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

Automate email extraction from Amazon with Amazon Email Scraper. The actor scans product, brand, or seller pages and pulls available contact emails into structured datasets for CRM enrichment.

- **URL**: https://apify.com/api-empire/amazon-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 7 total users, 0 monthly users, 100.0% runs succeeded, 1 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 gather critical **contact** information from **Amazon** seller profiles with ease. This tool is designed to **extract** **emails**, phone numbers, and other relevant details for business purposes.

It ensures high accuracy and efficiency, making it an essential resource for professionals seeking seller **data**. With **Amazon** Email Scraper, you can quickly access seller names, business names, and locations to build a comprehensive **data**base.

This software is ideal for businesses looking to enhance their outreach strategies and establish connections with **Amazon** sellers. The **extract**ed **data** can be used for marketing campaigns, partnership opportunities, and customer engagement.

Amazon Email Scraper is a powerful tool designed to help users extract email addresses and contact information from Amazon sellers efficiently. It simplifies the process of gathering essential data for business outreach and market analysis.

With the Amazon Email Scraper, you can access seller contact details without manually searching through countless pages. This tool is ideal for businesses looking to connect with Amazon sellers for partnerships or marketing purposes.

Amazon email scraping software provides an automated solution for extracting valuable contact information from Amazon seller profiles. It ensures accuracy and saves time compared to manual methods.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Seller Email Address | Extract email addresses of Amazon sellers for direct communication. |
| Seller Name | Retrieve the name of the seller listed on Amazon. |
| Business Name | Extract the business name associated with the seller profile. |
| Phone Number | Obtain the contact phone number of Amazon sellers. |
| Location | Gather the geographical location of the seller or business. |
| Seller Profile URL | Extract the URL of the seller's Amazon profile for reference. |
| Product Listings | Retrieve details of products listed by the seller on Amazon. |
| Ratings and Reviews | Collect seller ratings and reviews for performance analysis. |

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

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

- ⭐ **Automated** extraction of email addresses from **Amazon** seller profiles
- ⭐ **High** accuracy in gathering seller contact information such as phone numbers and business names
- ⭐ User-friendly interface for seamless operation and data collection
- ⭐ Ability to extract seller location and geographical details
- ⭐ Supports bulk data extraction for large-scale operations
- ⭐ Provides seller profile URLs for quick reference and verification
- ⭐ Includes product listing details for comprehensive seller analysis
- ⭐ Offers insights into seller ratings and reviews for performance evaluation
- ⭐ **Customizable** scraping options to meet specific business needs
- ⭐ **Fast** and efficient data processing for time-sensitive projects
- ⭐ **Secure** handling of extracted data to ensure privacy and compliance
- ⭐ Compatible with various platforms and systems for flexible usage

### 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 system
2. ✅ Open the software and **log in** using your credentials
3. ✅ Enter the primary keyword or seller profile URL to begin scraping
4. ✅ **Select** the specific data types you want to extract such as email addresses or phone numbers
5. ✅ **Configure** additional settings such as location filters or product categories if needed
6. ✅ Click the **Start** button to initiate the scraping process
7. ✅ Monitor the progress of data extraction on the dashboard
8. ✅ Once completed review the extracted data and save it to your preferred format
9. ✅ **Export** the data to a spreadsheet or database for further use
10. ✅ Repeat the process for additional seller profiles or categories as required
11. ✅ Use the extracted data for marketing campaigns or business outreach
12. ✅ Ensure compliance with legal guidelines when using the collected information

### Use Cases 🎯

Business Outreach
🎯 Connect with **Amazon** sellers for partnership opportunities
🎯 Expand your network by reaching out to sellers directly

Market Analysis
🎯 **Analyze** seller profiles to understand market trends
🎯 **Use** extracted data for competitive research

Marketing Campaigns
🎯 Build targeted email lists for promotional campaigns
🎯 Enhance customer engagement with accurate contact information

Performance Evaluation
🎯 Assess seller ratings and reviews for quality assurance
🎯 **Identify** top-performing sellers for collaboration

Product Research
🎯 Discover product listings from various sellers
🎯 Gather insights into popular product categories

### Why choose us? 💎

**Amazon** Email Scraper is the **best** **Amazon** email scraping tool for businesses seeking **reliable** and efficient data extraction solutions. Our software is designed to simplify the process of gathering seller contact information, ensuring accuracy and speed.

With features like automated email extraction and customizable scraping options, we provide a comprehensive solution for your data collection needs. Our **user-friendly** interface makes it easy for anyone to use the tool, regardless of technical expertise.

We prioritize data security and compliance, ensuring that your business operates within legal boundaries. By choosing **Amazon** Email Scraper, you gain access to a robust platform that supports scalability and flexibility.

Whether you're conducting market analysis or launching marketing campaigns, our tool is tailored to meet your objectives. Trust us to deliver high-quality results that empower your business to thrive in the competitive **Amazon** marketplace.

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

**Amazon** Email Scraper is built to handle data extraction tasks of any scale, making it suitable for businesses of all sizes. Whether you need to extract information from a few seller profiles or thousands, our software ensures consistent performance.

The tool supports bulk data extraction, allowing you to gather large volumes of seller information **efficient**ly. With **customizable** options, you can tailor the scraping process to meet specific business requirements.

Our platform is designed to adapt to your growing needs, ensuring **seamless** scalability as your operations expand. By leveraging **Amazon** Email Scraper, you can streamline your data collection processes and focus on achieving your business goals.

### **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 extracted data for spamming or unsolicited communication
⚖️ Verify the legality of email scraping in your region before proceeding
⚖️ Respect seller privacy and avoid collecting sensitive personal information
⚖️ **Use** the data only for legitimate business purposes such as outreach or analysis
⚖️ **Avoid** sharing or selling the extracted data to third parties without consent
⚖️ Regularly review and update your practices to align with legal regulations
⚖️ Consult legal professionals to ensure adherence to applicable laws and guidelines

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

### Input Table

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

### Output Format 📤

📝 Example Output (JSON)

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

### Output Table

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

### FAQ ❓

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

Amazon Email Scraper is a tool designed to extract email addresses and contact information from Amazon seller profiles.

#### How does the Amazon **Email Scraper** work?

The scraper automates the process of gathering seller data by scanning their profiles and extracting relevant information.

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

**Yes**, it is legal as long as you comply with Amazon's terms of service and regional data privacy laws.

#### What data can I **extract** using Amazon **Email Scraper**?

You can extract seller **emails**, names, business names, phone numbers, locations, profile URLs, product listings, and ratings.

#### Can I use the **extract**ed data for marketing purposes?

**Yes**, you can use the data for legitimate marketing campaigns, provided you adhere to legal and ethical guidelines.

#### Is Amazon **Email Scraper** user-friendly?

**Yes**, the tool features an intuitive interface that simplifies the data extraction process for all users.

#### Can I **extract** data in bulk?

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

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

**Yes**, our software ensures **secure** handling of extracted data to protect privacy and **compliance**.

#### What formats can I **export** the **extract**ed data to?

You can export the data to spreadsheets or databases for further use and analysis.

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

**No**, the tool is designed for ease of use and does not require advanced technical skills.

#### Can I customize the scraping process?

**Yes**, you can configure settings such as filters and data types to meet specific requirements.

#### Does Amazon **Email Scraper** support scalability?

**Yes**, the tool is built to handle data extraction tasks of any scale, making it suitable for **businesses** of all sizes.

#### Are there any restrictions on using the **extract**ed data?

**Yes**, you must use the data responsibly and avoid spamming or violating privacy laws.

#### Can I use Amazon **Email Scraper** for market analysis?

**Yes**, the tool is ideal for analyzing seller profiles and understanding market trends.

#### What is the pricing for Amazon **Email Scraper**?

Pricing details are available on our website or by contacting our support team.

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

| Scraper Name | Scraper Name |
|---|---|
| [Amazon Asin Scraper](https://apify.com/api-empire/amazon-asin-scraper) | [Amazon Product Details Scraper](https://apify.com/api-empire/amazon-product-details-scraper) |
| [Amazon B2b Email Scraper](https://apify.com/api-empire/amazon-b2b-email-scraper) | [Amazon Product Scraper](https://apify.com/api-empire/amazon-product-scraper) |
| [Amazon B2b Phone Number Scraper](https://apify.com/api-empire/amazon-b2b-phone-number-scraper) | [Amazon Search Products Scraper](https://apify.com/api-empire/amazon-search-products-scraper) |
| [Amazon Bestsellers Scraper](https://apify.com/api-empire/amazon-bestsellers-scraper) | [Amazon Search Scraper](https://apify.com/api-empire/amazon-search-actor) |
| [Amazon DE Sellers Leads Scraper](https://apify.com/api-empire/amazon-de-sellers-leads-scraper) | [Amazon Seller Data Extractor](https://apify.com/api-empire/amazon-seller-data-extractor) |
| [Amazon Phone Number Scraper](https://apify.com/api-empire/amazon-phone-number-scraper) | [Amazon Today's Deals Scraper](https://apify.com/api-empire/amazon-todays-deals-scraper) |

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Email Scraper",
        "description": "Automate email extraction from Amazon with Amazon Email Scraper. The actor scans product, brand, or seller pages and pulls available contact emails into structured datasets for CRM enrichment.",
        "version": "0.1",
        "x-build-id": "VDusFafpD49otuVu8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~amazon-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-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/api-empire~amazon-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-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/api-empire~amazon-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```