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

Amazon Email Scraper extracts publicly available email addresses from Amazon seller profiles and store pages. Build targeted contact lists for supplier outreach, partnerships, and marketplace collaborations at scale.

- **URL**: https://apify.com/scraper-engine/amazon-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 2 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** Email Scraper allows users to **extract** valuable **contact** information from **Amazon** seller profiles. This includes email addresses, seller names, and other relevant details that facilitate direct communication.

By using this tool, businesses can build a **data**base of **Amazon** seller **contact**s for marketing or networking purposes. The scraper is designed to navigate **Amazon**'s platform efficiently while adhering to ethical **data** collection practices.

Users can **extract** **Amazon** **emails** and other **data** points without the need for extensive manual effort. This tool is ideal for professionals looking to streamline their **data** collection processes and improve outreach strategies.

With its advanced features, **Amazon** Email Scraper ensures accurate and reliable results every time.

Amazon Email Scraper is a powerful tool designed to help users extract email addresses from Amazon efficiently and accurately. It is ideal for businesses and researchers looking to gather contact information from Amazon sellers.

With Amazon Email Scraper, you can streamline the process of collecting seller emails, saving time and effort. This tool is perfect for building targeted email lists for marketing or communication purposes.

Email scraping tools for Amazon are essential for businesses aiming to connect with sellers directly. Our scraper ensures compliance with ethical guidelines while delivering reliable results.

### 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 |
| --- | --- |
| Email Address | Extract verified email addresses of Amazon sellers. |
| Seller Name | Retrieve the names of Amazon sellers for personalized outreach. |
| Store Name | Collect the names of Amazon stores associated with sellers. |
| Product Listings | Identify the products listed by specific sellers. |
| Ratings and Reviews | Gather seller ratings and reviews for quality assessment. |
| Location Information | Extract geographic details associated with sellers. |
| Contact Links | Retrieve links to seller contact pages or profiles. |
| Seller ID | Capture unique seller IDs for database organization. |

### 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 email addresses and other seller details from **Amazon**
- ⭐ Supports multiple **Amazon** marketplaces for global data collection
- ⭐ User-friendly interface requiring no technical expertise to operate
- ⭐ **Advanced** algorithms ensure accurate and reliable data extraction
- ⭐ Adheres to ethical and legal guidelines for data scraping
- ⭐ **Customizable** scraping options to target specific data points
- ⭐ **Secure** data handling to protect user privacy and compliance
- ⭐ Provides detailed logs and reports for data verification
- ⭐ Compatible with various devices and operating systems
- ⭐ **Automated** scraping reduces manual effort and saves time
- ⭐ **Regular** updates to ensure compatibility with **Amazon**s platform
- ⭐ Scalable solution for both small and large-scale data collection

### 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** Email Scraper software on your device
2. ✅ Log in or create an account to access the tools features
3. ✅ **Select** the **Amazon** marketplace you want to scrape data from
4. ✅ Enter specific keywords or seller profiles to target for data extraction
5. ✅ Customize the scraping settings to include desired data points like emails or seller names
6. ✅ **Start** the scraping process and monitor progress through the dashboard
7. ✅ **Review** the extracted data in real-time or upon completion of the process
8. ✅ **Export** the collected data in your preferred format such as CSV or Excel
9. ✅ Verify the extracted data to ensure accuracy and completeness
10. ✅ Use the data for your intended purpose such as marketing or research
11. ✅ Refer to the tools documentation for troubleshooting or advanced features
12. ✅ Log out securely after completing your scraping session

### Use Cases 🎯

Marketing and Outreach
🎯 Build targeted email lists for **Amazon** sellers
🎯 Promote products or services to relevant sellers
🎯 Enhance B2B communication with verified contact details

Competitor Analysis
🎯 **Analyze** seller profiles and product offerings
🎯 **Identify** top-performing sellers in specific categories
🎯 Gather insights into competitor strategies and pricing

Academic Research
🎯 **Collect** data for market research studies
🎯 **Analyze** trends in seller demographics and product listings
🎯 Support academic projects with accurate and reliable data

Lead Generation
🎯 **Identify** potential business partners on **Amazon**
🎯 Expand your network with verified seller contacts
🎯 Streamline lead generation processes with automated tools

### Why choose us? 💎

**Amazon** Email Scraper is designed to provide users with a **reliable** and efficient solution for extracting seller emails from **Amazon**. Our tool is built with **advanced** technology to ensure accurate and secure data collection.

We prioritize user experience by offering a simple and intuitive interface that requires no technical expertise. Our scraper supports multiple **Amazon** marketplaces, making it a versatile choice for global users.

We adhere to strict ethical and legal guidelines to ensure compliance with data scraping regulations. Our team provides **regular** updates to maintain compatibility with **Amazon**'s platform and enhance performance.

With **Amazon** Email Scraper, you can save time and effort while achieving your data collection goals. Whether you're a business owner, researcher, or marketer, our tool is tailored to meet your needs.

Choose **Amazon** Email Scraper for a dependable and **user-friendly** data extraction experience.

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

**Amazon** Email Scraper is built to handle data extraction tasks of any size, making it a scalable solution for users with varying needs. Whether you're collecting data for a small project or a **large-scale** operation, our tool can adapt to your requirements.

The scraper's **advanced** algorithms ensure **efficient** performance even when processing **extensive** datasets. Our software supports batch processing, allowing users to extract data from multiple seller profiles simultaneously.

This scalability makes it an ideal choice for businesses, researchers, and marketers looking to expand their outreach. With **Amazon** Email Scraper, you can scale your data collection efforts without compromising on accuracy or reliability.

Our tool is designed to grow with your needs, providing a flexible and dependable solution for **Amazon** email extraction.

### **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 collect data for illegal or unethical purposes
⚖️ **Obtain** proper consent before contacting sellers using extracted emails
⚖️ **Avoid** scraping sensitive or personal information without authorization
⚖️ **Use** the tool responsibly to prevent overloading **Amazon**s servers
⚖️ Regularly review and adhere to local data privacy laws and regulations
⚖️ **Do not** share or sell extracted data without proper permissions
⚖️ Respect the intellectual property rights associated with **Amazon**s platform

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

### Input Table

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

### Output Format 📤

📝 Example Output (JSON)

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

### Output Table

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

### 🔗 What are other Amazon scraping tools?

If you want to scrape specific Amazon data, you can use any of the dedicated scrapers below for faster and more targeted results.\
Just enter product URLs, search keywords, ASINs, or seller names and start scraping instantly.

| [🔥 Amazon Today's Deals Scraper](https://apify.com/scraper-engine/amazon-todays-deals-scraper) | [🔎 Amazon Search Scraper](https://apify.com/scraper-engine/amazon-search-scraper) |
|---|---|
| [🏆 Amazon Bestsellers Scraper](https://apify.com/scraper-engine/amazon-bestsellers-scraper) | [📦 Amazon Product Scraper](https://apify.com/scraper-engine/amazon-product-scraper) |
| [🆔 Amazon ASINs Scraper](https://apify.com/scraper-engine/amazon-asins-scraper) | [📄 Amazon Product Details Scraper](https://apify.com/scraper-engine/amazon-product-details-scraper) |
| [🛍️ Amazon Search Products Scraper](https://apify.com/scraper-engine/amazon-search-products-scraper) | [🏪 Amazon Seller Scraper](https://apify.com/scraper-engine/amazon-seller-scraper) |
| [📞 Amazon Phone Number Scraper](https://apify.com/scraper-engine/amazon-phone-number-scraper) |

### FAQ ❓

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

Amazon Email Scraper is a tool designed to extract email addresses and other seller details from Amazon efficiently.

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

**Yes**, it is legal to use when adhering to Amazon's terms of service and data privacy laws.

#### Can I scrape data from all Amazon marketplaces?

**Yes**, the scraper supports multiple Amazon marketplaces globally.

#### Do I need technical skills to use Amazon **Email Scraper**?

**No**, the tool is **user-friendly** and requires no technical expertise to operate.

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

You can extract email addresses, seller names, store names, product listings, ratings, and more.

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

**Yes**, the scraper uses advanced algorithms to ensure accurate and reliable data extraction.

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

**Yes**, you can export the data in formats like **CSV** or Excel for further use.

#### Is my data **secure** while using the scraper?

**Yes**, the tool is designed to handle data **secure**ly and protect user privacy.

#### Does the scraper support batch processing?

**Yes**, it allows batch processing to extract data from multiple profiles simultaneously.

#### How often is the tool updated?

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

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

**Yes**, you can use the extracted data for marketing while ensuring **compliance** with legal guidelines.

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

Our team provides updates to ensure the scraper remains compatible with any changes.

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

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

#### Can I customize the scraping settings?

**Yes**, the tool allows customization to target specific data points.

#### What are the system requirements for the scraper?

The tool is compatible with most devices and operating systems, requiring minimal resources.

# 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-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-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-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Email Scraper",
        "description": "Amazon Email Scraper extracts publicly available email addresses from Amazon seller profiles and store pages. Build targeted contact lists for supplier outreach, partnerships, and marketplace collaborations at scale.",
        "version": "0.1",
        "x-build-id": "9m5rEGOlAdygnUgcx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~amazon-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-amazon-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraper-engine~amazon-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-amazon-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraper-engine~amazon-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-amazon-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Amazon (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Amazon profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Amazon"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Amazon"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```