# Amazon Bestsellers Scraper (`scraperforge/amazon-bestsellers-scraper`) Actor

📈 Amazon Bestsellers Scraper extracts Amazon Best Sellers by category — ASINs, titles, prices, ratings, reviews, ranks & links. ⚡ Export CSV/JSON for product research, trend tracking, price monitoring & competitor analysis. 🔍 Ideal for e‑commerce & FBA teams.

- **URL**: https://apify.com/scraperforge/amazon-bestsellers-scraper.md
- **Developed by:** [ScraperForge](https://apify.com/scraperforge) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Amazon Bestsellers Scraper

Amazon Bestsellers Scraper is a purpose-built tool that extracts structured data from Amazon Best Sellers category pages, letting you scrape Amazon top 100 products with clean ASINs, titles, prices, ratings, review counts, and bestseller positions. It solves the manual, time-consuming effort of collecting Amazon Best Sellers data by automating category and subcategory traversal, making it ideal for marketers, developers, data analysts, and researchers. With this Amazon best sellers list scraper and Amazon BSR scraper, you can power product research, competitor tracking, and price monitoring at scale.

### What data / output can you get?

Below are the exact fields the actor saves to the dataset for each product. Results can be exported from Apify to CSV, JSON, or Excel for analysis and reporting.

| Data type | Description | Example value |
| --- | --- | --- |
| name | Product title extracted from the Best Sellers page | "Blink Plus Plan with monthly auto-renewal" |
| url | Direct product URL (DP page) | "https://www.amazon.com/dp/B08JHCVHTY" |
| asin | Amazon Standard Identification Number | "B08JHCVHTY" |
| position | Bestseller rank position within the category/subcategory | 1 |
| price | Object with numeric value and currency symbol (when available) | {"value": 11.99, "currency": "$"} |
| numberOfOffers | Count of offers if present on the card | 3 |
| stars | Average star rating (parsed from the card) | 4.4 |
| reviewsCount | Total number of reviews (parsed from the card) | 272624 |
| thumbnailUrl | Product image URL from the card | "https://images-na.ssl-images-amazon.com/images/I/31YHGbJsldL._AC_UL300_.png" |
| categoryName | Short category name resolved from the page | "Electronics" |
| categoryFullName | Full banner/category label | "Best Sellers in Electronics" |
| subcategories | Array of discovered subcategories with names and URLs | [{"categoryName":"Accessories & Supplies","categoryUrl":"https://www.amazon.com/..."}] |
| categoryUrl | The category URL that was scraped | "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/" |
| input | Echo of the original input URL that initiated the scrape | "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/" |

Note: Some fields can be null if Amazon does not display them on the card (e.g., price, stars, numberOfOffers). Subcategories are included to provide context and enable subsequent traversal. Exports are available as CSV, JSON, or Excel via the Apify dataset.

### Key features

- ⚡️ Bold category scraping performance  
  Efficiently crawls Amazon Best Sellers category pages and streams structured records to the Apify dataset in real time.

- 🧭 Subcategory traversal control  
  Use the subcategoryDepth input to scrape the main category only or include subcategories for broader coverage with this Amazon best sellers scraping tool.

- 🌐 Multilingual header support  
  Set the language input to influence Accept-Language headers, enhancing localization for different Amazon domains.

- 🧩 Clean, structured fields for analysis  
  Extracts ASIN, product URL, price object, ratings, reviews, and bestseller position — a dependable Amazon bestseller data extractor for analytics.

- 🔀 Pagination handling  
  Automatically follows Best Sellers pagination using the pg parameter to cover deeper product lists where available.

- 🔒 Proxy configuration ready  
  Configure proxyConfiguration to run direct or via Apify Proxy/custom proxies for resilient runs on different Amazon domains.

- 🔁 Parallel category runs  
  Processes multiple categoryUrls concurrently, ideal for Amazon top sellers scraper workflows and ongoing monitoring jobs.

- 📦 Easy exports and integrations  
  Download results as JSON, CSV, or Excel from the dataset or wire into pipelines — great for automation scripts and BI tools.

- 🧪 Robustness against blocks  
  Detects Amazon Robot Check and HTTP 429 with retry logic to improve reliability across regions for your Amazon best sellers crawler.

- 🧠 Developer-friendly design  
  Consistent field names and JSON structure make it suitable for API pipelines and Python-based data workflows, including Amazon best sellers CSV export.

### How to use Amazon Bestsellers Scraper - step by step

1) Sign in to Apify  
Create a free Apify account or log in.

2) Open the actor  
Find “Amazon Bestsellers Scraper” in the Apify Store and click Try for free.

3) Add input URLs  
Paste Amazon Best Sellers category page URLs into categoryUrls. You can provide a list (string list or objects with url) to scrape multiple categories in one run.

4) Configure limits and depth  
Set maxResults (1–500 per start URL) to control volume. Choose subcategoryDepth to scrape only the main category (1) or include subcategories (2+).

5) Optional settings  
- language to set Accept-Language (varies by Amazon domain).  
- proxyConfiguration for direct or proxy-based runs.  
- detailedInformation and useCaptchaSolver are available in the input (see parameters below).

6) Start the run  
Click Start. The actor streams results to the dataset as it collects them. You’ll see logs indicating saved items and progress.

7) Export your data  
Open the dataset and export to JSON, CSV, or Excel. Use it for product research, trend tracking, and competitive analysis with this Amazon bestseller research tool.

Pro tip: Schedule the actor on Apify to build an Amazon bestseller monitoring tool for ongoing category tracking.

### Use cases

| Use case name | Description |
| --- | --- |
| E‑commerce competitor tracking | Monitor Amazon Best Sellers lists to benchmark pricing, ratings, and reviews across categories for actionable insights. |
| Product research & sourcing | Discover high-demand items and scrape Amazon top 100 products to validate opportunities for FBA and dropshipping. |
| Market trend analysis | Track movers in categories/subcategories to identify rising products using an Amazon bestseller rank extractor. |
| Pricing intelligence | Build a time series of price.value and currency to analyze pricing patterns with an Amazon best sellers price scraper. |
| Analytics pipelines | Feed structured ASIN-level data into BI dashboards and data warehouses via CSV/JSON exports. |
| Regional benchmarking | Compare category leaders across different Amazon domains using language and proxy settings. |
| Automation & alerts | Use exports and scheduling to power an Amazon best sellers automation script that flags changes in positions or ratings. |

### Why choose Amazon Bestsellers Scraper?

This actor focuses on precision, scale, and reliable automation for category-level Amazon Best Sellers data.

- 🎯 Accurate, structured output: Clean ASINs, URLs, prices, ratings, and review counts for dependable analysis.
- 🌍 Multilingual support: Optional language header for better localization across Amazon domains.
- 📈 Scale with control: Set maxResults and subcategoryDepth to fit category breadth and run budgets.
- 🛠️ Developer-ready: Consistent JSON fields and parallel runs simplify API pipelines and Python integrations.
- 🔐 Proxy-aware operation: Configure proxyConfiguration for resilient scraping across regions.
- 💾 Easy exports: Download as CSV, JSON, or Excel for immediate use in analysis and reports.
- 🧷 Built for reliability: Pagination logic, retry handling for HTTP 429, and Robot Check detection — more robust than brittle browser extensions.

In short, it’s a production-ready Amazon best sellers crawler designed for repeatable, automated data collection.

### Is it legal / ethical to use Amazon Bestsellers Scraper?

Yes — when done responsibly. The actor targets publicly available category pages and does not access private or authenticated content.

Guidelines for compliant use:
- Review and honor Amazon’s terms of service for your jurisdiction and use case.
- Collect only public data and avoid aggressive request rates.
- Respect applicable data protection regulations (e.g., GDPR, CCPA).
- Do not use scraped data for spam or abusive behavior.
- Consult your legal team for edge cases and commercial usage policies.

### Input parameters & output format

#### Example input JSON
```json
{
  "categoryUrls": [
    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
  ],
  "maxResults": 100,
  "subcategoryDepth": 2,
  "language": "en",
  "detailedInformation": false,
  "useCaptchaSolver": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Input parameters

- categoryUrls (array, required): Amazon Best Sellers category page URLs to scrape. Default: none.
- maxResults (integer, optional): Maximum number of products to extract per each Amazon category URL. Minimum 1, maximum 500. Default: 100.
- subcategoryDepth (integer, optional): 1️⃣ = main category only, 2️⃣+ = include subcategories. Minimum 1. Default: 2.
- language (string, optional, nullable): Language to use on Amazon. Disclaimer: each Amazon domain has a different set of supported languages; if unsupported, the default domain language is used. Enum includes: "", "cs", "da", "de", "en", "es", "fr", "nl", "pl", "pt", "sv", "tr", "he", "ar", "mrta", "hi", "bn", "ta", "te", "kn", "ml", "ko", "zh\_CN", "zh\_TW", "ja". Default: null (empty selection).
- detailedInformation (boolean, optional): Fetch extra product details (when available). Default: false.
- useCaptchaSolver (boolean, optional): Use captcha solver when blocked (warning: may incur extra cost). Default: false.
- proxyConfiguration (object, optional): Proxy settings. Default is DIRECT. Editor supports Apify Proxy or custom configuration. Default: none (prefill useApifyProxy: false).

#### Example output JSON

```json
{
  "name": "Blink Plus Plan with monthly auto-renewal",
  "url": "https://www.amazon.com/dp/B08JHCVHTY",
  "asin": "B08JHCVHTY",
  "position": 1,
  "price": { "value": 11.99, "currency": "$" },
  "numberOfOffers": null,
  "stars": 4.4,
  "reviewsCount": 272624,
  "thumbnailUrl": "https://images-na.ssl-images-amazon.com/images/I/31YHGbJsldL._AC_UL300_.png",
  "categoryName": "Electronics",
  "categoryFullName": "Best Sellers in Electronics",
  "subcategories": [
    { "categoryName": "Accessories & Supplies", "categoryUrl": "https://www.amazon.com/..." }
  ],
  "categoryUrl": "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
  "input": "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
}
```

Notes:

- Some fields can be null when Amazon does not display them on the card (e.g., price, stars, numberOfOffers).
- subcategories is an array of discovered subcategory links on the page to provide context for hierarchy and subsequent navigation.

### FAQ

#### Is Amazon Bestsellers Scraper free to use?

You can try the actor on Apify and export results from the dataset. The listing may include a subscription and trial minutes; check the Apify Store page for current pricing and trial terms.

#### Do I need to log in to scrape Amazon Best Sellers?

No. The actor fetches public Best Sellers category pages and does not require login or cookies.

#### Can I integrate this with Python or an API?

Yes. Results are saved to the Apify dataset, which you can access via the Apify API or download as JSON/CSV/Excel for Python-based pipelines and automation.

#### How many products can I scrape per category?

Use maxResults to control volume, up to 500 per start URL. The actor paginates and collects products in rank order, making it suitable to scrape Amazon top 100 products and beyond (within your specified limit).

#### Can it scrape subcategories automatically?

Yes. Set subcategoryDepth to 2 or higher to include subcategories discovered on the Best Sellers page. Use 1 to scrape only the main category.

#### What fields does the actor extract?

The dataset includes name, url, asin, position, price (value and currency), numberOfOffers, stars, reviewsCount, thumbnailUrl, categoryName, categoryFullName, subcategories, categoryUrl, and input.

#### How do I export results to CSV or Excel?

Open the run’s dataset on Apify and choose your preferred export format (CSV, JSON, or Excel). This makes it easy to use the tool as an Amazon best sellers CSV export workflow.

#### Is it legal to scrape Amazon Best Sellers pages?

Yes, when done responsibly. The actor targets public pages and does not access private or authenticated data. Always review Amazon’s terms and ensure compliance with applicable regulations in your jurisdiction.

### Closing CTA / Final thoughts

Amazon Bestsellers Scraper is built to extract structured Amazon Best Sellers data reliably and at scale. With clean ASINs, prices, ratings, reviews, and category context, it empowers marketers, analysts, researchers, and developers to automate product research and trend tracking. Configure limits and language, run across multiple categories, and export to CSV/JSON/Excel for downstream use. Developers can wire the dataset into pipelines via API for continuous Amazon bestseller monitoring. Start extracting smarter Amazon Best Sellers insights today.

# Actor input Schema

## `categoryUrls` (type: `array`):

📋 Amazon Best Sellers category page URLs to scrape.

## `maxResults` (type: `integer`):

📈 Maximum number of products to extract per each Amazon category URL.

## `subcategoryDepth` (type: `integer`):

1️⃣ = main category only, 2️⃣+ = include subcategories.

## `language` (type: `string`):

🗣️ Language to use on Amazon. ⚠️ Disclaimer: each Amazon domain has a different set of supported languages. If you choose a language that is not supported by the domain, the scraper will use the default language of the domain.

## `detailedInformation` (type: `boolean`):

Fetch extra product details (when available).

## `useCaptchaSolver` (type: `boolean`):

🔓 Use captcha solver when blocked (⚠️ warning: may incur extra cost).

## `proxyConfiguration` (type: `object`):

🔒 Proxy settings. Default is DIRECT. If blocked, falls back to residential proxy.

## Actor input object example

```json
{
  "categoryUrls": [
    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
  ],
  "maxResults": 100,
  "subcategoryDepth": 2,
  "detailedInformation": false,
  "useCaptchaSolver": false,
  "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 = {
    "categoryUrls": [
        "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperforge/amazon-bestsellers-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 = {
    "categoryUrls": ["https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperforge/amazon-bestsellers-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 '{
  "categoryUrls": [
    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperforge/amazon-bestsellers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Bestsellers Scraper",
        "description": "📈 Amazon Bestsellers Scraper extracts Amazon Best Sellers by category — ASINs, titles, prices, ratings, reviews, ranks & links. ⚡ Export CSV/JSON for product research, trend tracking, price monitoring & competitor analysis. 🔍 Ideal for e‑commerce & FBA teams.",
        "version": "0.2",
        "x-build-id": "scsgIzILl1uOppdej"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperforge~amazon-bestsellers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperforge-amazon-bestsellers-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/scraperforge~amazon-bestsellers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperforge-amazon-bestsellers-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/scraperforge~amazon-bestsellers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperforge-amazon-bestsellers-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": [
                    "categoryUrls"
                ],
                "properties": {
                    "categoryUrls": {
                        "title": "🔗 Amazon category URLs",
                        "type": "array",
                        "description": "📋 Amazon Best Sellers category page URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "📊 Max results (per start URL)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "📈 Maximum number of products to extract per each Amazon category URL.",
                        "default": 100
                    },
                    "subcategoryDepth": {
                        "title": "📁 How many subcategories do you want to scrape?",
                        "minimum": 1,
                        "type": "integer",
                        "description": "1️⃣ = main category only, 2️⃣+ = include subcategories.",
                        "default": 2
                    },
                    "language": {
                        "title": "🌐 Language",
                        "enum": [
                            "",
                            "cs",
                            "da",
                            "de",
                            "en",
                            "es",
                            "fr",
                            "nl",
                            "pl",
                            "pt",
                            "sv",
                            "tr",
                            "he",
                            "ar",
                            "mrta",
                            "hi",
                            "bn",
                            "ta",
                            "te",
                            "kn",
                            "ml",
                            "ko",
                            "zh_CN",
                            "zh_TW",
                            "ja"
                        ],
                        "type": "string",
                        "description": "🗣️ Language to use on Amazon. ⚠️ Disclaimer: each Amazon domain has a different set of supported languages. If you choose a language that is not supported by the domain, the scraper will use the default language of the domain."
                    },
                    "detailedInformation": {
                        "title": "Detailed information",
                        "type": "boolean",
                        "description": "Fetch extra product details (when available).",
                        "default": false
                    },
                    "useCaptchaSolver": {
                        "title": "🤖 Use Captcha solver",
                        "type": "boolean",
                        "description": "🔓 Use captcha solver when blocked (⚠️ warning: may incur extra cost).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "🔒 Proxy settings. Default is DIRECT. If blocked, falls back to residential proxy."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
