# Amazon Bestsellers Scraper · 20 Marketplaces (`santamaria-automations/amazon-bestsellers-scraper`) Actor

Extract Amazon's Best Sellers, Movers and Shakers, New Releases, Most Wished For and Most Gifted rankings across 20 marketplaces. Returns top 100 per category with rank, ASIN, brand, price, list price, stars, reviews, Amazon's Choice / Prime / deal badges. Pay-per-result.

- **URL**: https://apify.com/santamaria-automations/amazon-bestsellers-scraper.md
- **Developed by:** [Ale](https://apify.com/santamaria-automations) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

Extract Amazon's Best Sellers, Movers and Shakers, New Releases, Most Wished For and Most Gifted rankings across 20 marketplaces. Returns rank, ASIN, title, brand, price, list price, stars, reviews, Amazon's Choice / Prime / Limited-time-deal flags and thumbnail. Pay-per-result, no login required.

### What it does

You give it Amazon bestseller URLs or browse-node IDs. You get back clean, structured JSON, one row per ranked product.

- Five list types in one actor: Best Sellers, Movers and Shakers, New Releases, Most Wished For, Most Gifted
- Top 100 per category by walking pagination (Amazon's own list cap)
- Handles both Amazon layouts: modern grid (50 per page, 2 pages) and legacy list (20 per page, 5 pages)
- Marketplace and list type auto-detect from any bestseller URL you pass
- Pass numeric browse-node IDs when you don't have the URL handy
- `position` field carries the true 1-to-100 rank across paginated pages

#### Sample output

```json
{
  "asin": "B09B8V1LZ3",
  "url": "https://www.amazon.com/dp/B09B8V1LZ3",
  "marketplace": "US",
  "categoryUrl": "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
  "categoryName": "Best Sellers in Electronics",
  "categoryBreadCrumbs": ["Electronics"],
  "listType": "bestseller",
  "position": 1,
  "title": "Amazon Echo Dot (5th Gen, 2022 release) | With bigger vibrant sound",
  "brand": "Amazon",
  "thumbnailImage": "https://m.media-amazon.com/images/I/example.jpg",
  "price": { "value": 49.99, "currency": "$", "raw": "$49.99" },
  "listPrice": { "value": 59.99, "currency": "$", "raw": "$59.99" },
  "stars": 4.7,
  "reviewsCount": 193736,
  "isAmazonChoice": true,
  "isPrime": true,
  "isLimitedDeal": false,
  "dealText": null,
  "scrapedAt": "2026-06-15T07:33:09Z"
}
````

### Pricing

$0.001 per actor start, plus $0.001 per scraped result. Roughly $1 per 1,000 results.

A full top-100 walk of one category costs $0.10. Walking 100 categories across a marketplace (10,000 products) costs $10.

You only pay for results that successfully return data. Failed fetches are not charged.

**New to Apify?** Every account gets a $5 free monthly platform credit, enough for around 5,000 results on this actor before you commit to paying anything. Plenty to test the full feature set.

### Why this scraper

**Five list types, one actor.** Best Sellers, Movers and Shakers, New Releases, Most Wished For, Most Gifted: all toggled from a single input. Most competitors only ship the default Best Sellers list.

**Auto-detects everything.** Drop in any Amazon bestseller URL and the actor figures out the marketplace, the list type, and the layout (Amazon ships two and switches between them) without configuration.

**Top 100 walk built in.** Pagination is automatic. The actor walks until the category's full top 100 is gathered, then stops cleanly when the list ends.

**20 marketplaces.** Auto-detects marketplace from the URL TLD. For browse-node IDs the `country` input selects the marketplace. Locale-correct prices and currencies thanks to per-marketplace proxy routing.

**Pay only for results.** $0.001 per successfully scraped row. Failed fetches are not charged.

### Use with AI Agents (MCP)

Connect this actor to any MCP-compatible AI client: Claude Desktop, Claude.ai, Cursor, VS Code, LangChain, LlamaIndex, or custom agents.

**Apify MCP server URL:**

`https://mcp.apify.com?tools=santamaria-automations/amazon-bestsellers-scraper`

**Example prompt once connected:**

> "Use `amazon-bestsellers-scraper` to fetch the top 100 in Electronics on amazon.com. Return as a CSV."

Clients that support dynamic tool discovery (Claude.ai, VS Code) will receive the full input schema automatically.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `startUrls` | array | Bestseller URLs. Marketplace AND list type auto-detect from the URL. |
| `categoryUrls` | array | Alias for `startUrls`, merged into the same queue. |
| `browseNodeIds` | array of strings | Numeric browse-node IDs (e.g. `172282`). `country` picks the marketplace and the list-type toggles pick the list. |
| `country` | string | Marketplace for `browseNodeIds`: US, UK, DE, FR, IT, ES, CA, MX, BR, NL, SE, PL, TR, JP, IN, AU, SG, SA, AE, EG. |
| `language` | string | `AUTO` matches the marketplace, or pick one: en, de, fr, it, es, ja, pt, ar, tr, sv, nl, pl. |
| `maxResultsPerCategory` | integer | Cap per category. Maximum 100 (Amazon's own cap). Default 100. |
| `maxResults` | integer | Hard cap across all categories. `0` means unlimited. |
| `movers` | boolean | Scrape Movers and Shakers instead of Best Sellers (applies to `browseNodeIds`). |
| `newReleases` | boolean | Scrape New Releases instead of Best Sellers. |
| `mostWished` | boolean | Scrape Most Wished For instead of Best Sellers. |
| `mostGifted` | boolean | Scrape Most Gifted instead of Best Sellers. |
| `concurrency` | integer | Categories fetched in parallel, 1 to 20. Default `5`. |

List-type toggles are mutually exclusive. If multiple are true, precedence is movers, newReleases, mostWished, mostGifted, bestseller.

#### Example input: Best Sellers in three categories

```json
{
  "startUrls": [
    {"url": "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"},
    {"url": "https://www.amazon.com/Best-Sellers/zgbs/hpc/"},
    {"url": "https://www.amazon.de/gp/bestsellers/electronics/"}
  ],
  "maxResultsPerCategory": 100,
  "concurrency": 3
}
```

#### Example input: New Releases by browse-node ID

```json
{
  "browseNodeIds": ["172282", "1055398"],
  "country": "US",
  "newReleases": true,
  "maxResultsPerCategory": 50
}
```

### Output fields

#### Identity and ranking

`asin`, `title`, `url`, `marketplace`, `categoryUrl`, `categoryName`, `categoryBreadCrumbs`, `listType`, `position`

#### Pricing

- `price` as `{value, currency, raw}`
- `listPrice` (struck-through original when on sale)

#### Social proof

- `stars` (0 to 5)
- `reviewsCount`

#### Badges

- `isAmazonChoice`, `isPrime`
- `isLimitedDeal` (true on Limited Time Deal or Lightning Deal badges)
- `dealText` (literal badge text when a deal is active)

#### Media

`thumbnailImage`

#### Brand

`brand` (when shown on the card, often null on bestseller listings)

#### Run metadata

`input`, `scrapedAt`

### Common use cases

- **Market-trend monitoring.** Track which products rank in a category over time.
- **New-product discovery.** Use `newReleases` to surface fresh launches in a niche.
- **Category-rank tracking for your own SKUs.** Find where your ASIN sits in its category's top 100, daily.
- **Wishlist and gifting trend analysis.** Use `mostWished` and `mostGifted` for social-shopping signals not visible on Best Sellers.
- **Movers and Shakers alerts.** Catch products gaining sales rank fast (24h rolling window) for trend-spotting.

### Notes and limits

- **Amazon caps every list at 100.** The actor cannot return more than 100 rows per category. This is Amazon's own limit.
- **Lazy-loaded rows on some categories (2026-06).** A handful of high-traffic Best Seller categories now lazy-load positions 31 to 50 via a JSON API on initial render. v1 returns the rows that appear in the server-rendered HTML (typically around 60 of 100 on affected categories). v1.1 will call the JSON endpoint to fill the gap.
- **Category slugs differ across marketplaces.** A path like `/zgbs/electronics/` is US-specific. For other marketplaces, open the bestsellers root nav of that marketplace and use the actual category URL from there. Browse-node IDs also differ per marketplace.
- **Layout auto-detection.** Amazon ships two layouts (modern grid and legacy list). The actor sniffs both and handles either silently.
- **Bestsellers refresh hourly.** Pulling these more often than that returns identical data.
- **`brand` is often null.** Bestseller cards frequently omit the brand line. Fetch the ASIN through Amazon Product Scraper for guaranteed brand data.

#### Fields that may be null

- `categoryName` and `categoryBreadCrumbs` are extracted from the page header. Some sub-category pages on smaller marketplaces ship without the standard header.
- `listPrice` only when the product is on sale.
- `stars` and `reviewsCount` are null on products with zero reviews.
- `dealText` only when a deal badge is shown.
- `brand` frequently null on bestseller cards (see above).

#### Recommended concurrency

3 to 5 concurrent categories is the sweet spot. Pages within a single category are walked sequentially to preserve session warmth. Cross-category parallelism is what the concurrency setting controls.

#### Multi-marketplace runs

Mixing marketplaces in one run is supported. Accept-Language, locale headers, and the proxy country are tuned per category. Expect slightly longer runtime on smaller marketplaces (`.sa`, `.ae`, `.eg`, `.sg`) where Amazon's anti-bot is more aggressive.

### Related Actors

- [Amazon Product Scraper](https://apify.com/santamaria-automations/amazon-product-scraper): pull the full 50+ field PDP detail for any ASIN returned here (description, A+ content, variants, AI review summary, top reviews).
- [Amazon Search Scraper](https://apify.com/santamaria-automations/amazon-search-scraper): scrape search results pages by keyword across the same 20 marketplaces.
- [Amazon Seller Scraper](https://apify.com/santamaria-automations/amazon-seller-scraper): extract seller storefronts, ratings, business addresses and full product catalogs.

### Support

For issues, feature requests, or marketplaces not yet supported, please open an issue on the [Issues tab](https://apify.com/santamaria-automations/amazon-bestsellers-scraper/issues) of this actor. We typically respond within 24 hours.

Contact: contact@nanoscrape.com

# Actor input Schema

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

Amazon bestseller-list URLs. Any `/gp/bestsellers/...`, `/zgbs/...`, `/Best-Sellers-...`, `/gp/movers-and-shakers/...`, `/gp/new-releases/...`, `/gp/most-wished-for/...` or `/gp/most-gifted/...` URL works. Marketplace AND list type are auto-detected from the URL. Combine with the Browse Node IDs field below — both are merged into one queue.

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

Alias for the Category URLs field above. Use whichever feels more natural — both are merged into the same queue.

## `browseNodeIds` (type: `array`):

Amazon browse-node IDs (numeric strings). The Marketplace Country below selects which Amazon to use, and the Movers / New Releases / Most Wished For / Most Gifted toggles below pick which list to scrape. Example: `172282` for Electronics on amazon.com.

## `country` (type: `string`):

Which Amazon marketplace to use for the Browse Node IDs field above. Ignored for entries in Category URLs (TLD is detected from the URL).

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

Accept-Language preference sent to Amazon. `AUTO` matches the marketplace (e.g. de-DE for Germany, ja-JP for Japan) — recommended unless you need consistent English copy across all marketplaces.

## `maxResultsPerCategory` (type: `integer`):

Cap the number of products returned per category. Amazon caps each list at 100, so the maximum is 100. Default 100.

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

Hard cap on the total number of rows across all categories combined. `0` = unlimited (only Max Results per Category limits the run).

## `movers` (type: `boolean`):

When true, scrape Amazon's `/gp/movers-and-shakers/...` ranking (biggest gainers in sales rank over the last 24 hours) instead of the default Best Sellers list. Applies to Browse Node IDs; Category URLs always honor their own path.

## `newReleases` (type: `boolean`):

When true, scrape Amazon's `/gp/new-releases/...` ranking. Applies to Browse Node IDs; Category URLs always honor their own path.

## `mostWished` (type: `boolean`):

When true, scrape Amazon's `/gp/most-wished-for/...` ranking (most-added-to-wishlists). Applies to Browse Node IDs.

## `mostGifted` (type: `boolean`):

When true, scrape Amazon's `/gp/most-gifted/...` ranking (most popular gift purchases). Applies to Browse Node IDs.

## `concurrency` (type: `integer`):

Categories fetched in parallel. 3-5 is reliable for most workloads. Pages within a single category are fetched sequentially to preserve session warmth.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
    },
    {
      "url": "https://www.amazon.de/gp/bestsellers/electronics/"
    }
  ],
  "categoryUrls": [],
  "browseNodeIds": [],
  "country": "US",
  "language": "AUTO",
  "maxResultsPerCategory": 100,
  "maxResults": 0,
  "movers": false,
  "newReleases": false,
  "mostWished": false,
  "mostGifted": false,
  "concurrency": 5
}
```

# Actor output Schema

## `bestsellers` (type: `string`):

Dataset containing scraped Amazon bestseller-list rows

# 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/Best-Sellers-Electronics/zgbs/electronics/"
        },
        {
            "url": "https://www.amazon.de/gp/bestsellers/electronics/"
        }
    ],
    "categoryUrls": [],
    "browseNodeIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("santamaria-automations/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/Best-Sellers-Electronics/zgbs/electronics/" },
        { "url": "https://www.amazon.de/gp/bestsellers/electronics/" },
    ],
    "categoryUrls": [],
    "browseNodeIds": [],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Bestsellers Scraper · 20 Marketplaces",
        "description": "Extract Amazon's Best Sellers, Movers and Shakers, New Releases, Most Wished For and Most Gifted rankings across 20 marketplaces. Returns top 100 per category with rank, ASIN, brand, price, list price, stars, reviews, Amazon's Choice / Prime / deal badges. Pay-per-result.",
        "version": "1.0",
        "x-build-id": "MdqZ70NHKNSNH3rMV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/santamaria-automations~amazon-bestsellers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-santamaria-automations-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/santamaria-automations~amazon-bestsellers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-santamaria-automations-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/santamaria-automations~amazon-bestsellers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-santamaria-automations-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": "Category URLs",
                        "type": "array",
                        "description": "Amazon bestseller-list URLs. Any `/gp/bestsellers/...`, `/zgbs/...`, `/Best-Sellers-...`, `/gp/movers-and-shakers/...`, `/gp/new-releases/...`, `/gp/most-wished-for/...` or `/gp/most-gifted/...` URL works. Marketplace AND list type are auto-detected from the URL. Combine with the Browse Node IDs field below — both are merged into one queue.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categoryUrls": {
                        "title": "Category URLs (alias)",
                        "type": "array",
                        "description": "Alias for the Category URLs field above. Use whichever feels more natural — both are merged into the same queue.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "browseNodeIds": {
                        "title": "Browse Node IDs",
                        "type": "array",
                        "description": "Amazon browse-node IDs (numeric strings). The Marketplace Country below selects which Amazon to use, and the Movers / New Releases / Most Wished For / Most Gifted toggles below pick which list to scrape. Example: `172282` for Electronics on amazon.com.",
                        "items": {
                            "type": "string",
                            "pattern": "^[0-9]+$"
                        }
                    },
                    "country": {
                        "title": "Marketplace Country",
                        "enum": [
                            "US",
                            "CA",
                            "MX",
                            "BR",
                            "UK",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "SE",
                            "PL",
                            "TR",
                            "JP",
                            "IN",
                            "AU",
                            "SG",
                            "SA",
                            "AE",
                            "EG"
                        ],
                        "type": "string",
                        "description": "Which Amazon marketplace to use for the Browse Node IDs field above. Ignored for entries in Category URLs (TLD is detected from the URL).",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "AUTO",
                            "en",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "ja",
                            "pt",
                            "ar",
                            "tr",
                            "sv",
                            "nl",
                            "pl"
                        ],
                        "type": "string",
                        "description": "Accept-Language preference sent to Amazon. `AUTO` matches the marketplace (e.g. de-DE for Germany, ja-JP for Japan) — recommended unless you need consistent English copy across all marketplaces.",
                        "default": "AUTO"
                    },
                    "maxResultsPerCategory": {
                        "title": "Max Results per Category",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Cap the number of products returned per category. Amazon caps each list at 100, so the maximum is 100. Default 100.",
                        "default": 100
                    },
                    "maxResults": {
                        "title": "Max Total Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the total number of rows across all categories combined. `0` = unlimited (only Max Results per Category limits the run).",
                        "default": 0
                    },
                    "movers": {
                        "title": "Scrape Movers & Shakers (instead of Best Sellers)",
                        "type": "boolean",
                        "description": "When true, scrape Amazon's `/gp/movers-and-shakers/...` ranking (biggest gainers in sales rank over the last 24 hours) instead of the default Best Sellers list. Applies to Browse Node IDs; Category URLs always honor their own path.",
                        "default": false
                    },
                    "newReleases": {
                        "title": "Scrape New Releases (instead of Best Sellers)",
                        "type": "boolean",
                        "description": "When true, scrape Amazon's `/gp/new-releases/...` ranking. Applies to Browse Node IDs; Category URLs always honor their own path.",
                        "default": false
                    },
                    "mostWished": {
                        "title": "Scrape Most Wished For (instead of Best Sellers)",
                        "type": "boolean",
                        "description": "When true, scrape Amazon's `/gp/most-wished-for/...` ranking (most-added-to-wishlists). Applies to Browse Node IDs.",
                        "default": false
                    },
                    "mostGifted": {
                        "title": "Scrape Most Gifted (instead of Best Sellers)",
                        "type": "boolean",
                        "description": "When true, scrape Amazon's `/gp/most-gifted/...` ranking (most popular gift purchases). Applies to Browse Node IDs.",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Concurrent Categories",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Categories fetched in parallel. 3-5 is reliable for most workloads. Pages within a single category are fetched sequentially to preserve session warmth.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
