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

Extract Amazon product data by ASIN or URL across 20 marketplaces. Returns price, list price, stock, ratings, star breakdown, monthly purchase volume, variants, A+ content, bestseller ranks, hi-res images and 40+ more fields. Pay-per-result, no login required.

- **URL**: https://apify.com/santamaria-automations/amazon-product-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 $3.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 Product Scraper

Extract Amazon product data by ASIN or URL across 20 marketplaces. Returns price, list price, stock, ratings, star breakdown, monthly purchase volume, variants, A+ content, bestseller ranks, hi-res images and 40+ more fields per product. Pay-per-result, no login required.

### What it does

You give it Amazon URLs or bare ASINs. You get back clean, structured JSON, one row per product.

- Any URL format works: `/dp/ASIN`, `/gp/product/ASIN`, full slug URLs with ref tags, or a list of 10-character ASINs
- Marketplace auto-detects from the URL TLD. For bare ASINs the country input picks the marketplace
- Runs 1 to 50 requests in parallel (default 10)
- Returns 50+ fields per product, see the full list below
- One row per ASIN. No duplicate spam, no padded rows

#### Sample output

```json
{
  "asin": "B09B8V1LZ3",
  "url": "https://www.amazon.com/dp/B09B8V1LZ3",
  "marketplace": "US",
  "title": "Amazon Echo Dot (5th Gen, 2022 release) | With bigger vibrant sound",
  "brand": "Amazon",
  "price": { "value": 49.99, "currency": "$", "raw": "$49.99" },
  "listPrice": { "value": 59.99, "currency": "$", "raw": "$59.99" },
  "stars": 4.7,
  "reviewsCount": 193736,
  "starsBreakdown": { "5star": 0.82, "4star": 0.11, "3star": 0.03, "2star": 0.01, "1star": 0.03 },
  "monthlyPurchaseVolume": "10K+ bought in past month",
  "inStock": true,
  "isPrime": true,
  "isAmazonChoice": false
}
````

The full output also includes `manufacturer`, `highResolutionImages`, `galleryThumbnails`, `videosCount`, `features`, `description`, `aPlusContent`, `breadCrumbs`, `bestsellerRanks`, `delivery`, `fastestDelivery`, `seller`, `shipsFrom`, `attributes`, `productOverview`, `variantAsins`, `variantAttributes`, `isMultipack`, `multipackCount`, `answeredQuestions`, `aiReviewsSummary`, `topReviews` and more.

### Pricing

$0.001 per actor start, plus $0.003 per scraped product. Roughly $3 per 1,000 products.

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

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

### Why this scraper

**Built for completeness.** Many Amazon scrapers silently drop the awkward cases: multipacks, variant listings, products without star breakdowns, items missing typical detail tables. This actor returns a row for every ASIN you submit, with partial data filled in where present and clearly-null fields where Amazon did not expose them.

**Multipack detection.** Listings like "Pack of 4" or "8-Pack" are flagged with `isMultipack: true` and `multipackCount: 8`. You can filter them downstream or correctly attribute reviews to the parent product. Most scrapers on the marketplace silently skip these.

**20 marketplaces.** Auto-detects the marketplace from any `amazon.<TLD>/dp/...` URL. For bare ASINs, the `country` input picks the marketplace. Accept-Language is tuned per country so prices, stock and delivery dates render in the right locale.

**Fast at scale.** Configurable concurrency (1 to 50 parallel) with built-in rate limiting and automatic retries on transient blocks. No CAPTCHA service subscription required.

**Pay only for results.** $0.003 per successfully scraped product. 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-product-scraper`

**Example prompt once connected:**

> "Use `amazon-product-scraper` to fetch the current price, rating, and stock status for ASINs B09B8V1LZ3, B0BDHWDR12, and B00HZV9WTM on amazon.com. Return results as a table."

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

### Input

| Field | Type | Description |
| --- | --- | --- |
| `startUrls` | array | Amazon product URLs in any format: `/dp/`, `/gp/product/`, full slug URLs with ref tags. |
| `asins` | array of strings | Bare ASINs, 10 chars each, e.g. `B09B8V1LZ3`. |
| `country` | string | Marketplace for bare ASINs: 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 a specific one: en, de, fr, it, es, ja, pt, ar, tr, sv, nl, pl. |
| `maxItems` | integer | Cap the total products scraped. `0` means unlimited. |
| `scrapeReviewSample` | boolean | Include up to 8 top reviews per product. Default `true`. |
| `scrapeVariants` | boolean | Include the list of variant ASINs. Default `true`. |
| `zipCode` | string | Override the delivery ZIP. Affects shown price, stock, and delivery date. |
| `concurrency` | integer | Parallel requests, 1 to 50. Default `10`. |

You can mix `startUrls` and `asins` in the same run. Duplicates (same ASIN plus marketplace) are deduplicated automatically.

#### Example input

```json
{
  "startUrls": [
    { "url": "https://www.amazon.com/dp/B09B8V1LZ3" },
    { "url": "https://www.amazon.de/dp/B0FWDZ45GQ" }
  ],
  "asins": ["B07XJ8C8F5", "B0BDHWDR12"],
  "country": "US",
  "scrapeReviewSample": true,
  "concurrency": 10
}
```

### Output fields

#### Core identity

`asin`, `url`, `marketplace`, `title`, `brand`, `manufacturer`

#### Pricing and stock

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

#### Ratings and social proof

- `stars` (0 to 5 average)
- `reviewsCount`
- `starsBreakdown` (`{5star, 4star, 3star, 2star, 1star}` as fractions)
- `monthlyPurchaseVolume` (e.g. "10K+ bought in past month")
- `answeredQuestions`
- `aiReviewsSummary` (Amazon's AI-generated review summary)
- `topReviews` (up to 8 review samples)

#### Media

`thumbnailImage`, `highResolutionImages`, `galleryThumbnails`, `videosCount`

#### Content

- `features` (bullet points), `description`, `aPlusContent`
- `breadCrumbs`, `bestsellerRanks`
- `attributes`, `manufacturerAttributes`, `productOverview`
- `importantInformation`

#### Badges and shipping

- `isAmazonChoice`, `amazonChoiceText`, `isPrime`, `isBestSeller`
- `delivery`, `fastestDelivery`, `shippingPrice`
- `seller` as `{name, url, id}`, `shipsFrom`, `condition`, `returnPolicy`

#### Variants

- `variantAsins`: list of sibling variants for the parent listing
- `variantAttributes`: variant dimension labels (Color, Size, Style, Pack Size, etc.)
- `variantDetails`: per-variant ASIN to attribute mapping
- `isMultipack`, `multipackCount`, `originalAsin`

#### Run metadata

`loadedCountryCode`, `locationText`, `input`, `scrapedAt`

### Common use cases

- **Repricing.** Pull current `price` and `listPrice` daily for a SKU catalog.
- **Stock monitoring.** Track `inStock`, `inStockText`, `delivery` for restock alerts.
- **Catalog enrichment.** Pull `features`, `attributes`, `highResolutionImages` for product feeds.
- **Competitive intelligence.** Compare `stars`, `reviewsCount`, `monthlyPurchaseVolume` across competitor ASINs.
- **Variant discovery.** Use `variantAsins` to enumerate all sibling SKUs of a parent listing.
- **Review analytics.** Pull `topReviews` and `aiReviewsSummary` for sentiment analysis.
- **Marketplace expansion.** Same ASIN across `.com`, `.de`, `.co.uk` for cross-marketplace pricing.

### Notes and limits

- **One row per ASIN per run.** If you submit the same ASIN twice (e.g. via both `startUrls` and `asins`), it's deduplicated.
- **Variant ASINs are listed, not separately fetched** in v1. If you need full data for every variant, pass the variant ASINs in a follow-up run.
- **Reviews returned**: top 8 reviews per product when `scrapeReviewSample=true`.
- **Localization**: prices, delivery dates, and language follow the marketplace. To force USD on `.de`, switch to `country: US` with US ASINs.

#### Fields that may be null

Some output fields are situational. They populate when Amazon shows them and stay null otherwise. This is not an extraction bug:

- `listPrice` is only populated when the product is on sale (struck-through original price).
- `description` and `aPlusContent` populate on most book and retail PDPs. On many device/electronics PDPs (Echo, Fire TV, AirPods) Amazon hydrates the long-form description block client-side via JavaScript, so it's not in the server-rendered HTML this actor receives.
- `bestsellerRanks` populates on items with a "#1 in Category" badge or BSR table. Not every PDP shows one in the initial render.
- `aiReviewsSummary` only appears on products with enough reviews for Amazon to generate an AI summary.
- `monthlyPurchaseVolume` only appears on items Amazon has recent sales velocity for.
- `videosCount`, `answeredQuestions` only when those sections exist on the PDP.

#### Recommended concurrency

5 to 10 parallel requests is the sweet spot. Higher works but transient blocks become more frequent, which the actor handles via automatic retries (small extra time, no data loss).

#### Multi-marketplace runs

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

### Related Actors

- [Amazon Search Scraper](https://apify.com/santamaria-automations/amazon-search-scraper): scrape search results pages by keyword across the same 20 marketplaces.
- [Amazon Bestsellers Scraper](https://apify.com/santamaria-automations/amazon-bestsellers-scraper): scrape Amazon's bestseller, movers and shakers, new releases, most wished for and most gifted rankings.
- [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-product-scraper/issues) of this actor. We typically respond within 24 hours.

Contact: contact@nanoscrape.com

# Actor input Schema

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

Amazon product page URLs. Any format works: `/dp/B09B8V1LZ3`, `/gp/product/B09B8V1LZ3`, or full slug URLs. Marketplace is auto-detected from the URL TLD. Combine with the ASINs field below — both are merged into one queue.

## `asins` (type: `array`):

Bare ASINs (10 chars). The Marketplace Country below determines which Amazon to scrape these from. Combine with Product URLs above — both fields can be used together.

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

Which Amazon marketplace to use for the ASINs field above. Ignored for entries in Product 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.

## `maxItems` (type: `integer`):

Cap the total number of products scraped across this run. `0` = unlimited (scrape every URL + ASIN you provided).

## `scrapeReviewSample` (type: `boolean`):

Return up to 8 top reviews per product (stars, title, author, date, body). Adds minimal cost. For the full review stream, use the Amazon Reviews Scraper.

## `scrapeVariants` (type: `boolean`):

Include the list of sibling variant ASINs (sizes, colors, packs). Variant detail pages are NOT separately fetched in v1 — only their ASINs and dimension labels are returned. Pass those ASINs in a follow-up run to enrich them.

## `zipCode` (type: `string`):

Optional. Override the default delivery ZIP for the selected marketplace. Affects shown price, stock, and delivery date. Leave empty to use the marketplace default (e.g. 10001 for US, 10115 for DE, 75001 for FR).

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

Products fetched in parallel. 5-10 is reliable for most workloads; higher (up to 50) is faster but increases the chance of transient blocks that force retries.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.amazon.com/dp/B09B8V1LZ3"
    },
    {
      "url": "https://www.amazon.de/dp/B0BDHB9Y8H"
    }
  ],
  "asins": [
    "B07XJ8C8F5"
  ],
  "country": "US",
  "language": "AUTO",
  "maxItems": 0,
  "scrapeReviewSample": true,
  "scrapeVariants": true,
  "zipCode": "94103",
  "concurrency": 10
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing scraped Amazon product items

# 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/dp/B09B8V1LZ3"
        },
        {
            "url": "https://www.amazon.de/dp/B0BDHB9Y8H"
        }
    ],
    "asins": [
        "B07XJ8C8F5"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("santamaria-automations/amazon-product-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/dp/B09B8V1LZ3" },
        { "url": "https://www.amazon.de/dp/B0BDHB9Y8H" },
    ],
    "asins": ["B07XJ8C8F5"],
}

# Run the Actor and wait for it to finish
run = client.actor("santamaria-automations/amazon-product-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/dp/B09B8V1LZ3"
    },
    {
      "url": "https://www.amazon.de/dp/B0BDHB9Y8H"
    }
  ],
  "asins": [
    "B07XJ8C8F5"
  ]
}' |
apify call santamaria-automations/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Scraper · 20 Marketplaces",
        "description": "Extract Amazon product data by ASIN or URL across 20 marketplaces. Returns price, list price, stock, ratings, star breakdown, monthly purchase volume, variants, A+ content, bestseller ranks, hi-res images and 40+ more fields. Pay-per-result, no login required.",
        "version": "1.0",
        "x-build-id": "KKdsDrwkh4P5sCKd4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/santamaria-automations~amazon-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-santamaria-automations-amazon-product-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-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-santamaria-automations-amazon-product-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-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-santamaria-automations-amazon-product-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": "Product URLs",
                        "type": "array",
                        "description": "Amazon product page URLs. Any format works: `/dp/B09B8V1LZ3`, `/gp/product/B09B8V1LZ3`, or full slug URLs. Marketplace is auto-detected from the URL TLD. Combine with the ASINs 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"
                                }
                            }
                        }
                    },
                    "asins": {
                        "title": "ASINs",
                        "type": "array",
                        "description": "Bare ASINs (10 chars). The Marketplace Country below determines which Amazon to scrape these from. Combine with Product URLs above — both fields can be used together.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Z0-9]{10}$"
                        }
                    },
                    "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 ASINs field above. Ignored for entries in Product 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"
                    },
                    "maxItems": {
                        "title": "Max Products",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the total number of products scraped across this run. `0` = unlimited (scrape every URL + ASIN you provided).",
                        "default": 0
                    },
                    "scrapeReviewSample": {
                        "title": "Include Top Reviews",
                        "type": "boolean",
                        "description": "Return up to 8 top reviews per product (stars, title, author, date, body). Adds minimal cost. For the full review stream, use the Amazon Reviews Scraper.",
                        "default": true
                    },
                    "scrapeVariants": {
                        "title": "Include Variant ASINs",
                        "type": "boolean",
                        "description": "Include the list of sibling variant ASINs (sizes, colors, packs). Variant detail pages are NOT separately fetched in v1 — only their ASINs and dimension labels are returned. Pass those ASINs in a follow-up run to enrich them.",
                        "default": true
                    },
                    "zipCode": {
                        "title": "Delivery ZIP Code",
                        "type": "string",
                        "description": "Optional. Override the default delivery ZIP for the selected marketplace. Affects shown price, stock, and delivery date. Leave empty to use the marketplace default (e.g. 10001 for US, 10115 for DE, 75001 for FR)."
                    },
                    "concurrency": {
                        "title": "Concurrent Requests",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Products fetched in parallel. 5-10 is reliable for most workloads; higher (up to 50) is faster but increases the chance of transient blocks that force retries.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
