# Amazon B2B Email Scraper (`scrapeflow/amazon-b2b-email-scraper`) Actor

📧 Amazon B2B Email Scraper finds verified business emails from Amazon listings—fast, accurate, and easy to export. Perfect for B2B prospecting, lead generation, and outreach. 🚀 Automate your pipeline and save hours. ✅

- **URL**: https://apify.com/scrapeflow/amazon-b2b-email-scraper.md
- **Developed by:** [ScrapeFlow](https://apify.com/scrapeflow) (community)
- **Categories:** Lead generation, Automation, E-commerce
- **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** B2B Email Scraper allows users to **extract** a wide range of **data** from **Amazon** sellers and vendors. It focuses on gathering **contact** information, including email addresses, to support B2B lead generation.

The tool is designed to provide accurate and comprehensive results, ensuring that users have access to reliable **data** for their marketing campaigns. In addition to email addresses, users can **extract** details such as seller names, business locations, and product categories.

This automated email scraper for **Amazon** simplifies the **data** collection process, making it faster and more efficient. By using this tool, businesses can build a robust email **data**base for outreach and communication.

The **extract**ed **data** is presented in a structured format, making it easy to integrate into existing CRM or marketing systems. This **Amazon** business email finder is ideal for companies looking to streamline their lead generation efforts and enhance their marketing strategies.

Amazon B2B Email Scraper is a powerful tool designed to help businesses extract valuable contact information from Amazon. It simplifies the process of gathering B2B email addresses for lead generation and outreach purposes.

Using an Amazon email scraping software, you can efficiently collect data from Amazon sellers and vendors. This tool is ideal for businesses looking to expand their network and build a robust email database.

The Amazon B2B Email Scraper automates the extraction process, saving time and effort for users. It is a reliable solution for those who need accurate and up-to-date contact information for their marketing campaigns.

### 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 |
| --- | --- |
| Email Address | Accurate email addresses of Amazon sellers and vendors for B2B communication. |
| Seller Name | Full names of sellers or vendors listed on Amazon. |
| Business Location | Geographical information about the seller's or vendor's location. |
| Product Categories | Details about the product categories the seller or vendor operates in. |
| Seller Ratings | Ratings and reviews associated with the seller or vendor. |
| Contact Numbers | Phone numbers provided by sellers or vendors, if available. |
| Business Website | Links to the seller's or vendor's business website, if listed. |
| Seller ID | Unique identification numbers for sellers or vendors on Amazon. |

### 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**:

- ⭐ **Automated** extraction of B2B email addresses from **Amazon** sellers and vendors
- ⭐ Supports lead generation by providing accurate and up-to-date contact information
- ⭐ **Customizable** data scraping options to suit specific business needs
- ⭐ User-friendly interface for seamless operation and data collection
- ⭐ Structured data output for easy integration with CRM systems
- ⭐ **High**-speed scraping capabilities to save time and effort
- ⭐ **Comprehensive** data coverage including seller names locations and product categories
- ⭐ Compliance with legal and ethical guidelines for data scraping
- ⭐ **Regular** updates to ensure compatibility with **Amazon**s platform changes
- ⭐ **Secure** and reliable tool for extracting business-critical information

### 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 on the **Amazon** B2B Email Scraper platform
2. ✅ Log in to your account and navigate to the dashboard
3. ✅ Enter the required search criteria such as product categories or seller locations
4. ✅ **Configure** the scraping settings to specify the data you want to extract
5. ✅ **Start** the scraping process and monitor the progress in real-time
6. ✅ Once the scraping is complete download the extracted data in your preferred format
7. ✅ **Review** the data to ensure accuracy and relevance for your needs
8. ✅ **Integrate** the data into your CRM or marketing system for further use
9. ✅ Use the extracted email addresses for B2B outreach and lead generation campaigns
10. ✅ Regularly update your scraping settings to adapt to changes on **Amazon**s platform

### Use Cases 🎯

Lead Generation for B2B Marketing
🎯 Extract email addresses of **Amazon** sellers to expand your contact list
🎯 **Identify** potential business partners or clients through targeted searches

Building a B2B Email Database
🎯 Create a comprehensive database of seller and vendor contacts
🎯 **Use** structured data for efficient communication and outreach

Market Research and Analysis
🎯 Gather data on seller locations and product categories for market insights
🎯 **Analyze** seller ratings and reviews to identify top-performing vendors

Improving Vendor Relationships
🎯 **Use** contact information to establish direct communication with vendors
🎯 Strengthen relationships with sellers through personalized outreach

### Why choose us? 💎

The **Amazon** B2B Email Scraper stands out for its efficiency and reliability in extracting valuable contact information. Our tool is designed to meet the needs of businesses looking to enhance their lead generation efforts.

With a **user-friendly** interface and customizable options, it offers a seamless experience for users of all technical levels. We prioritize data accuracy and ensure that the extracted information is up-to-date and relevant.

Our scraper complies with legal and ethical guidelines, providing businesses with a secure and trustworthy solution. By automating the data collection process, we help users save time and focus on their core business activities.

Our dedicated support team is available to assist with any queries or issues, ensuring a smooth experience. Whether you are a small business or a large enterprise, our tool is **scalable** to meet your specific requirements.

Choose the **Amazon** B2B Email Scraper for a **reliable**, efficient, and compliant solution to your data extraction needs.

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

The **Amazon** B2B Email Scraper is designed to handle data extraction tasks of any scale. Whether you need a small dataset or a large volume of information, our tool can adapt to your requirements.

It offers high-speed scraping capabilities, ensuring quick and **efficient** data collection. The tool is suitable for businesses of all sizes, from startups to large enterprises.

Its **customizable** settings allow users to focus on specific data points, making it versatile and flexible. By automating the process, it eliminates the need for manual data collection, saving time and resources.

Regular updates ensure compatibility with **Amazon**'s platform, keeping the tool relevant and effective. With the **Amazon** B2B Email Scraper, you can scale your lead generation efforts without compromising on quality or accuracy.

### **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 when using the scraper
⚖️ **Do not** use the tool for unauthorized or unethical purposes
⚖️ Respect data privacy laws and regulations in your region
⚖️ **Avoid** scraping personal information not intended for public use
⚖️ **Use** the extracted data only for legitimate business purposes
⚖️ **Obtain** consent before contacting individuals using the extracted information
⚖️ Regularly review legal updates to ensure ongoing compliance
⚖️ **Do not** share or sell the extracted data without proper authorization

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Amazon B2B 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 B2B 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 B2B 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 the Amazon B2B **Email Scraper**?

It is a tool designed to extract B2B email addresses and other contact information from Amazon sellers and vendors.

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

**Yes**, it is legal when used in **compliance** with Amazon's terms of service and data privacy laws.

#### What data can I **extract** using this tool?

You can extract email addresses, seller names, business locations, product categories, and more.

#### Can I customize the data **extract**ion process?

**Yes**, the tool offers customizable settings to focus on specific data points.

#### Is the **extract**ed data accurate?

The tool is designed to provide accurate and up-to-date information for your business needs.

#### How do I integrate the data into my **CRM** system?

The extracted data is provided in a structured format, making it easy to import into your CRM.

#### Does the tool support **large-scale** data **extract**ion?

**Yes**, the Amazon B2B Email Scraper is scalable and can handle **large volumes** of data.

#### What file formats are available for data **export**?

The tool supports various formats, including **CSV** and Excel, for easy data export.

#### Is technical support available for the tool?

**Yes**, our **dedicated support** team is available to assist with any queries or issues.

#### Can I use the tool for personal purposes?

The tool is designed for legitimate business purposes and should not be used for personal or unethical activities.

#### How often is the tool updated?

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

#### Is there a free trial available?

Please check our website for details on free trials or demo versions of the tool.

#### What happens if Amazon changes its platform structure?

Our team ensures **regular updates** to maintain the tool's functionality and compatibility.

#### Can I **extract** data from **specific** product categories?

**Yes**, you can configure the tool to focus on specific product categories for data extraction.

#### Is the Amazon B2B **Email Scraper** **secure** to use?

**Yes**, the tool is designed with security in mind to protect your data and ensure **compliance**.

# 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("scrapeflow/amazon-b2b-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("scrapeflow/amazon-b2b-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 scrapeflow/amazon-b2b-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon B2B Email Scraper",
        "description": "📧 Amazon B2B Email Scraper finds verified business emails from Amazon listings—fast, accurate, and easy to export. Perfect for B2B prospecting, lead generation, and outreach. 🚀 Automate your pipeline and save hours. ✅",
        "version": "0.1",
        "x-build-id": "Volurg1xJGGOeCHfx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeflow~amazon-b2b-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeflow-amazon-b2b-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/scrapeflow~amazon-b2b-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeflow-amazon-b2b-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/scrapeflow~amazon-b2b-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeflow-amazon-b2b-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```