# Amazon Email Scraper (`scrapepilotapi/amazon-email-scraper`) Actor

- **URL**: https://apify.com/scrapepilotapi/amazon-email-scraper.md
- **Developed by:** [ScrapePilot](https://apify.com/scrapepilotapi) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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 📱

The **Amazon** Email Scraper allows users to **extract** a variety of **data** points from **Amazon**'s platform. This includes **contact** information for sellers, such as email addresses, which can be used for marketing, research, or business outreach.

The tool also captures seller names, business names, and other relevant details. By using this **Amazon** email finder software, users can efficiently gather **data** without manual effort.

The **extract**ed **data** is organized and exportable, making it easy to integrate into your existing systems. This **Amazon** email scraping service is designed to provide accurate and up-to-date information for your business needs.

Amazon Email Scraper is a powerful tool designed to help users extract email addresses from Amazon efficiently and accurately. It enables businesses and individuals to connect with Amazon sellers and buyers for various purposes.

With the Amazon email extraction tool, you can streamline your outreach efforts by gathering contact information directly from Amazon's platform. This tool is ideal for marketers, researchers, and businesses looking to expand their network.

The Amazon Email Scraper simplifies the process of finding seller contact details, saving you time and effort. It provides a reliable way to extract emails from Amazon while ensuring data accuracy.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Seller Email Addresses | Extract verified email addresses of Amazon sellers for outreach and communication. |
| Seller Names | Retrieve the names of sellers associated with the extracted email addresses. |
| Business Names | Gather the business names of Amazon sellers for better identification. |
| Product Listings | Extract links to product listings associated with the sellers. |
| Seller Ratings | Collect seller ratings to evaluate their performance and credibility. |
| Location Information | Retrieve location details of sellers if available on their profiles. |
| Contact Numbers | Extract phone numbers of sellers when provided in their profiles. |
| Seller URLs | Capture direct links to seller profiles for further analysis. |

### Key Features of **Amazon** Email Scraper

Here are the **standout features** that make the **Amazon** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ Extracts email addresses from **Amazon** sellers quickly and accurately
- ⭐ Supports bulk data extraction for large-scale operations
- ⭐ Provides detailed seller information including names and business details
- ⭐ User-friendly interface for easy navigation and operation
- ⭐ Exports data in multiple formats for seamless integration with other tools
- ⭐ **Advanced** filtering options to refine your data extraction process
- ⭐ **Regular** updates to ensure compatibility with **Amazon**s platform changes
- ⭐ **High**ly secure and compliant with data protection regulations
- ⭐ **Customizable** settings to meet specific user requirements
- ⭐ Offers 247 customer support for troubleshooting and assistance

### How to use **Amazon** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Amazon** emails today:

1. ✅ **Sign up** for an account or **log in** to the **Amazon** Email Scraper platform
2. ✅ Download and install the **Amazon** email extraction tool on your device
3. ✅ Enter the keywords or criteria for the sellers you want to target
4. ✅ **Select** the data types you wish to extract such as email addresses or seller names
5. ✅ **Configure** the advanced filtering options to narrow down your search results
6. ✅ **Start** the scraping process and monitor the progress on the dashboard
7. ✅ Once the scraping is complete review the extracted data for accuracy
8. ✅ **Export** the data in your preferred format such as CSV or Excel
9. ✅ **Integrate** the exported data into your CRM or marketing tools
10. ✅ Repeat the process as needed to keep your data up-to-date

### Use Cases 🎯

Marketing Campaigns
🎯 **Use** the **Amazon** Email Scraper to gather seller emails for targeted email campaigns
🎯 Expand your outreach efforts by connecting with **Amazon** sellers directly

Business Research
🎯 Extract seller data to analyze market trends and competitor activities
🎯 **Identify** potential partners or suppliers on **Amazon**s platform

Lead Generation
🎯 Generate leads by collecting contact information of **Amazon** sellers
🎯 Build a database of potential clients for your business

Customer Support
🎯 **Find** seller contact details to resolve customer issues more efficiently
🎯 Reach out to sellers for product inquiries or support requests

### Why choose us? 💎

Our **Amazon** Email Scraper is the **best** **Amazon** email scraper for professionals who need **reliable** and efficient data extraction. It is designed with **user-friendly** features that make it accessible to both beginners and **advanced** users.

The tool supports bulk data extraction, allowing you to gather large amounts of information in a short time. With **advanced** filtering options, you can customize your scraping process to meet specific requirements.

We prioritize data accuracy and compliance with legal guidelines to ensure a trustworthy experience. Our **Amazon** email scraping service is backed by a dedicated support team available 24/7 to assist you.

By choosing our **Amazon** email finder software, you can save time, reduce manual effort, and focus on growing your business.

### **Amazon** Email Scraper Scalability 📈

The **Amazon** Email Scraper is built to handle data extraction at any scale, making it suitable for businesses of all sizes. Whether you need to extract a few hundred emails or thousands, the tool performs **efficient**ly without compromising accuracy.

Its robust infrastructure ensures smooth operation even during **large-scale** scraping tasks. The tool's scalability is complemented by **customizable** settings, allowing you to tailor the process to your specific needs.

Regular updates ensure compatibility with **Amazon**'s evolving platform, keeping your data extraction **seamless**. With our **Amazon** email harvesting tool, you can confidently scale your operations as your business grows.

### **Amazon** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Amazon** is **legal** as long as you follow **ethical** and **compliant** practices. The **Amazon** Email Scraper extracts only **publicly available** information from **public** **Amazon** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Amazon**s terms of service while using the scraper
⚖️ **Do not** use the extracted data for unsolicited or spam email campaigns
⚖️ Respect data privacy laws such as GDPR and CCPA when handling extracted information
⚖️ **Avoid** scraping sensitive or personal data that is not publicly available
⚖️ **Use** the tool responsibly and only for legitimate business purposes
⚖️ Regularly review updates to **Amazon**s policies to ensure continued compliance
⚖️ **Do not** resell or distribute the extracted data without proper authorization
⚖️ Seek legal advice if unsure about the legality of your scraping activities

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Amazon Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Amazon",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (Amazon) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Amazon",
    "keyword": "Amazon Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Amazon as the source |
| keyword | Keyword that triggered the result (Amazon Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Amazon profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Amazon **Email Scraper**?

Amazon Email Scraper is a tool designed to extract email addresses and other seller information from Amazon's platform.

#### How does the Amazon email **extract**ion tool work?

The tool uses advanced algorithms to scan Amazon's platform and extract relevant data based on your criteria.

#### Is the Amazon **Email Scraper** **legal** to use?

**Yes**, but it must be used in **compliance** with Amazon's terms of service and applicable data privacy laws.

#### Can I **extract** bulk data using this tool?

**Yes**, the Amazon Email Scraper supports bulk data extraction for large-scale operations.

#### What formats can I **export** the data in?

You can export the extracted data in formats like **CSV** and Excel for easy integration.

#### Is the tool compatible with all devices?

The Amazon Email Scraper is compatible with most devices and operating systems.

#### How accurate is the **extract**ed data?

The tool is designed to provide highly accurate and up-to-date data.

#### Can I customize the scraping process?

**Yes**, the tool offers advanced **filtering** options to customize your data extraction.

#### Is **customer support** available?

**Yes**, we offer 24/7 customer support to assist with any issues or questions.

#### What is the best Amazon email scraper for businesses?

Our Amazon Email Scraper is considered the best due to its reliability, scalability, and **user-friendly** features.

#### Can I scrape emails from Amazon sellers?

**Yes**, the tool is specifically designed to extract **emails** from Amazon sellers.

#### Does the tool comply with GDPR and CCPA?

**Yes**, the Amazon Email Scraper is designed to comply with GDPR, CCPA, and other data privacy regulations.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with Amazon's platform changes.

#### Can I use the tool for **lead generation**?

**Yes**, the Amazon Email Scraper is ideal for generating leads by collecting seller contact information.

#### Is there a free trial available?

Please check our website for information on free trials and pricing options.

# Actor input Schema

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

List of keywords to search for on Amazon (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Amazon profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

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

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

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

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `proxyConfiguration` (type: `object`):

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Amazon",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilotapi/amazon-email-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 = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilotapi/amazon-email-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 '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapepilotapi/amazon-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Email Scraper",
        "version": "0.1",
        "x-build-id": "tobWxdfcyL9s0Gmk3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~amazon-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-amazon-email-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/scrapepilotapi~amazon-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-amazon-email-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/scrapepilotapi~amazon-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-amazon-email-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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Amazon (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Amazon profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Amazon"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Amazon"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```