# Amazon Jobs Scraper (`automation-lab/amazon-jobs-scraper`) Actor

Extract public Amazon.jobs listings, locations, teams, descriptions, and qualifications. Export structured hiring data and monitor roles by query or URL.

- **URL**: https://apify.com/automation-lab/amazon-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 7 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Amazon Jobs Scraper

Scrape public Amazon.jobs search results and job details with an HTTP-only Apify Actor. Use it to monitor Amazon hiring by role, city, country, team, business category, seniority signals, and remote or virtual wording.

### What does Amazon Jobs Scraper do?

Amazon Jobs Scraper collects structured job listings from the public Amazon.jobs career site. It queries the same public search data used by the website and saves normalized rows to an Apify dataset.

Each result can include the job title, job ID, job URL, location, team, business category, job category, dates, description, basic qualifications, and preferred qualifications.

### Who is it for?

- 🧑‍💼 Recruiters tracking Amazon hiring demand by market.
- 📊 Labor-market analysts measuring hiring velocity across Amazon teams.
- 🏢 Competitive-intelligence teams watching business-unit expansion.
- 🌍 Location strategy teams comparing open roles by country or city.
- 🤖 Automation builders feeding job intelligence into CRMs, dashboards, or alerts.

### Why use this actor?

- ✅ HTTP-only implementation, no browser overhead.
- ✅ Public Amazon.jobs data, no account required.
- ✅ Search URL mode for exact filters copied from Amazon.jobs.
- ✅ Query mode for simple keyword and location monitoring.
- ✅ Clean text extraction from HTML descriptions and qualification fields.

### What data can you extract?

| Field | Description |
| --- | --- |
| `jobId` | Amazon job identifier |
| `title` | Job title |
| `jobUrl` | Public Amazon.jobs detail URL |
| `location` | Main display location |
| `locations` | All normalized locations found in the source record |
| `countryCode` | Country code when provided by Amazon.jobs |
| `city` | City when provided |
| `state` | State or region when provided |
| `team` | Team label from Amazon.jobs |
| `businessCategory` | Business category slug or label |
| `jobCategory` | Job category |
| `postedDate` | Posted date when available |
| `updatedDate` | Updated timestamp when available |
| `jobType` | Primary search label when available |
| `schedule` | Schedule type when available |
| `remoteOrVirtual` | Remote/virtual signal derived from source text |
| `description` | Cleaned job description |
| `basicQualifications` | Cleaned basic qualifications |
| `preferredQualifications` | Cleaned preferred qualifications |
| `sourceSearchUrl` | Search URL that produced the result |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape Amazon jobs?

The actor uses pay-per-event pricing. A small start event covers run setup and a per-item event is charged for each saved job listing. Keep `maxItems` low for trial runs, then increase it once the query returns the type of jobs you need.

### How to use it

1. Open the actor on Apify.
2. Paste an Amazon.jobs search URL, or enter a role keyword and location.
3. Set `maxItems` to the number of jobs you need.
4. Run the actor.
5. Export the dataset as JSON, CSV, Excel, or via API.

### Input options

#### Search URL

Use this when you already configured filters on Amazon.jobs:

```json
{
  "searchUrl": "https://www.amazon.jobs/en/search?base_query=software&loc_query=Berlin",
  "maxItems": 25
}
````

#### Query mode

Use this for repeatable monitoring jobs:

```json
{
  "baseQuery": "data scientist",
  "locationQuery": "United States",
  "maxItems": 50
}
```

### Optional filters

The actor supports optional `jobCategory`, `businessCategory`, `country`, and `sort` fields. These are most useful when copied from a filtered Amazon.jobs URL or when you maintain a known taxonomy of Amazon.jobs categories. For plain city/country text, the actor resolves common Amazon hiring hubs (for example `Berlin` -> `city=Berlin&country=DEU`) and post-filters saved rows so ignored Amazon.jobs `loc_query` values do not return unrelated countries.

### Output example

```json
{
  "jobId": "1234567",
  "title": "Software Development Engineer",
  "jobUrl": "https://www.amazon.jobs/en/jobs/1234567/software-development-engineer",
  "location": "Berlin, BE, DEU",
  "countryCode": "DEU",
  "city": "Berlin",
  "team": "Amazon Web Services",
  "businessCategory": "amazon-web-services",
  "jobCategory": "software-development",
  "postedDate": "2026-06-01",
  "description": "Job description text...",
  "basicQualifications": "Basic qualifications text...",
  "preferredQualifications": "Preferred qualifications text...",
  "sourceSearchUrl": "https://www.amazon.jobs/en/search.json?base_query=software&loc_query=Berlin%2C+Germany&country=DEU&city=Berlin",
  "scrapedAt": "2026-06-14T00:00:00.000Z"
}
```

### Tips for better results

- 🔎 Start with a broad keyword, then narrow by location.
- 📍 Use Amazon.jobs URLs if you need exact filters; plain locations such as `Berlin` are enriched with country/city parameters when possible.
- 🧪 Test with `maxItems` 10–25 before larger monitoring runs.
- 🧹 Use `jobId` for de-duplication in downstream systems.
- 🕒 Schedule daily or weekly runs to monitor hiring changes.

### Common use cases

- Track Amazon software engineering openings in target cities.
- Monitor warehouse and operations hiring by country.
- Watch AWS or Devices team expansion.
- Build dashboards of Amazon hiring by business unit.
- Feed new Amazon job openings into Slack, Airtable, or a CRM.

### Integrations

Connect the dataset to:

- Google Sheets for lightweight reporting.
- Airtable for recruiting operations.
- Slack notifications for new matching jobs.
- BigQuery or Snowflake for labor-market analysis.
- Webhooks for automated lead or role monitoring workflows.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/amazon-jobs-scraper').call({
  baseQuery: 'software',
  locationQuery: 'Berlin',
  maxItems: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/amazon-jobs-scraper').call(run_input={
    'baseQuery': 'software',
    'locationQuery': 'Berlin',
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~amazon-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"baseQuery":"software","locationQuery":"Berlin","maxItems":25}'
```

### MCP usage

Use the Apify MCP server with Claude Code or Claude Desktop and enable this actor with:

```text
https://mcp.apify.com/?tools=automation-lab/amazon-jobs-scraper
```

Add it in Claude Code with:

```bash
claude mcp add apify-amazon-jobs https://mcp.apify.com/?tools=automation-lab/amazon-jobs-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-amazon-jobs": {
      "url": "https://mcp.apify.com/?tools=automation-lab/amazon-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Run Amazon Jobs Scraper for AWS roles in Seattle and summarize teams hiring most."
- "Find Amazon.jobs software openings in Berlin and export title, URL, and qualifications."
- "Monitor virtual Amazon roles and highlight senior management positions."

### Scheduling

For monitoring workflows, schedule the actor daily or weekly. Use the same query and compare `jobId` values across datasets to identify newly posted roles.

### Data quality notes

Amazon.jobs may not provide every field for every role. Fields such as `team`, `schedule`, `state`, or dates can be missing depending on the source record. The actor keeps unavailable values as `null` instead of guessing.

### Troubleshooting

#### Why did I get fewer jobs than `maxItems`?

The search may have fewer public results than requested, or filters may be too narrow. Try a broader keyword or remove optional category filters.

#### Why are some descriptions long?

Amazon job descriptions and qualifications are naturally detailed. The actor cleans HTML but preserves the text so downstream users can analyze requirements.

### Legality

This actor extracts publicly available job listing information. You should use the data responsibly, respect Amazon.jobs terms, and avoid collecting or processing personal data. If you are unsure, consult your legal advisor.

### FAQ

#### Can I scrape a filtered Amazon.jobs URL?

Yes. Paste the filtered URL into `searchUrl`; the actor converts it to the public JSON search endpoint and preserves supported query parameters.

#### Does this actor require an Amazon account?

No. It uses public Amazon.jobs search data and does not log in.

#### Can I monitor new jobs over time?

Yes. Schedule repeat runs and compare `jobId` values across datasets to detect new or removed roles.

### Related scrapers

- https://apify.com/automation-lab/linkedin-jobs-scraper
- https://apify.com/automation-lab/indeed-scraper
- https://apify.com/automation-lab/google-jobs-scraper
- https://apify.com/automation-lab/airbnb-careers-scraper

### Changelog

Initial version: public Amazon.jobs search scraping with normalized job listing output.

# Actor input Schema

## `searchUrl` (type: `string`):

Optional full Amazon.jobs search URL. If provided, it takes priority over the query fields below. The actor enriches common city/country loc\_query values (for example Berlin) with Amazon's country/city filters.

## `baseQuery` (type: `string`):

Keyword for the Amazon.jobs base\_query parameter, such as software, warehouse, data scientist, or product manager.

## `locationQuery` (type: `string`):

City, country, or region text. The actor resolves common Amazon hiring hubs (for example Berlin -> Germany/DEU) and post-filters saved jobs so plain location text does not return unrelated countries.

## `maxItems` (type: `integer`):

Maximum number of job listings to save. Keep this low for test runs and increase it for production monitoring.

## `jobCategory` (type: `string`):

Optional Amazon.jobs job category slug if you copied it from a filtered Amazon.jobs URL.

## `businessCategory` (type: `string`):

Optional Amazon.jobs business category slug if you copied it from a filtered Amazon.jobs URL.

## `country` (type: `string`):

Optional country fallback (name or Amazon country code such as Germany, DEU, United States, or USA) used when locationQuery is empty or to disambiguate a city.

## `sort` (type: `string`):

Optional sort value supported by Amazon.jobs URLs, for example recent.

## Actor input object example

```json
{
  "searchUrl": "https://www.amazon.jobs/en/search?base_query=software&loc_query=Berlin",
  "baseQuery": "software",
  "locationQuery": "Berlin",
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchUrl": "https://www.amazon.jobs/en/search?base_query=software&loc_query=Berlin",
    "baseQuery": "software",
    "locationQuery": "Berlin",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/amazon-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchUrl": "https://www.amazon.jobs/en/search?base_query=software&loc_query=Berlin",
    "baseQuery": "software",
    "locationQuery": "Berlin",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/amazon-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchUrl": "https://www.amazon.jobs/en/search?base_query=software&loc_query=Berlin",
  "baseQuery": "software",
  "locationQuery": "Berlin",
  "maxItems": 20
}' |
apify call automation-lab/amazon-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/amazon-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Jobs Scraper",
        "description": "Extract public Amazon.jobs listings, locations, teams, descriptions, and qualifications. Export structured hiring data and monitor roles by query or URL.",
        "version": "0.1",
        "x-build-id": "pE09HaKPeNhuYDNPd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~amazon-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-amazon-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~amazon-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-amazon-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~amazon-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-amazon-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchUrl": {
                        "title": "🔎 Amazon.jobs search URL",
                        "type": "string",
                        "description": "Optional full Amazon.jobs search URL. If provided, it takes priority over the query fields below. The actor enriches common city/country loc_query values (for example Berlin) with Amazon's country/city filters."
                    },
                    "baseQuery": {
                        "title": "Role or keyword",
                        "type": "string",
                        "description": "Keyword for the Amazon.jobs base_query parameter, such as software, warehouse, data scientist, or product manager.",
                        "default": "software"
                    },
                    "locationQuery": {
                        "title": "Location query",
                        "type": "string",
                        "description": "City, country, or region text. The actor resolves common Amazon hiring hubs (for example Berlin -> Germany/DEU) and post-filters saved jobs so plain location text does not return unrelated countries.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of job listings to save. Keep this low for test runs and increase it for production monitoring.",
                        "default": 20
                    },
                    "jobCategory": {
                        "title": "Job category filter",
                        "type": "string",
                        "description": "Optional Amazon.jobs job category slug if you copied it from a filtered Amazon.jobs URL."
                    },
                    "businessCategory": {
                        "title": "Business/team category filter",
                        "type": "string",
                        "description": "Optional Amazon.jobs business category slug if you copied it from a filtered Amazon.jobs URL."
                    },
                    "country": {
                        "title": "Country/location fallback",
                        "type": "string",
                        "description": "Optional country fallback (name or Amazon country code such as Germany, DEU, United States, or USA) used when locationQuery is empty or to disambiguate a city."
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "",
                            "recent"
                        ],
                        "type": "string",
                        "description": "Optional sort value supported by Amazon.jobs URLs, for example recent."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```