# Amazon Email Scraper Fast Advanced And Cheapest (`scraperoka/amazon-email-scraper-fast-advanced-and-cheapest`) Actor

🔍 Extract emails fast with Amazon Email Scraper Fast Advanced And Cheapest! 🚀 Get targeted leads for B2B outreach, marketing, and recruitment. ⚡ Affordable, efficient, and easy to use—save time and grow your pipeline!

- **URL**: https://apify.com/scraperoka/amazon-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Email Scraper - Fast, Advanced and Cheapest 🎯

Manually collecting email leads from Amazon can waste hours—especially when you’re trying to build a targeted outreach list fast. **Amazon Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from Amazon based on the keywords and filters you choose, so you can assemble an Amazon contact email finder list without the busywork. This Amazon email scraper tool is ideal for marketers, recruiters, and growth teams that need fast Amazon email scraping results. In a single run, you can collect thousands of leads in minutes—then export and use them immediately.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Amazon.com",
  "keyword": "manager",
  "title": "Example Amazon profile result title",
  "description": "Example publicly available snippet text that may contain john.doe@gmail.com and other contact details.",
  "url": "https://www.example.com/amazon-result-url",
  "email": "john.doe@gmail.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network for your lead (reported as `Amazon.com`). |
| `keyword` | string | Which keyword drove this result, so you can trace lead sources for optimization. |
| `title` | string | The result title text captured alongside the email. |
| `description` | string | The extracted snippet text used to find the email on the result page. |
| `url` | string | The link associated with the result where the email was found. |
| `email` | string | The actual email address collected for outreach or enrichment. |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Amazon Email Scraper - Fast, Advanced and Cheapest?

There are a lot of ways to pull data from Amazon—here’s what sets **Amazon Email Scraper - Fast, Advanced and Cheapest** apart.

#### Keyword-Driven Lead Finding

You provide your own `keywords` to drive the email harvesting workflow, making it easier to run an Amazon outreach email list that matches your niche (for example, manager- or founder-focused searches). Using an Amazon email search automation approach means you can iterate quickly when results are too narrow.

#### Domain Filters for Cleaner Matches

You can restrict results using `customDomains` (like `@gmail.com` or `@yahoo.com`) so the Amazon seller email extractor output focuses on the email types you actually want. This is especially useful when building B2B lead generation Amazon emails lists where you want consistent domains.

#### Max Limit Control for Cost-Safe Scraping

The actor supports `maxEmails` to stop once a target number of emails is reached. That makes it easier to run tests, control runtime, and avoid spending too long on diminishing returns—one of the key reasons it’s often chosen as the cheapest Amazon email scraper option.

#### Resumable Progress for Longer Runs

If your run is interrupted, it can resume using saved progress state (including already-seen emails). This helps keep your Amazon contact email finder workflow efficient and reduces duplicate work across sessions.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["manager", "founder"],
  "location": "New York, NY",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords (or queries) the actor uses to find relevant Amazon results from which it extracts emails. |
| `location` | ⬜ | Optional location filter to help narrow the results. |
| `customDomains` | ⬜ | List of email domains (for example `@gmail.com`, `@yahoo.com`) the actor uses to focus extracted emails on specific domain types. |
| `maxEmails` | ⬜ | Maximum number of emails to collect. The scraper stops once this limit is reached (useful for controlling runtime and testing). |

***

### Core Capabilities

#### Amazon Email Extraction from Public Sources

The actor extracts email addresses from Amazon based on your inputs. It’s designed for anyone doing scrape Amazon customer emails or building an Amazon lead list email scraper for outreach.

#### Flexible Inputs for Targeted Results

You control what “relevant” means by setting `keywords` and (optionally) `location` and `customDomains`. This flexibility supports both fast Amazon email scraping and more advanced Amazon email scraper workflows when you need tighter targeting.

#### Deduplicated Email Collection

The actor keeps track of already-seen emails so you don’t repeatedly collect the same address in the same overall run. That helps your output stay clean for importing into CRM and outreach tools.

#### Resilient, Long-Run Friendly Behavior

Longer runs can take time, but the actor supports resumable progress and includes logic to stop when it detects diminishing results. This makes it a practical Amazon email harvesting software choice for list-building campaigns.

#### Structured Dataset Output

Each found lead is pushed into the dataset incrementally with consistent fields like `keyword`, `url`, and `email`. That means you can start reviewing and exporting results as the run progresses.

***

### Who Gets the Most Out of This

If you’re building an Amazon outreach email list, marketing teams benefit from controlling both keywords and email-domain filters to quickly assemble a usable contact set for campaigns. Recruiters and growth teams can use targeted `keywords` to focus on roles and decision-makers, then export results to move straight into outreach workflows.

**Sales development reps** can run an Amazon contact email finder job to turn a topic list into leads—collecting emails tied to the search terms they care about. This is especially helpful when you need B2B lead generation Amazon emails rather than generic lists.

**Data analysts and researchers** can use the dataset fields (`keyword`, `description`, `url`, `email`) to evaluate which inputs yield the most contacts and refine keyword/domain strategy for subsequent runs. They can also combine results with other datasets outside Apify.

**Automation specialists and developers** can integrate this Amazon email search automation output into pipelines via the Apify API, using the consistent dataset records for downstream enrichment and deduplication.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Amazon Email Scraper - Fast, Advanced and Cheapest from start to finish:

1. **Open the actor on Apify** — go to <https://console.apify.com> and find the actor by name.
2. **Enter your inputs** — set `keywords` (required), and optionally `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — use the Apify UI to enable proxy support for more reliable scraping runs.
4. **Hit Run and watch the live log** — monitor progress and make sure you’re getting new emails.
5. **View results in the dataset tab** — leads appear incrementally with fields like `keyword`, `url`, and `email`.
6. **Export as JSON, CSV, or Excel** — download what you need for outreach, CRM import, or analysis.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Amazon Email Scraper - Fast, Advanced and Cheapest plugs directly into your existing workflow.

Export formats are available from the Apify dataset tab, including JSON, CSV, and Excel. For teams who need to push leads elsewhere, you can connect the actor output using Apify integrations or automation tools such as Zapier/Make to move results into your CRM or spreadsheets.

You can also access run results programmatically via the Apify API (see [apify.com/docs/api](https://apify.com/docs/api)) and trigger downstream actions with webhooks when you need automation beyond manual exports.

***

### Pricing & Free Trial

Amazon Email Scraper - Fast, Advanced and Cheapest runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier usage is intended for testing and smaller runs (and limits may apply). For larger jobs, you can use Apify’s pay-as-you-go billing model based on platform compute. For the most up-to-date plan and pricing details, check the Apify pricing page.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Resumable progress | Keeps track of already-seen emails and saved cursor state to continue efficiently. |
| Result limiting | Uses `maxEmails` to stop once the target is reached. |
| Duplicate avoidance | Tracks collected emails to reduce repeated entries. |
| Resilience during runs | Includes logic to stop when results are no longer being produced. |

**Limitations:** This actor works with publicly available web data that can be read without login. It can only extract emails that appear in the collected result content, so results depend on what’s published for your chosen keywords and `customDomains`.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes—Apify offers a free tier for trying out actors. The exact amount you can collect depends on your run inputs and whether free-tier limitations apply.

#### Do I need to log in to use Amazon Email Scraper - Fast, Advanced and Cheapest?

No. The actor is designed to extract emails from publicly available sources without requiring you to log in.

#### How accurate is the data?

Accuracy depends on what email addresses are actually present in the publicly available result content. The actor extracts email addresses that match your domain filters, such as `@gmail.com`, based on the collected text.

#### How many results can I get per run?

You control the maximum with `maxEmails`, which stops the run once the limit is reached. If results are sparse, you may collect fewer than your requested limit.

#### How often is the data updated / how fresh is it?

The dataset reflects what is available during your run. If you need fresher leads, simply run the actor again with updated keywords or domain filters.

#### Is this legal? Does it comply with GDPR / CCPA?

Use of this actor is intended for data available from publicly available sources. You are responsible for ensuring your use complies with GDPR, CCPA, applicable laws, and platform terms.

#### Can I export results to Google Sheets or Excel?

You can export from the Apify dashboard in formats like JSON, CSV, or Excel. From there, you can import into Google Sheets or connect via automation tools if that fits your workflow.

#### Can I run this on a schedule automatically?

Yes. You can schedule runs via Apify’s scheduling features so the actor runs automatically on a recurring schedule.

#### Can I access this via API?

Yes. You can use the Apify API to trigger runs and fetch results programmatically (see [apify.com/docs/api](https://apify.com/docs/api)).

#### What happens if the actor hits an error?

The actor continues to write successful results incrementally to your dataset. If errors occur, the run may stop or skip forward depending on the failure mode, but your already-collected data remains available in the dataset.

***

### Need Help or Have a Request?

Got a question about Amazon Email Scraper - Fast, Advanced and Cheapest or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with input tuning (keywords, `customDomains`, and `maxEmails`) and to discuss ideas like webhook notifications on completion or batch CSV upload for keyword sets.

***

### Disclaimer & Responsible Use

*Amazon Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to extract Amazon contact email leads — start your free run today.*

By using this actor, you agree to use **publicly available data** only. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform terms, and any applicable regulations. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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 = {
    "keywords": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/amazon-email-scraper-fast-advanced-and-cheapest").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 = {
    "keywords": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/amazon-email-scraper-fast-advanced-and-cheapest").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 '{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scraperoka/amazon-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/amazon-email-scraper-fast-advanced-and-cheapest",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Email Scraper Fast Advanced And Cheapest",
        "description": "🔍 Extract emails fast with Amazon Email Scraper Fast Advanced And Cheapest! 🚀 Get targeted leads for B2B outreach, marketing, and recruitment. ⚡ Affordable, efficient, and easy to use—save time and grow your pipeline!",
        "version": "1.0",
        "x-build-id": "d8YhZ82dZEikEwjM3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~amazon-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-amazon-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~amazon-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-amazon-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~amazon-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-amazon-email-scraper-fast-advanced-and-cheapest",
                "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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
