# Amazon B2b Email Scraper (`scrapio/amazon-b2b-email-scraper`) Actor

📦 Amazon B2B Email Scraper finds verified business emails and public seller contact info from Amazon storefronts and listings. ⚡️Build supplier lists, source vendors, and power outreach with clean, export-ready leads. 🔍 Ideal for sales, sourcing, and e‑commerce teams.

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 📱

**Amazon** B2B Email Scraper allows users to **extract** a wide range of **data** points from **Amazon**'s platform. This includes email addresses, seller names, business names, and additional **contact** details.

By gathering this information, businesses can create targeted marketing campaigns and build meaningful connections with **Amazon** sellers. The tool is designed to provide accurate and reliable **data**, ensuring that users have access to the most relevant information for their needs.

With its advanced capabilities, this **Amazon** email scraping software is perfect for businesses of all sizes, from startups to established enterprises. Whether you are looking for seller **contact** details or other business-related information, this tool simplifies the process of **data** **extract**ion and ensures compliance with legal guidelines.

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

With the Amazon email scraping tool, you can efficiently collect email addresses and other relevant data from Amazon's vast marketplace. This enables businesses to build targeted email lists and establish connections with potential partners or clients.

The Amazon business email scraper is ideal for companies looking to expand their network and streamline their lead generation efforts. It is user-friendly, reliable, and capable of handling large-scale data extraction tasks.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.scrapio@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract email addresses of Amazon sellers and businesses for outreach. |
| Seller Names | Retrieve the names of sellers operating on Amazon's platform. |
| Business Names | Collect the names of businesses associated with Amazon seller accounts. |
| Contact Numbers | Access phone numbers listed by Amazon sellers where available. |
| Seller Locations | Gather location details of sellers for targeted marketing. |
| Product Listings | Extract information about products listed by specific sellers. |
| Seller Ratings | Retrieve ratings and reviews associated with Amazon sellers. |
| Business Categories | Identify the categories in which sellers operate for segmentation. |

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

- ⭐ Efficiently extracts **Amazon** B2B emails and contact details for lead generation
- ⭐ Supports bulk data extraction for large-scale campaigns and outreach
- ⭐ Provides accurate and up-to-date information from **Amazon**s platform
- ⭐ User-friendly interface with simple setup and operation
- ⭐ **Customizable** scraping options to target specific sellers or categories
- ⭐ Ensures compliance with legal and ethical guidelines for data extraction
- ⭐ Compatible with various operating systems and devices
- ⭐ Offers data export in multiple formats for easy integration with CRM tools
- ⭐ Includes advanced filtering options to refine data collection
- ⭐ Provides robust customer support for troubleshooting and assistance
- ⭐ Automates the scraping process to save time and resources
- ⭐ Scalable solution suitable for businesses of all sizes

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

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

1. ✅ Download and install the **Amazon** B2B Email Scraper software on your device
2. ✅ Launch the tool and **log in** with your account credentials
3. ✅ **Configure** the scraping settings including target categories or sellers
4. ✅ Enter specific keywords or filters to refine your data extraction process
5. ✅ **Start** the scraping process and monitor progress through the dashboard
6. ✅ **Review** the extracted data once the process is complete
7. ✅ **Export** the data in your preferred format for further use
8. ✅ **Integrate** the exported data with your CRM or email marketing tools
9. ✅ Use the data for targeted marketing campaigns or outreach efforts
10. ✅ Regularly update the tool to ensure optimal performance and compliance
11. ✅ Contact customer support if you encounter any issues during the process
12. ✅ Repeat the process as needed for continuous lead generation

### Use Cases 🎯

B2B Lead Generation
🎯 Extract **Amazon** B2B emails to build targeted email lists
🎯 **Identify** potential business partners or clients from **Amazon** sellers

Marketing Campaigns
🎯 **Use** scraped email data to run personalized email marketing campaigns
🎯 Segment sellers by categories for more effective outreach

Competitor Analysis
🎯 **Analyze** seller data and product listings to understand market trends
🎯 **Identify** competitors and their business strategies on **Amazon**

Data Enrichment
🎯 Enhance your existing databases with accurate **Amazon** seller information
🎯 Fill in missing contact details for a complete business profile

Sales Outreach
🎯 Connect directly with **Amazon** sellers to pitch your products or services
🎯 Expand your sales network by targeting relevant businesses on **Amazon**

### Why choose us? 💎

**Amazon** B2B Email Scraper is designed to provide businesses with a **reliable** and efficient solution for extracting email data from **Amazon**. Our tool is built with **advanced** technology to ensure accurate and up-to-date information, helping you make informed decisions for your marketing and outreach efforts.

We understand the importance of scalability, which is why our software can handle both small and large-scale data extraction tasks. Whether you are a startup or an established enterprise, our tool adapts to your needs and delivers consistent results.

Our **user-friendly** interface makes it easy for anyone to use the software, regardless of technical expertise. Additionally, we prioritize compliance with legal and ethical standards, ensuring that your data collection practices are secure and responsible.

With robust customer support and **regular** updates, we are committed to providing you with a seamless experience. Choose **Amazon** B2B Email Scraper to simplify your lead generation process and achieve your business goals efficiently.

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

**Amazon** B2B Email Scraper is designed to scale with your business needs, whether you are targeting a small niche or a broad market. The tool supports bulk data extraction, making it suitable for **large-scale** campaigns and **extensive** lead generation efforts.

Its **advanced** filtering options allow you to focus on specific categories or sellers, ensuring that you collect only the most relevant data. As your business grows, the software can adapt to handle increased data volumes without compromising performance.

Regular updates and optimizations ensure that the tool remains **efficient** and reliable, even as **Amazon**'s platform evolves. Whether you are a small business or a large enterprise, **Amazon** B2B Email Scraper provides a scalable solution to meet your data extraction requirements.

### **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 malicious purposes
⚖️ **Avoid** scraping personal data that is not publicly available on **Amazon**
⚖️ **Use** the extracted data responsibly and in accordance with data protection laws
⚖️ **Obtain** consent from individuals before using their contact information for marketing
⚖️ **Do not** distribute or sell scraped data to third parties without permission
⚖️ Regularly review applicable laws and regulations to ensure compliance
⚖️ Respect the privacy and intellectual property rights of **Amazon** and its users

### 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 Amazon B2B **Email Scraper**?

Amazon B2B Email Scraper is a tool designed to extract email addresses and other contact details from Amazon for B2B lead generation.

#### Is the tool **legal** to use?

**Yes**, as long as you comply with Amazon's terms of service and applicable data protection laws.

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

You can extract email addresses, seller names, business names, contact numbers, and more.

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

The tool is designed to provide accurate and up-to-date information from Amazon's platform.

#### Can I use the tool for bulk data **extract**ion?

**Yes**, the tool supports bulk data extraction for large-scale campaigns.

#### Is technical expertise required to use the tool?

**No**, the tool features a **user-friendly** interface suitable for all users.

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

You can export data in multiple formats compatible with CRM and marketing tools.

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

**Yes**, we provide robust customer support to assist with any issues.

#### Can I customize the scraping process?

**Yes**, you can configure settings to target specific sellers or categories.

#### Is the tool scalable for growing businesses?

**Yes**, the tool is designed to scale with your business needs and handle increased data volumes.

#### Does the tool comply with data protection laws?

**Yes**, the tool is built to ensure **compliance** with legal and ethical standards.

#### Can I scrape data from multiple categories on Amazon?

**Yes**, the tool allows you to scrape data from multiple categories based on your preferences.

#### How often is the tool updated?

The tool is regularly updated to ensure optimal performance and compatibility with Amazon's platform.

#### Is there a free trial available?

Please check our website for information on free trials or demo versions.

#### Can I use the tool for competitor analysis?

**Yes**, you can analyze seller data and product listings to gain insights into competitors.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapio/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 and public seller contact info from Amazon storefronts and listings. ⚡️Build supplier lists, source vendors, and power outreach with clean, export-ready leads. 🔍 Ideal for sales, sourcing, and e‑commerce teams.",
        "version": "0.1",
        "x-build-id": "aZLFZlhAkhJ4hanXD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~amazon-b2b-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-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/scrapio~amazon-b2b-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-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/scrapio~amazon-b2b-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```