# Amazon Product Scraper (`leadsbrary/amazon-product-scraper`) Actor

From $1/1000 results. Extract product titles, prices, ratings, reviews, images, variants (color, size, style), seller info and more from Amazon search, category, best-seller and product pages — all major Amazon domains supported.

- **URL**: https://apify.com/leadsbrary/amazon-product-scraper.md
- **Developed by:** [Alexandre Manguis](https://apify.com/leadsbrary) (community)
- **Categories:** E-commerce, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 product data from Amazon search results, category pages, best-seller lists, and individual product pages — across all major Amazon domains worldwide. No Amazon account required.

### What you get

| Field | Description |
|---|---|
| `title` | Full product name |
| `asin` | Amazon product identifier (ASIN) |
| `brand` | Brand name |
| `price` | Current price with currency |
| `listPrice` | Original / crossed-out price |
| `stars` | Average customer rating (0–5) |
| `reviewsCount` | Total number of customer reviews |
| `inStock` | Stock availability (true/false) |
| `features` | Product bullet points |
| `description` | Full product description |
| `url` | Product URL |
| `thumbnailImage` | Main product image URL |
| `highResolutionImages` | All high-resolution image URLs |
| `breadCrumbs` | Category path |
| `delivery` | Delivery message |
| `seller` | Featured seller info |
| `variantDimensions` | Structured Color / Size / Style variants with ASINs |
| `variantDetails` | Flat list of all variant ASINs with prices |
| `offers` | Other sellers' offers (when maxOffers > 0) |
| `categoryPageData` | Position, badge, sponsored flag from search page |

### Input examples

**Search results**
```json
{
  "categoryOrProductUrls": [{ "url": "https://www.amazon.com/s?k=wireless+keyboard" }],
  "maxItemsPerStartUrl": 50,
  "scrapeProductDetails": true
}
````

**Single product page**

```json
{
  "categoryOrProductUrls": [{ "url": "https://www.amazon.com/dp/B0B3BVWJ6Y" }],
  "scrapeProductDetails": true
}
```

**Best-seller list**

```json
{
  "categoryOrProductUrls": [{ "url": "https://www.amazon.com/gp/bestsellers/electronics" }],
  "maxItemsPerStartUrl": 100,
  "scrapeProductDetails": true
}
```

**German Amazon — laptop search**

```json
{
  "categoryOrProductUrls": [{ "url": "https://www.amazon.de/s?k=laptop" }],
  "maxItemsPerStartUrl": 30,
  "language": "de",
  "proxyCountry": "DE",
  "scrapeProductDetails": true
}
```

**Fast listing-card mode (no product page)**

```json
{
  "categoryOrProductUrls": [{ "url": "https://www.amazon.com/s?k=headphones" }],
  "maxItemsPerStartUrl": 200,
  "scrapeProductDetails": false
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `categoryOrProductUrls` | array | — | Amazon URLs to scrape (search, category, best-seller, product). At least one required. |
| `maxItemsPerStartUrl` | integer | 100 | Max products per URL. Set to 0 for unlimited. |
| `scrapeProductDetails` | boolean | true | Open each product page for full data. Disable to get listing-card data only (faster). |
| `maxSearchPagesPerStartUrl` | integer | 9999 | Max search/category pages to paginate through per URL. |
| `maxProductVariantsAsSeparateResults` | integer | 0 | Max variant ASINs to enqueue as separate product results per product. |
| `scrapeProductVariantPrices` | boolean | false | Visit variant URLs to get their individual prices. Slower and higher blocking risk. |
| `maxOffers` | integer | 0 | Max offers to scrape from the offer-listing page per product. 0 = skip. |
| `scrapeSellers` | boolean | false | Enrich seller data from seller profile pages. |
| `language` | string | Domain default | Language for the Amazon interface (e.g. `en`, `de`, `fr`, `ja`). |
| `countryCode` | string | Not set | Best-effort delivery country code (e.g. `US`, `DE`). |
| `zipCode` | string | Not set | Best-effort ZIP/postal code for delivery location (e.g. `10001`). |
| `locationDeliverableRoutes` | array | All pages | Page types where delivery location is applied. |
| `useCaptchaSolver` | boolean | false | Automatically solve Amazon CAPTCHAs using your CAPTCHA service API key. |
| `captchaProvider` | string | 2captcha | CAPTCHA solving service: `2captcha` or `capsolver`. |
| `captchaApiKey` | string | — | Your personal API key from the selected CAPTCHA provider. |
| `maxConcurrency` | integer | 3 | Parallel browser pages. Lower is safer against blocking. |
| `maxRequestRetries` | integer | 3 | Retry attempts per failed request. |
| `requestTimeoutSecs` | integer | 90 | Per-page timeout in seconds. |
| `loadImages` | boolean | false | Load image resources in the browser. Disable for speed. |
| `proxyCountry` | string | Auto | Country for the proxy, auto-selected from the Amazon domain. |
| `proxyConfiguration` | object | No proxy | Proxy settings. Leave empty for no proxy. A reliable proxy is recommended for production. |

### Output example

```json
{
  "title": "Logitech MK270 Wireless Keyboard and Mouse Combo — Black",
  "asin": "B079JLY5M5",
  "brand": "Logitech",
  "url": "https://www.amazon.com/dp/B079JLY5M5",
  "price": { "value": 27.99, "currency": "$" },
  "listPrice": { "value": 39.99, "currency": "$" },
  "stars": 4.5,
  "reviewsCount": 118404,
  "inStock": true,
  "inStockText": "In Stock",
  "delivery": "FREE delivery Wednesday, May 25",
  "features": [
    "Wireless 2.4 GHz connection with a tiny Unifying receiver",
    "Full-size keyboard with 8 hot keys and number pad",
    "3-year battery life for keyboard, 18 months for mouse"
  ],
  "thumbnailImage": "https://m.media-amazon.com/images/I/71niXI9xqWL._AC_SX522_.jpg",
  "breadCrumbs": "Electronics > Computers & Accessories > Keyboard & Mouse Combos",
  "variantDimensions": [
    {
      "dimension": "color_name",
      "label": "Color",
      "selectedValue": "Black",
      "options": [
        { "asin": "B079JLY5M5", "value": "Black", "available": true },
        { "asin": "B0DHGGRYZ9", "value": "Off White", "available": true },
        { "asin": "B0D2X7DCG5", "value": "Rose", "available": true }
      ]
    },
    {
      "dimension": "size_name",
      "label": "Size",
      "selectedValue": "1 Pack",
      "options": [
        { "asin": "B079JLY5M5", "value": "1 Pack", "available": true },
        { "asin": "B0DK5M7QJR", "value": "4 Pack", "available": true }
      ]
    },
    {
      "dimension": "style_name",
      "label": "Style",
      "selectedValue": "Combo",
      "options": [
        { "asin": "B004N627KS", "value": "Keyboard", "available": true },
        { "asin": "B079JLY5M5", "value": "Combo", "available": true },
        { "asin": "B08H6Y88K4", "value": "Keyboard and Mouse Combo", "available": true }
      ]
    }
  ],
  "categoryPageData": {
    "categoryUrl": "https://www.amazon.com/s?k=keyboard",
    "productPosition": 3,
    "pageNumber": 1,
    "isSponsored": false,
    "bestsellerBadge": null
  }
}
```

### Tips

- **Match proxy country to domain** — Set `proxyCountry` to match the Amazon domain (e.g. `DE` for amazon.de) to get accurate local prices and availability.
- **Listing-card mode for large catalogs** — Set `scrapeProductDetails: false` to get title, ASIN, price, rating, and image from search pages without opening each product. 5–10× faster.
- **Pagination control** — Use `maxSearchPagesPerStartUrl` with `maxItemsPerStartUrl` to limit large category pages.
- **Multiple countries at once** — Use separate start URLs for different Amazon domains (amazon.com, amazon.de, amazon.fr, etc.) in the same run.
- **Variants** — `variantDimensions` gives you every color, size, and style option with its ASIN. Use `maxProductVariantsAsSeparateResults` to scrape each variant as a full separate product.
- **CAPTCHA solver** — If you frequently hit Amazon CAPTCHAs, enable `useCaptchaSolver` with your own API key from [2captcha.com](https://2captcha.com) or [capsolver.com](https://capsolver.com).

### Keywords

amazon scraper, amazon product data, amazon search scraper, amazon price tracker, amazon ASIN extractor, amazon category scraper, amazon bestseller scraper, ecommerce data, product research, price monitoring, amazon review count, product availability checker, amazon data extraction, crawl amazon, amazon variants, amazon color size scraper, multi-domain amazon

# Actor input Schema

## `categoryOrProductUrls` (type: `array`):

Amazon search, category, best-seller, or product URLs to scrape. Examples: https://www.amazon.com/s?k=keyboard, https://www.amazon.com/dp/B0B3BVWJ6Y.

## `maxItemsPerStartUrl` (type: `integer`):

Maximum number of products to save for each start URL. Set to 0 for unlimited.

## `scrapeProductDetails` (type: `boolean`):

Open each product page for full data (title, description, variants, seller, etc.). Disable to get listing-card data only — much faster.

## `maxSearchPagesPerStartUrl` (type: `integer`):

Maximum number of search/category pages to paginate through for each start URL.

## `maxProductVariantsAsSeparateResults` (type: `integer`):

Maximum number of variant ASINs to enqueue as separate product results per parent product. Variant details are always included in the variantDimensions field.

## `scrapeProductVariantPrices` (type: `boolean`):

Visit a limited number of variant product URLs to get their individual prices. Increases run time and blocking risk.

## `maxOffers` (type: `integer`):

Maximum number of offers to scrape from the offer-listing page per product. Set to 0 to skip.

## `scrapeSellers` (type: `boolean`):

Extract seller data from product pages and enrich the featured seller from their profile page.

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

Language hint for Amazon pages. Each domain supports a different set of languages — unsupported values are ignored.

## `countryCode` (type: `string`):

Best-effort delivery country code. For accurate local prices, use the matching Amazon domain and proxyCountry.

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

Best-effort ZIP or postal code for Amazon delivery location, e.g. 10001.

## `locationDeliverableRoutes` (type: `array`):

Page types where the delivery location should be applied.

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

Automatically solve Amazon image CAPTCHAs using your own CAPTCHA service API key. Requires captchaApiKey and captchaProvider.

## `captchaProvider` (type: `string`):

CAPTCHA solving service to use. You must have your own account with the selected provider.

## `captchaApiKey` (type: `string`):

Your personal API key from the selected CAPTCHA provider. Required when useCaptchaSolver is enabled.

## `maxConcurrency` (type: `integer`):

Maximum number of browser pages to run in parallel. Lower values are safer against blocking.

## `maxRequestRetries` (type: `integer`):

How many times to retry a failed request before marking it as failed.

## `requestTimeoutSecs` (type: `integer`):

Timeout for a single page request in seconds.

## `loadImages` (type: `boolean`):

Load image resources in the browser. Disable for faster runs — product image URLs are still extracted from HTML.

## `proxyCountry` (type: `string`):

Country for the proxy. AUTO\_SELECT\_PROXY\_COUNTRY picks a country matching the Amazon domain (e.g. amazon.de → DE).

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

Proxy settings. Leave empty to run without a proxy. For production use, a reliable proxy is strongly recommended — Amazon blocks datacenter IPs aggressively.

## Actor input object example

```json
{
  "categoryOrProductUrls": [
    {
      "url": "https://www.amazon.com/s?k=keyboard"
    }
  ],
  "maxItemsPerStartUrl": 100,
  "scrapeProductDetails": true,
  "maxSearchPagesPerStartUrl": 5,
  "maxProductVariantsAsSeparateResults": 0,
  "scrapeProductVariantPrices": false,
  "maxOffers": 0,
  "scrapeSellers": false,
  "language": "",
  "countryCode": "",
  "zipCode": "",
  "locationDeliverableRoutes": [
    "PRODUCT",
    "SEARCH",
    "OFFERS"
  ],
  "useCaptchaSolver": false,
  "captchaProvider": "2captcha",
  "maxConcurrency": 3,
  "maxRequestRetries": 3,
  "requestTimeoutSecs": 90,
  "loadImages": false,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
  "proxyConfiguration": {}
}
```

# Actor output Schema

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

No description

# 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 = {
    "categoryOrProductUrls": [
        {
            "url": "https://www.amazon.com/s?k=keyboard"
        }
    ],
    "maxItemsPerStartUrl": 100,
    "scrapeProductDetails": true,
    "maxSearchPagesPerStartUrl": 5,
    "maxProductVariantsAsSeparateResults": 0,
    "scrapeProductVariantPrices": false,
    "maxOffers": 0,
    "scrapeSellers": false,
    "zipCode": "",
    "locationDeliverableRoutes": [
        "PRODUCT",
        "SEARCH",
        "OFFERS"
    ],
    "useCaptchaSolver": false,
    "maxConcurrency": 3,
    "maxRequestRetries": 3,
    "requestTimeoutSecs": 90,
    "loadImages": false,
    "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
    "proxyConfiguration": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("leadsbrary/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 = {
    "categoryOrProductUrls": [{ "url": "https://www.amazon.com/s?k=keyboard" }],
    "maxItemsPerStartUrl": 100,
    "scrapeProductDetails": True,
    "maxSearchPagesPerStartUrl": 5,
    "maxProductVariantsAsSeparateResults": 0,
    "scrapeProductVariantPrices": False,
    "maxOffers": 0,
    "scrapeSellers": False,
    "zipCode": "",
    "locationDeliverableRoutes": [
        "PRODUCT",
        "SEARCH",
        "OFFERS",
    ],
    "useCaptchaSolver": False,
    "maxConcurrency": 3,
    "maxRequestRetries": 3,
    "requestTimeoutSecs": 90,
    "loadImages": False,
    "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
    "proxyConfiguration": {},
}

# Run the Actor and wait for it to finish
run = client.actor("leadsbrary/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 '{
  "categoryOrProductUrls": [
    {
      "url": "https://www.amazon.com/s?k=keyboard"
    }
  ],
  "maxItemsPerStartUrl": 100,
  "scrapeProductDetails": true,
  "maxSearchPagesPerStartUrl": 5,
  "maxProductVariantsAsSeparateResults": 0,
  "scrapeProductVariantPrices": false,
  "maxOffers": 0,
  "scrapeSellers": false,
  "zipCode": "",
  "locationDeliverableRoutes": [
    "PRODUCT",
    "SEARCH",
    "OFFERS"
  ],
  "useCaptchaSolver": false,
  "maxConcurrency": 3,
  "maxRequestRetries": 3,
  "requestTimeoutSecs": 90,
  "loadImages": false,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
  "proxyConfiguration": {}
}' |
apify call leadsbrary/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Scraper",
        "description": "From $1/1000 results. Extract product titles, prices, ratings, reviews, images, variants (color, size, style), seller info and more from Amazon search, category, best-seller and product pages — all major Amazon domains supported.",
        "version": "0.1",
        "x-build-id": "dgFk1BnFccQYtlGrQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/leadsbrary~amazon-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-leadsbrary-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/leadsbrary~amazon-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-leadsbrary-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/leadsbrary~amazon-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-leadsbrary-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",
                "required": [
                    "categoryOrProductUrls"
                ],
                "properties": {
                    "categoryOrProductUrls": {
                        "title": "Amazon URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Amazon search, category, best-seller, or product URLs to scrape. Examples: https://www.amazon.com/s?k=keyboard, https://www.amazon.com/dp/B0B3BVWJ6Y.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItemsPerStartUrl": {
                        "title": "Max results per URL",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to save for each start URL. Set to 0 for unlimited.",
                        "default": 100
                    },
                    "scrapeProductDetails": {
                        "title": "Scrape product details",
                        "type": "boolean",
                        "description": "Open each product page for full data (title, description, variants, seller, etc.). Disable to get listing-card data only — much faster.",
                        "default": true
                    },
                    "maxSearchPagesPerStartUrl": {
                        "title": "Max search pages per URL",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of search/category pages to paginate through for each start URL.",
                        "default": 9999
                    },
                    "maxProductVariantsAsSeparateResults": {
                        "title": "Max variants as separate results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of variant ASINs to enqueue as separate product results per parent product. Variant details are always included in the variantDimensions field.",
                        "default": 0
                    },
                    "scrapeProductVariantPrices": {
                        "title": "Scrape variant prices",
                        "type": "boolean",
                        "description": "Visit a limited number of variant product URLs to get their individual prices. Increases run time and blocking risk.",
                        "default": false
                    },
                    "maxOffers": {
                        "title": "Max offers per product",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of offers to scrape from the offer-listing page per product. Set to 0 to skip.",
                        "default": 0
                    },
                    "scrapeSellers": {
                        "title": "Scrape seller data",
                        "type": "boolean",
                        "description": "Extract seller data from product pages and enrich the featured seller from their profile page.",
                        "default": false
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "",
                            "cs",
                            "da",
                            "de",
                            "en",
                            "es",
                            "fr",
                            "nl",
                            "pl",
                            "pt",
                            "sv",
                            "tr",
                            "he",
                            "ar",
                            "mrta",
                            "hi",
                            "bn",
                            "ta",
                            "te",
                            "kn",
                            "ml",
                            "ko",
                            "zh_CN",
                            "zh_TW",
                            "ja"
                        ],
                        "type": "string",
                        "description": "Language hint for Amazon pages. Each domain supports a different set of languages — unsupported values are ignored.",
                        "default": ""
                    },
                    "countryCode": {
                        "title": "Delivery country",
                        "enum": [
                            "",
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "CA",
                            "AU",
                            "JP",
                            "IN",
                            "MX",
                            "BR",
                            "NL",
                            "SE",
                            "PL",
                            "TR",
                            "AE",
                            "SA",
                            "SG"
                        ],
                        "type": "string",
                        "description": "Best-effort delivery country code. For accurate local prices, use the matching Amazon domain and proxyCountry.",
                        "default": ""
                    },
                    "zipCode": {
                        "title": "ZIP / postal code",
                        "type": "string",
                        "description": "Best-effort ZIP or postal code for Amazon delivery location, e.g. 10001.",
                        "default": ""
                    },
                    "locationDeliverableRoutes": {
                        "title": "Apply delivery location on",
                        "type": "array",
                        "description": "Page types where the delivery location should be applied.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "PRODUCT",
                                "SEARCH",
                                "OFFERS"
                            ],
                            "enumTitles": [
                                "Product pages",
                                "Search/category pages",
                                "Offer-listing pages"
                            ]
                        },
                        "default": [
                            "PRODUCT",
                            "SEARCH",
                            "OFFERS"
                        ]
                    },
                    "useCaptchaSolver": {
                        "title": "Use CAPTCHA solver",
                        "type": "boolean",
                        "description": "Automatically solve Amazon image CAPTCHAs using your own CAPTCHA service API key. Requires captchaApiKey and captchaProvider.",
                        "default": false
                    },
                    "captchaProvider": {
                        "title": "CAPTCHA provider",
                        "enum": [
                            "2captcha",
                            "capsolver"
                        ],
                        "type": "string",
                        "description": "CAPTCHA solving service to use. You must have your own account with the selected provider.",
                        "default": "2captcha"
                    },
                    "captchaApiKey": {
                        "title": "CAPTCHA API key",
                        "type": "string",
                        "description": "Your personal API key from the selected CAPTCHA provider. Required when useCaptchaSolver is enabled."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of browser pages to run in parallel. Lower values are safer against blocking.",
                        "default": 3
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry a failed request before marking it as failed.",
                        "default": 3
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 15,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Timeout for a single page request in seconds.",
                        "default": 90
                    },
                    "loadImages": {
                        "title": "Load images",
                        "type": "boolean",
                        "description": "Load image resources in the browser. Disable for faster runs — product image URLs are still extracted from HTML.",
                        "default": false
                    },
                    "proxyCountry": {
                        "title": "Proxy country",
                        "enum": [
                            "AUTO_SELECT_PROXY_COUNTRY",
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "CA",
                            "AU",
                            "JP",
                            "IN",
                            "MX",
                            "BR",
                            "NL",
                            "SE",
                            "PL",
                            "TR",
                            "AE",
                            "SA",
                            "SG"
                        ],
                        "type": "string",
                        "description": "Country for the proxy. AUTO_SELECT_PROXY_COUNTRY picks a country matching the Amazon domain (e.g. amazon.de → DE).",
                        "default": "AUTO_SELECT_PROXY_COUNTRY"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Leave empty to run without a proxy. For production use, a reliable proxy is strongly recommended — Amazon blocks datacenter IPs aggressively.",
                        "default": {}
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
