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

🛒 Amazon B2B Email Scraper finds verified business emails from Amazon seller & vendor profiles, plus company names, websites & phones. 🎯 Perfect for lead gen, outreach & market research. ⚡ Fast, accurate, export to CSV, deduping & domain filters. Prospecting & CRM-ready leads.

- **URL**: https://apify.com/scraper-engine/amazon-b2b-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** AI, Automation, E-commerce
- **Stats:** 5 total users, 1 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** essential **contact** information from **Amazon** sellers and businesses. The tool is designed to pull verified **data**, ensuring accuracy and usability for outreach campaigns.

Users can retrieve seller profiles, business email addresses, and additional **contact** details for lead generation purposes. This scraper focuses on providing clean and structured **data** that can be integrated into marketing or CRM systems.

By **extract**ing relevant B2B information, businesses can enhance their networking and sales strategies effectively. The software is optimized to handle large **data**sets while maintaining **data** integrity and compliance with legal standards.

Amazon B2B Email Scraper is a powerful tool designed to help businesses extract valuable contact information from Amazon sellers efficiently. It simplifies the process of finding business emails for lead generation and outreach purposes.

With Amazon B2B Email Scraper, you can access verified business emails from Amazon sellers, enabling seamless communication for partnerships or sales opportunities. This tool is ideal for businesses looking to expand their network within the Amazon ecosystem.

The Amazon B2B Email Scraper is built to handle large-scale data extraction while ensuring accuracy and reliability. It provides a streamlined solution for obtaining seller contact details without manual effort.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Seller name | The name of the Amazon seller or business entity. |
| Business email | Verified email address for business communication. |
| Seller profile URL | Direct link to the Amazon seller's profile. |
| Business location | Geographical location of the seller or business. |
| Product categories | Categories of products sold by the Amazon seller. |
| Contact number | Phone number associated with the seller's business. |
| Ratings and reviews | Seller ratings and customer reviews for credibility assessment. |
| Business description | Overview of the seller's business and offerings. |

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

- ⭐ Extract verified business emails from **Amazon** sellers for reliable communication
- ⭐ Automate the process of gathering B2B contact information to save time and effort
- ⭐ Access detailed seller profiles including location and product categories
- ⭐ Retrieve structured data that can be integrated into CRM or marketing systems
- ⭐ Ensure compliance with legal guidelines while scraping data from **Amazon**
- ⭐ Handle large-scale data extraction without compromising accuracy or speed
- ⭐ Filter results based on specific criteria like product categories or seller ratings
- ⭐ User-friendly interface for easy setup and operation of the scraping tool
- ⭐ **Regular** updates to maintain compatibility with **Amazon**s platform changes
- ⭐ **Secure** and encrypted processes to protect extracted data from unauthorized access

### 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** using your credentials
3. ✅ Enter specific search criteria such as product categories or seller locations
4. ✅ **Configure** the scraper settings to define the scope of data extraction
5. ✅ **Start** the scraping process and monitor progress through the dashboard
6. ✅ **Review** the extracted data to ensure accuracy and completeness
7. ✅ **Export** the data in your preferred format such as CSV or Excel
8. ✅ **Integrate** the exported data into your CRM or marketing tools for further use
9. ✅ Adjust settings or filters for subsequent scraping sessions as needed
10. ✅ Contact support if you encounter any issues during the scraping process

### Use Cases 🎯

Lead Generation for B2B Sales
🎯 Extract business emails to build a database of potential clients
🎯 **Identify** sellers offering products relevant to your industry

Market Research and Analysis
🎯 **Analyze** seller profiles to understand market trends
🎯 Gather data on product categories and seller ratings

Partnership Opportunities
🎯 **Find** sellers open to collaboration or partnerships
🎯 Contact businesses with complementary offerings

Email Marketing Campaigns
🎯 Create targeted email lists for promotional campaigns
🎯 Reach out to verified sellers with personalized messages

CRM Integration
🎯 Export structured data for seamless integration into CRM systems
🎯 Maintain organized contact records for better management

### Why choose us? 💎

**Amazon** B2B Email Scraper offers unparalleled efficiency in extracting business emails from **Amazon** sellers. Our tool is designed to provide verified and accurate contact information, ensuring **reliable** communication for B2B purposes.

By automating the data extraction process, businesses can save significant time and resources that would otherwise be spent on manual efforts. Our software is tailored to meet the needs of professionals seeking high-quality leads for sales, partnerships, or market research.

With **advanced** filtering options, users can focus on specific criteria like product categories or seller ratings. The tool is **regular**ly updated to stay compatible with **Amazon**'s platform changes, ensuring uninterrupted functionality.

Additionally, our secure and encrypted processes protect your data from unauthorized access, offering peace of mind during every scraping session. Whether you're looking for an **Amazon** lead generation tool or a comprehensive email scraping solution, our software delivers precise and actionable results to support your business growth.

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

**Amazon** B2B Email Scraper is built to handle data extraction tasks of varying scales, from small businesses to large enterprises. The tool is optimized to process **extensive** datasets without compromising speed or accuracy.

Users can customize the scope of scraping based on their specific needs, whether targeting a niche market or a broader audience. Our software ensures that even high-volume scraping sessions maintain data integrity and compliance with legal standards.

With scalable infrastructure, the tool adapts to growing business demands, making it a reliable solution for long-term use. Whether you're extracting a few hundred emails or thousands, **Amazon** B2B Email Scraper delivers consistent and **efficient** results.

### **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 to extract personal or non-business-related information
⚖️ **Obtain** permission from **Amazon** sellers before contacting them for business purposes
⚖️ **Avoid** sharing or selling extracted data to third parties without consent
⚖️ **Use** the scraper for legitimate business purposes only such as lead generation or market research
⚖️ **Adhere** to data protection laws and regulations applicable in your region
⚖️ Regularly review **Amazon**s policies to stay updated on permissible scraping practices
⚖️ Implement security measures to protect extracted data from unauthorized access

### 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 verified business **emails** and contact information from Amazon sellers.

#### How does the scraper ensure data accuracy?

The scraper uses advanced algorithms to verify and extract accurate contact details from seller profiles.

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

**Yes**, Amazon B2B Email Scraper is ideal for generating leads by extracting business **emails** from Amazon sellers.

#### Is the data **extract**ion process **secure**?

**Yes**, the tool employs encrypted processes to ensure the security of extracted data.

#### Can I filter results based on **specific** criteria?

**Yes**, users can filter data extraction by product categories, seller ratings, or geographical location.

#### Is the scraper compatible with all Amazon marketplaces?

**Yes**, the tool supports data extraction across multiple Amazon marketplaces globally.

#### How often is the software updated?

The scraper is regularly updated to maintain compatibility with Amazon's platform changes.

#### Can I **export** the **extract**ed data?

**Yes**, the tool allows users to export data in various formats like **CSV** or Excel.

#### Is the scraper easy to use?

**Yes**, the software features a **user-friendly** interface for **seamless** operation.

#### What are the **legal** guidelines for using the scraper?

Users must comply with Amazon's terms of service and applicable data protection laws when using the tool.

#### Can I integrate the data into my **CRM** system?

**Yes**, the extracted data can be easily integrated into CRM or marketing systems.

#### What is the scalability of this tool?

The scraper is designed to handle both small-scale and large-scale data extraction efficiently.

#### Does the tool support automated scraping?

**Yes**, Amazon B2B Email Scraper automates the data extraction process for convenience.

#### What kind of businesses can benefit from this tool?

Any business looking to generate leads, conduct market research, or build partnerships with Amazon sellers can benefit from this tool.

#### Is **customer support** available for the scraper?

**Yes**, users can contact support for assistance with setup or troubleshooting.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraper-engine/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 seller & vendor profiles, plus company names, websites & phones. 🎯 Perfect for lead gen, outreach & market research. ⚡ Fast, accurate, export to CSV, deduping & domain filters. Prospecting & CRM-ready leads.",
        "version": "0.1",
        "x-build-id": "6kJWjFyOHpyRapA6P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~amazon-b2b-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-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/scraper-engine~amazon-b2b-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-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/scraper-engine~amazon-b2b-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```