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

Scrape Amazon Best Sellers, New Releases, Movers & Shakers, Most Wished For and Gift Ideas rankings by category across 10 marketplaces. Returns ranked products with rank, ASIN, title, price, rating, review count, Prime status and image. HTTP-only, MCP-ready, no auth required.

- **URL**: https://apify.com/khadinakbar/amazon-bestsellers-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 product scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## 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 — Rankings, BSR & Trends

**Amazon Bestsellers Scraper** extracts Amazon's ranking charts — **Best Sellers, New Releases, Most Wished For, and Gift Ideas** — by category, across 10 marketplaces. Give it a category chart URL (or just pick a chart type and marketplace) and it returns the ranked product list with rank, ASIN, title, price, rating, review count, Prime status, badges, and image — clean, flat JSON built for spreadsheets, dashboards, and AI agents.

It is HTTP-only (fast and cheap), MCP-ready, needs no login, and runs on residential proxies geo-matched to each marketplace so the rankings you get are the rankings a shopper in that country sees.

---

### What is Amazon Bestsellers Scraper?

Amazon's Best Sellers pages (the `/gp/bestsellers/` and `/zgbs/` charts) are the single best free signal of what is actually selling on Amazon right now — updated hourly, ranked 1 to 100, split into thousands of categories and subcategories. This actor turns those pages into structured data you can analyze.

Unlike a general product scraper, this actor is purpose-built for **ranking charts**. It understands all four sibling charts that share Amazon's chart layout, auto-detects the chart type and marketplace from any URL you paste, and scrolls + paginates to capture the full top 100 per category.

| | |
|---|---|
| **Charts** | Best Sellers · New Releases · Most Wished For · Gift Ideas |
| **Marketplaces** | US, UK, DE, FR, IT, ES, CA, JP, IN, AU |
| **Output** | Up to 100 ranked products per chart, 18 flat fields each |
| **Price** | $0.005 per product + $0.00005 actor start |
| **Tech** | Headless browser + residential proxy, MCP-ready |

---

### Use cases for Amazon bestseller data

- **Product research & sourcing** — find proven, fast-moving products in any niche before you commit inventory.
- **BSR (Best Sellers Rank) tracking** — schedule daily runs and watch ranks move over time.
- **Trend spotting** — New Releases surfaces products breaking out before they reach the main charts.
- **Competitor monitoring** — track which of a rival's ASINs enter or climb a category chart.
- **Gifting & seasonal demand** — Most Wished For and Gift Ideas reveal demand the sales charts do not.
- **AI agents & RAG** — a clean "what's top in category X right now" tool for Claude, ChatGPT, and automations.

---

### What data can I extract with Amazon Bestsellers Scraper?

Every record is one ranked product:

| Field | Description |
|---|---|
| `rank` | Position in the chart (1 = top) |
| `asin` | Amazon product ID |
| `title` | Product name |
| `brand` | Brand / byline when shown |
| `price` | Numeric price in the marketplace currency |
| `priceString` | Price exactly as displayed |
| `currency` | ISO 4217 code (USD, GBP, EUR, …) |
| `rating` | Average star rating (0–5) |
| `reviewsCount` | Number of ratings |
| `isPrime` | Prime badge present |
| `badges` | Card badges (Best Seller, Amazon's Choice, …) |
| `imageUrl` | Thumbnail image URL |
| `productUrl` | Product detail page URL |
| `categoryName` | Chart category name |
| `categoryUrl` | Chart page URL |
| `chartType` | bestsellers / new-releases / most-wished-for / gift-ideas |
| `marketplace` | Country code |
| `scrapedAt` | ISO 8601 timestamp |

---

### How much does scraping Amazon Best Sellers cost?

Pay-per-event, no subscription:

- **$0.005** per product returned
- **$0.00005** per actor start

| Job | Products | Approx cost |
|---|---|---|
| Top 100 of one category | 100 | ~$0.50 |
| Top 20 of one category | 20 | ~$0.10 |
| 5 categories, top 100 each | 500 | ~$2.50 |
| One department + subcategories | varies | scales with subcategories found |

The actor prints the maximum possible cost in the log and run status **before** it charges anything, and the actual billed amount at the end — no surprises.

---

### How to use Amazon Bestsellers Scraper

1. Open the actor and either:
   - paste one or more chart URLs into **Amazon chart URLs** (e.g. `https://www.amazon.com/gp/bestsellers/electronics`), **or**
   - leave that empty and choose a **Chart type** + **Marketplace** (+ optional category slug).
2. Set **Max products per chart** (1–100).
3. (Optional) Enable **Crawl subcategories** to expand one level into the category tree.
4. Run. Export the dataset as JSON, CSV, Excel, or pull it via the API.

#### How to scrape Amazon by chart URL or by category

Paste any `/gp/bestsellers/…`, `/gp/new-releases/…`, `/gp/most-wished-for/…` or `/gp/most-gifted/…` URL from any supported marketplace — the chart type and country are detected automatically. No URL handy? Just pick the chart type and marketplace and the actor builds the URL for you.

#### ⬇️ Input example

```json
{
  "startUrls": [{ "url": "https://www.amazon.com/gp/bestsellers/electronics" }],
  "maxItemsPerCategory": 100,
  "includeSubcategories": false
}
````

Or without URLs:

```json
{
  "chartType": "new-releases",
  "marketplace": "UK",
  "categorySlug": "toys",
  "maxItemsPerCategory": 50
}
```

#### ⬆️ Output example

```json
{
  "rank": 1,
  "asin": "B0CHX1W1XY",
  "title": "Apple AirPods Pro (2nd Generation) Wireless Earbuds",
  "brand": "Apple",
  "price": 189.99,
  "priceString": "$189.99",
  "currency": "USD",
  "rating": 4.7,
  "reviewsCount": 24531,
  "isPrime": true,
  "badges": ["Best Seller"],
  "imageUrl": "https://m.media-amazon.com/images/I/61SUj2aKoEL._AC_UL300_.jpg",
  "productUrl": "https://www.amazon.com/dp/B0CHX1W1XY",
  "categoryName": "Electronics",
  "categoryUrl": "https://www.amazon.com/gp/bestsellers/electronics",
  "chartType": "bestsellers",
  "marketplace": "US",
  "scrapedAt": "2026-06-01T12:00:00Z"
}
```

#### Use it from the Apify API

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/amazon-bestsellers-scraper').call({
    chartType: 'bestsellers',
    marketplace: 'US',
    categorySlug: 'electronics',
    maxItemsPerCategory: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

***

### Scrape any Amazon & ecommerce data with dedicated scrapers

Pair this with the rest of the Amazon and ecommerce toolkit:

- [Amazon Reviews Scraper](https://apify.com/khadinakbar/amazon-reviews-scraper) — pull reviews for any ASIN
- [Amazon Product Intelligence](https://apify.com/khadinakbar/amazon-product-intelligence) — full product detail
- [Amazon Competitor Price Tracker](https://apify.com/khadinakbar/amazon-competitor-price-tracker) — track ASIN prices + alerts
- [eBay All-in-One Scraper](https://apify.com/khadinakbar/ebay-all-in-one-scraper) — active, sold & seller data
- [Etsy All-in-One Scraper](https://apify.com/khadinakbar/etsy-all-in-one-scraper) — products + reviews
- [Shopify All-in-One Scraper](https://apify.com/khadinakbar/shopify-all-in-one-scraper) — any Shopify store
- [AliExpress All-in-One Scraper](https://apify.com/khadinakbar/aliexpress-all-in-one-scraper) — listings + detail + reviews
- [Google Shopping Scraper](https://apify.com/khadinakbar/google-shopping-scraper) — cross-retailer prices
- [Google Trends Scraper](https://apify.com/khadinakbar/google-trends-scraper) — pair rankings with search demand
- [Google News Scraper](https://apify.com/khadinakbar/google-news-scraper) — news around trending products

***

### ❓ FAQ

**How many products can I scrape with Amazon Bestsellers Scraper?**
Amazon publishes up to 100 products per chart (two pages of 50). Scrape as many categories, charts, and marketplaces per run as you like — enable subcategory crawling to multiply coverage.

**Can I integrate Amazon Bestsellers Scraper with other apps?**
Yes. Export to Google Sheets, Make, Zapier, or any tool via Apify integrations, or stream the dataset straight into your own pipeline.

**Can I use Amazon Bestsellers Scraper with the Apify API?**
Yes. Start runs, pass input, and fetch the dataset through the Apify API or any Apify client SDK (see the example above).

**Can I use Amazon Bestsellers Scraper through an MCP Server?**
Yes. The actor is MCP-ready — its tool description, input, and flat output are written for AI agents. Expose it via the Apify MCP server and an agent can call it as `amazon-bestsellers-scraper`.

**Do I need proxies to scrape Amazon?**
Yes — Amazon blocks datacenter IPs immediately. The actor defaults to Apify residential proxies geo-matched to the marketplace; keep the default for reliable results.

**Is it legal to scrape Amazon best seller data?**
This actor collects only publicly available ranking data and does not access private or personal information. You are responsible for using scraped data in compliance with Amazon's Terms of Service, applicable laws (including copyright and data-protection rules), and for consulting legal counsel about your specific use case. Use it responsibly and at a reasonable rate.

**Your feedback**
Found a bug or want a new field, chart, or marketplace? Open an issue on the actor's Issues tab — feature requests and reports directly shape the roadmap.

# Actor input Schema

## `startUrls` (type: `array`):

Amazon ranking-chart URLs to scrape — Best Sellers, New Releases, Most Wished For, or Gift Ideas pages (e.g. https://www.amazon.com/gp/bestsellers/electronics). Paste any category or subcategory chart URL from any of the 10 supported marketplaces; the chart type and marketplace are auto-detected from each URL. Leave empty to use the Chart type + Marketplace fields below instead. This is NOT a single product (/dp/) or search (/s?k=) URL — for product detail use the amazon-product-intelligence actor.

## `chartType` (type: `string`):

Which Amazon ranking chart to scrape when you do not paste explicit Start URLs. 'bestsellers' = top 100 by sales; 'new-releases' = trending new products; 'most-wished-for' = most added to wish lists; 'gift-ideas' = most gifted. Defaults to bestsellers. Ignored when Start URLs are provided (the type is auto-detected from each URL).

## `marketplace` (type: `string`):

Amazon marketplace (country) to scrape when using Chart type instead of Start URLs. Selects the domain and a geo-matched residential proxy (e.g. 'US' uses amazon.com via a US IP). One of US, UK, DE, FR, IT, ES, CA, JP, IN, AU. Defaults to US. Ignored when Start URLs are provided (the domain is read from each URL).

## `categorySlug` (type: `string`):

Optional Amazon category slug appended to the chart when using Chart type (e.g. 'books', 'kitchen', 'toys-and-games', 'beauty'). Slugs come from that marketplace's own bestseller URLs — most are shared, but some differ by country (e.g. Electronics is 'electronics' on amazon.com but a localized node on amazon.de). Leave empty for a cross-department sample of the top ~30 products; specify a category to get the full ranked top 100. Ignored when Start URLs are provided.

## `maxItemsPerCategory` (type: `integer`):

Maximum number of ranked products to return per chart/category page. Amazon publishes at most 100 products per chart (two pages of 50), so values above 100 are capped at 100. Defaults to 100. Lower it (for example 20) to cut cost and runtime when you only need the very top of each list.

## `includeSubcategories` (type: `boolean`):

When enabled, also scrapes the immediate subcategory charts linked in the left-hand navigation of each start page (one level deep, same chart type). This greatly increases result count and cost — a department such as Electronics has 20-40 subcategories. Defaults to false (scrape only the exact pages you provide). Each subcategory is still capped by Max products per chart.

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

Proxy settings. Amazon blocks datacenter IPs on the first request, so this defaults to Apify residential proxies geo-matched to the marketplace — keep the default unless you have a specific reason to change it. You can pin a country or supply custom proxy URLs here.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.amazon.com/gp/bestsellers/electronics"
    }
  ],
  "chartType": "bestsellers",
  "marketplace": "US",
  "categorySlug": "",
  "maxItemsPerCategory": 100,
  "includeSubcategories": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped chart products as structured JSON records.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.amazon.com/gp/bestsellers/electronics"
        }
    ],
    "maxItemsPerCategory": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "startUrls": [{ "url": "https://www.amazon.com/gp/bestsellers/electronics" }],
    "maxItemsPerCategory": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "startUrls": [
    {
      "url": "https://www.amazon.com/gp/bestsellers/electronics"
    }
  ],
  "maxItemsPerCategory": 100
}' |
apify call khadinakbar/amazon-bestsellers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Bestsellers Scraper",
        "description": "Scrape Amazon Best Sellers, New Releases, Movers & Shakers, Most Wished For and Gift Ideas rankings by category across 10 marketplaces. Returns ranked products with rank, ASIN, title, price, rating, review count, Prime status and image. HTTP-only, MCP-ready, no auth required.",
        "version": "0.1",
        "x-build-id": "dF44ryfrAZJ1bLV6c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~amazon-bestsellers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~amazon-bestsellers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~amazon-bestsellers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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",
                "properties": {
                    "startUrls": {
                        "title": "Amazon chart URLs",
                        "type": "array",
                        "description": "Amazon ranking-chart URLs to scrape — Best Sellers, New Releases, Most Wished For, or Gift Ideas pages (e.g. https://www.amazon.com/gp/bestsellers/electronics). Paste any category or subcategory chart URL from any of the 10 supported marketplaces; the chart type and marketplace are auto-detected from each URL. Leave empty to use the Chart type + Marketplace fields below instead. This is NOT a single product (/dp/) or search (/s?k=) URL — for product detail use the amazon-product-intelligence actor.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "chartType": {
                        "title": "Chart type",
                        "enum": [
                            "bestsellers",
                            "new-releases",
                            "most-wished-for",
                            "gift-ideas"
                        ],
                        "type": "string",
                        "description": "Which Amazon ranking chart to scrape when you do not paste explicit Start URLs. 'bestsellers' = top 100 by sales; 'new-releases' = trending new products; 'most-wished-for' = most added to wish lists; 'gift-ideas' = most gifted. Defaults to bestsellers. Ignored when Start URLs are provided (the type is auto-detected from each URL).",
                        "default": "bestsellers"
                    },
                    "marketplace": {
                        "title": "Marketplace",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "CA",
                            "JP",
                            "IN",
                            "AU"
                        ],
                        "type": "string",
                        "description": "Amazon marketplace (country) to scrape when using Chart type instead of Start URLs. Selects the domain and a geo-matched residential proxy (e.g. 'US' uses amazon.com via a US IP). One of US, UK, DE, FR, IT, ES, CA, JP, IN, AU. Defaults to US. Ignored when Start URLs are provided (the domain is read from each URL).",
                        "default": "US"
                    },
                    "categorySlug": {
                        "title": "Category (optional)",
                        "type": "string",
                        "description": "Optional Amazon category slug appended to the chart when using Chart type (e.g. 'books', 'kitchen', 'toys-and-games', 'beauty'). Slugs come from that marketplace's own bestseller URLs — most are shared, but some differ by country (e.g. Electronics is 'electronics' on amazon.com but a localized node on amazon.de). Leave empty for a cross-department sample of the top ~30 products; specify a category to get the full ranked top 100. Ignored when Start URLs are provided.",
                        "default": ""
                    },
                    "maxItemsPerCategory": {
                        "title": "Max products per chart",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of ranked products to return per chart/category page. Amazon publishes at most 100 products per chart (two pages of 50), so values above 100 are capped at 100. Defaults to 100. Lower it (for example 20) to cut cost and runtime when you only need the very top of each list.",
                        "default": 100
                    },
                    "includeSubcategories": {
                        "title": "Crawl subcategories",
                        "type": "boolean",
                        "description": "When enabled, also scrapes the immediate subcategory charts linked in the left-hand navigation of each start page (one level deep, same chart type). This greatly increases result count and cost — a department such as Electronics has 20-40 subcategories. Defaults to false (scrape only the exact pages you provide). Each subcategory is still capped by Max products per chart.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Amazon blocks datacenter IPs on the first request, so this defaults to Apify residential proxies geo-matched to the marketplace — keep the default unless you have a specific reason to change it. You can pin a country or supply custom proxy URLs here.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
