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

📧 Extract verified business emails fast with Email Scraper Fast Advanced & Cheapest. Find targeted leads by keyword, industry & location—save hours of prospecting for sales, marketing & agencies. ⚡🔍 Get results now!

- **URL**: https://apify.com/solid-scraper/amazon-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (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 $2.99 / 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 📬

**Amazon Email Scraper - Fast, Advanced and Cheapest** helps you **extract email addresses from publicly available Amazon sources** using the keywords and email-domain filters you choose. Whether you’re a marketer, business developer, researcher, or lead-generation specialist, this **Amazon email scraper** and **Amazon seller email scraper** streamlines the work of finding outreach contacts—so you can build an **Amazon outreach email list** faster and at scale.

---

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

| Feature | Benefit |
| --- | --- |
| ✅ All-in-one email extraction | Extract emails from Amazon using your **keywords** and **custom domains** in one run |
| ✅ Reliability with built-in resilience | Designed to keep scraping steady with retries and fallbacks when results are limited |
| ✅ Control over how many emails you collect | Use `maxEmails` to cap results and help manage scraping time and cost |
| ✅ Structured, dataset-ready output | Outputs consistent records you can export directly for outreach or analysis |
| ✅ Scales across keywords and domains | Runs across your keyword list and custom email domains to widen coverage |
| ✅ Apify-friendly automation | Works smoothly in the Apify environment so you can schedule and repeat runs easily |

---

### Key features

- 🔍 **Keyword + domain targeting**: Use your `keywords` to find relevant leads and `customDomains` (like `@gmail.com`) to focus email extraction.
- ⚙️ **Location filtering**: Optionally set `location` to narrow results to a specific geography.
- 🎯 **Max emails limit**: Stop at your `maxEmails` target to control runtime and budget (doesn’t guarantee reaching the number).
- 🛡️ **Resilience when results are limited**: Includes retries and fallbacks to improve success when scraping returns fewer results than expected.
- 📁 **Incremental dataset saving**: Each discovered record is pushed as it’s found, reducing the chance of losing progress mid-run.
- 🔄 **Progress resume support**: Maintains cursor progress so a rerun can resume instead of starting from scratch.
- 📊 **Clear lead records**: Each dataset row includes the keyword, title, description, source URL, and extracted email—ready for downstream workflows.
- 💾 **Easy export for analysis or outreach**: Output lands in the **Amazon Emails Dataset** in a table-friendly structure.

---

### Input

Provide input via an `input.json` file. Example structure:

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | ✅ Yes | A list of keywords (or keyword phrases) the actor uses to find relevant Amazon leads to scrape emails from. |
| `location` | ❌ No | Location text used to filter results. Leave it empty if you don’t want location-based filtering. |
| `customDomains` | ❌ No | A list of email domains the actor should look for while extracting emails (for example `@gmail.com`, `@yahoo.com`). |
| `maxEmails` | ❌ No | Maximum number of emails to collect. The actor stops once this limit is reached. Higher values may take longer and still don’t guarantee hitting the exact number. |

***

### Output

The actor saves the scraped results into the **Amazon Emails Dataset** as individual JSON records with fields describing the lead and the extracted email.

#### Output JSON example

```json
{
  "network": "Amazon.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "example@gmail.com"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `network` | string | Source network label (set to `Amazon.com`). |
| `keyword` | string | The keyword currently being used when extracting this email. |
| `title` | string | The result title text associated with the lead (or `No title` if unavailable). |
| `description` | string | Extracted description text that may include contact details (or `No data` if unavailable). |
| `url` | string | The source URL for the lead (or `No URL` if unavailable). |
| `email` | string | The extracted email address for the lead. |

You can export your dataset from Apify in common formats like JSON and CSV for use in your **Amazon email finder tool** workflows.

***

### How to use Amazon Email Scraper - Fast, Advanced and Cheapest (via Apify Console)

1. **Open Apify Console**: Log in at https://console.apify.com and open the **Actors** tab.
2. **Find the actor**: Search for **Amazon Email Scraper - Fast, Advanced and Cheapest** in the marketplace.
3. **Configure INPUT**: In the Input section, provide your `keywords`. Optionally add `location`, `customDomains`, and `maxEmails`.
4. **Choose proxy settings (optional)**: This actor is designed with built-in proxy support for reliable scraping. You can run with default behavior in Apify.
5. **Click Run**: Start the actor and watch the live logs. During the run, it will push found contacts incrementally to the dataset.
6. **Monitor progress**: If you stop and rerun, the actor can resume using saved progress (cursor state and already-seen emails).
7. **Open OUTPUT dataset**: When finished, go to the dataset named **Scraped Leads** inside **Amazon Emails Dataset**.
8. **Export your results**: Export to JSON/CSV and plug the results into your outreach pipeline or analytics tooling.

No coding required—you’ll get **Amazon seller email scraper**-ready records in minutes.

***

### Advanced features & SEO optimization

- 🚀 **Engineered for Amazon email extraction**: Built specifically for “Amazon email scraper” style lead research, including **Amazon contact email finder** use cases.
- 🔁 **Resume & deduplication**: Maintains a `seen_emails` list and a saved cursor so duplicates are avoided and interrupted runs can continue.
- 🧭 **Coverage through keyword × domain combinations**: Runs across your `keywords` and `customDomains` to improve the odds of uncovering outreach contacts.
- 🧠 **Smart guidance when results are limited**: If you collect fewer emails than your target, the actor suggests widening keywords, adding similar terms, or including more domains.
- 🕒 **Timeout-aware runs**: The input instructions note that larger searches/higher limits can take longer, and you can extend timeout in **Run Options** (default: 3600 seconds / 1 hour).

***

### Best use cases

- 📈 **Amazon outreach email list building**: Generate targeted contact leads by combining job-title keywords (like “manager” or “founder”) with email-domain filters.
- 🧾 **B2B email enrichment for Amazon sellers**: Enrich CRM records by extracting likely contact emails tied to Amazon presence.
- 🧑‍💼 **Sales prospecting for Amazon marketplaces**: Quickly collect emails for lead generation campaigns without manually scanning profiles.
- 🔎 **Market research and competitive analysis**: Scrape emails from publicly available sources to understand who is reachable in a niche.
- 🏭 **Supplier contact discovery**: Use role-focused keywords to find supplier-facing contacts and build an **Amazon supplier email scraper** dataset.
- 📬 **Customer support outreach campaigns**: Target emails for customer engagement and partnerships using consistent domain filters.
- 💻 **Data analyst pipelines**: Feed structured dataset rows (`keyword`, `url`, `email`) into analysis or reporting workflows.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array
  - ✅ `location` as a string (optional)
  - ✅ `customDomains` as an array (optional)
  - ✅ `maxEmails` as an integer (optional; range described in input schema)

- **Proxy Support**
  - ✅ Built-in proxy support for reliable scraping

- **Retry Mechanism**
  - ✅ Includes retries and fallbacks for resilience when results are limited

- **Dataset Structure**
  - ✅ **Amazon Emails Dataset** → view: **Scraped Leads**
  - ✅ Fields include: `keyword`, `title`, `description`, `url`, `email`

- **Rate Limits & Performance**
  - ✅ Larger searches or higher limits can take longer (timeout guidance is included in the input description)

- **Limitations**
  - ❌ Results may be limited depending on what’s available from publicly available sources
  - ❌ Collecting emails matching your `maxEmails` target is not guaranteed

***

### FAQ

#### Does Amazon Email Scraper - Fast, Advanced and Cheapest guarantee finding exactly `maxEmails`?

❌ No. `maxEmails` is a cap that stops the scraper once the limit is reached, but it doesn’t guarantee that the actor will reach that number—results depend on what’s available in the publicly accessible sources it scans.

#### What email types does this Amazon email scraper extract?

✅ It extracts email addresses that match the email-domain filters you provide in `customDomains` (for example `@gmail.com`, `@yahoo.com`). Each pushed record includes the extracted `email` value.

#### Can I limit results to a specific location?

✅ Yes. Use the `location` field to filter results by geography. If you leave it empty, the scraper runs without location filtering.

#### Is there any resume support if my run stops?

✅ Yes. The actor saves progress using a cursor state and tracks `seen_emails`, so reruns can resume rather than starting completely from scratch.

#### What does the dataset row contain?

✅ Each dataset record includes `network`, `keyword`, `title`, `description`, `url`, and `email`. These fields are designed to be directly usable for outreach targeting and downstream enrichment.

#### What happens if results are limited?

✅ The actor is designed with resilience (retries and fallbacks). If emails are limited, the actor recommends practical adjustments like using wider keywords, adding similar terms, or including more domains.

#### Do I need to write code to run this Amazon lead email scraper?

✅ No. You can configure everything in Apify Console by filling the INPUT fields and then run the actor. The output is written directly into the dataset.

***

### Support & feature requests

Want to improve your results with **Amazon Email Scraper - Fast, Advanced and Cheapest**? Share feedback and feature requests—we use it to shape the roadmap.

- 💡 **Feature Requests**: Examples include CSV export enhancements, additional output fields, or more flexible domain/email filtering options tailored for an **Amazon email extraction software** workflow.
- 📧 **Contact**: Email <dataforleads@gmail.com>

Thanks for helping make the **Amazon email scraper** experience better with every run! 🚀

***

### Closing CTA / Final thoughts

*If you’re looking for the most comprehensive and SEO-optimized way to scrape Amazon emails, **Amazon Email Scraper - Fast, Advanced and Cheapest** is built for exactly that.*\
Run it with focused keywords and custom domains to get results that are ready for outreach at scale. 📬

***

### Disclaimer

**This tool only accesses publicly accessible sources** to extract emails. It does not access private profiles, authenticated data, or password-protected pages. It’s your responsibility to comply with applicable laws and regulations (including GDPR and CCPA where relevant), spam rules, and platform terms of service.

For data-removal requests, contact <dataforleads@gmail.com>. Please use this tool responsibly, ethically, and for legitimate purposes only.

# 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("solid-scraper/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("solid-scraper/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 solid-scraper/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=solid-scraper/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 verified business emails fast with Email Scraper Fast Advanced & Cheapest. Find targeted leads by keyword, industry & location—save hours of prospecting for sales, marketing & agencies. ⚡🔍 Get results now!",
        "version": "1.0",
        "x-build-id": "ITVBeATf59FT6rLje"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~amazon-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-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/solid-scraper~amazon-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-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/solid-scraper~amazon-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
