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

"Amazon Product Scraper extracts product data with precision. Capture titles, prices, images, reviews, ratings, variations, and seller details fast. Ideal for market research, price tracking, and e-commerce insights with clean, structured JSON output

- **URL**: https://apify.com/simpleapi/amazon-product-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### 🤖 What is Amazon Product Scraper?

An Amazon Product Scraper is a smart web automation tool that extracts product details, prices, reviews, ratings, ASINs, and images directly from Amazon in seconds ⚡. Whether you’re building an e-commerce database, conducting market research, or running a price comparison tool, an Amazon scraper saves you countless hours.

Using platforms like Apify Amazon Scraper, Amazon Product Scraper Python, or even a Chrome extension, you can easily gather structured product data for analysis or automation.

✨ SEO Advantage: By leveraging accurate Amazon data, businesses can optimize listings, monitor competitors, and power AI-driven marketing insights — all while staying data-informed.

* * *

### 📦 What Amazon Product Scraper Can Extract

Below is a breakdown of what you can extract using tools like Apify Amazon Product Scraper, Amazon Product Scraper Free, or Amazon Scraper Python scripts:

| 🧩 Data Type | 💡 Description |
| --- | --- |
| Product Name | The title of the product listed on Amazon |
| ASIN (Amazon ID) | Unique Amazon Standard Identification Number |
| Price & Discounts | Regular price, sale price, and currency |
| Availability | Stock status, Prime eligibility, and delivery time |
| Ratings & Reviews | Average star rating, total review count |
| Product Details | Features, description, specifications |
| Category & Breadcrumbs | Product’s category path on Amazon |
| Images & Videos | URLs to product media assets |
| Seller Information | Seller name, store URL, and location |

🧠 Tools like Amazon Product Scraper GitHub projects or Apify Amazon Scraper API give you flexible access to all this data for analysis or integration.

* * *

### ⚙️ Key Features of Amazon Product Scraper ✨

Here’s why the Amazon Product Scraper software stands out among all other data extraction tools:

*   🔄 Bulk Data Extraction — Scrape thousands of product pages using Amazon Product Scraper Python or Apify Amazon Scraper in one go.  
      
    
*   🧠 Smart Variation Detection — Automatically captures color, size, and pack variations.  
      
    
*   💾 Structured JSON Output — Easy to integrate with your apps, APIs, or BI tools.  
      
    
*   🧩 Proxy & Anti-blocking Support — Ensures smooth and consistent scraping performance.  
      
    
*   🧮 Real-time Data Validation — Detects missing or mismatched ASINs automatically.  
      
    
*   💻 Multiple Platforms Supported — Works via Chrome Extension, API, or even open-source GitHub Amazon Product Scraper Python projects.  
      
    
*   🔔 Notifications & Scheduling — Automate runs and receive updates when new data is available.  
      
    
*   💸 Free & Paid Options — Choose between Amazon Product Scraper Free or enterprise-level solutions depending on your project scale.  
      
    

* * *

### 🧭 How to Use Amazon Product Scraper

Follow this step-by-step guide to extract data from Amazon efficiently using Apify Amazon Product Scraper or a Python-based scraper:

1.  🔐 Log in to Apify — Create a free account or log in to your Apify dashboard.  
      
    
2.  🧭 Select the Actor — Search for “Amazon Product Scraper” in the Apify Store.  
      
    
3.  📥 Enter Input Data — Add Amazon product URLs or subcategory links (like /s?...).  
      
    
4.  ⚙️ Choose Options — Customize options like max item count, proxy region, and output format.  
      
    
5.  ▶️ Run the Actor — Click “Start” to begin scraping. The actor will extract data automatically.  
      
    
6.  📊 Download Results — Export your dataset in JSON, CSV, or via the Apify API.  
      
    

💡 For developers, GitHub Amazon Product Scraper Python repositories provide open-source examples to build custom scrapers.

* * *

### 🎯 Use Cases

Here’s how professionals use Amazon Product Scraper software across industries:

*   🛍️ E-commerce Intelligence — Track competitor prices and stock changes in real time.  
      
    
*   📊 Market Research — Analyze product performance, trends, and customer sentiment.  
      
    
*   💰 Dynamic Pricing — Use live data from Amazon to adjust your product pricing automatically.  
      
    
*   🧠 Product Development — Identify customer needs and top-performing features.  
      
    
*   🧾 Affiliate Marketing — Generate SEO-optimized content with real-time product data.  
      
    
*   🤝 Data Enrichment — Combine Amazon data with CRM or ERP systems for deep insights.  
      
    

* * *

### 🌟 Why Choose Our Amazon Product Scraper?

Our Amazon Product Scraper app stands apart because it’s built for speed, scalability, and precision 🔥

*   ✅ Easy to use — No coding needed; start scraping instantly.  
      
    
*   ⚙️ Customizable API Access — Seamless integration with Amazon Product Scraper API.  
      
    
*   🌍 Multi-region Proxy Support — Extract data globally without interruptions.  
      
    
*   🧩 Developer Friendly — Fully compatible with Amazon Product Scraper GitHub templates.  
      
    
*   💸 Flexible Pricing — Start with Amazon Product Scraper Free, upgrade as you grow.  
      
    
*   🧠 AI-Enhanced Accuracy — Cleans, validates, and structures your data automatically.  
      
    

* * *

### 🚀 How Many Results Can You Scrape with Amazon Product Scraper?

Depending on your setup and input complexity, the Amazon Product Scraper can extract up to 100,000+ results per run 💪.

*   📍 Apify Amazon Scraper users can scale up automatically using actor concurrency.  
      
    
*   ⚙️ Python Amazon Scraper scripts can handle thousands of URLs using async requests.  
      
    
*   🌐 Chrome Extension scrapers are better for small batch data collection (less than 500 products).  
      
    

| Tool Type | Scalability | Best For |
| --- | --- | --- |
| Apify Amazon Product Scraper | 🔝 Very High | Enterprise-scale data extraction |
| Amazon Scraper Python | 🔧 Medium | Developers and researchers |
| Amazon Product Scraper Chrome Extension | ⚡ Fast Setup | Small scraping tasks |

✨ Pro Tip: Combine Amazon Product Scraper API with your analytics tools (like Power BI or Google Sheets) for real-time dashboards.

* * *

### ⚖️ Is It Legal to Scrape Amazon?

Scraping publicly available Amazon data (like prices, titles, and ratings) is generally legal, as long as you:

*   ✅ Respect Amazon’s robots.txt and API terms  
      
    
*   ✅ Don’t collect private or sensitive data  
      
    
*   ✅ Use scraping for research, analytics, or price comparison only  
      
    

If you’re unsure, consult legal experts and consider using Apify Amazon Scraper, which is built with compliance and responsible data collection in mind.

* * *

### 🧾 Input Parameters

Example JSON input for the Amazon Product Scraper API 👇

```json
{
  "categoryOrProductUrls": [
    "https://www.amazon.com/s?k=keyboard",
    "https://www.amazon.com/dp/B08N5WRWNW"
  ],
  "maxItemsPerStartUrl": 100,
  "maxSearchPagesPerStartUrl": 9999,
  "maxConcurrentRequests": 10,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Parameter | Type | Description |
| --- | --- | --- |
| categoryOrProductUrls | Array | **Required.** Search URLs (e.g. /s?k=keyboard) or product URLs (e.g. /dp/ASIN) |
| maxItemsPerStartUrl | Integer | Max products to scrape per URL (default: 100) |
| maxSearchPagesPerStartUrl | Integer | Max search pages per URL (default: 9999) |
| maxConcurrentRequests | Integer | Concurrent product page requests (default: 10) |
| proxyCountry | String | Proxy country or AUTO\_SELECT\_PROXY\_COUNTRY; use NO\_PROXY to disable |
| proxyConfiguration | Object | Apify proxy settings (residential recommended) |

***

### 📤 Output Format

**Dataset:** One item per product (each product object as in the table below).

**Default key-value store (OUTPUT):** Full result object:

```json
{
  "status": "success",
  "scrapedAt": "2026-02-23T11:54:58.662655",
  "duration": "111.31s",
  "stats": {
    "totalProducts": 100,
    "totalErrors": 0,
    "urlsProcessed": 1
  },
  "products": [ { ... } ],
  "errors": null
}
```

Each product in `products` includes:

| Field | Type | Description |
| --- | --- | --- |
| asin | String | Product ASIN |
| title | String | Product name |
| url | String | Product page URL |
| price | Object | `{ "value", "currency" }` |
| listPrice | Object | List/crossed price |
| inStock | Boolean | Availability |
| brand | String | Brand name |
| stars | Float | Average rating |
| reviewsCount | Integer | Review count |
| breadCrumbs | String | Category path |
| thumbnailImage | String | Main image URL |
| galleryThumbnails | Array | Gallery image URLs |
| features | Array | Bullet points |
| productOverview | Array | `{ "key", "value" }` specs |
| seller | Object | Seller id, url, name |
| bestsellerRanks | Array | `{ "rank", "category" }` |
| delivery, fastestDelivery | String | Delivery dates |
| and more | — | Same structure as reference output |

***

### ❓ FAQ

#### 1. Is there a free Amazon Product Scraper?

👉 Yes! You can use Amazon Product Scraper Free on platforms like Apify or explore open-source GitHub versions.

#### 2. How do I build my own scraper?

Use Amazon Product Scraper Python GitHub templates — customize them with requests, BeautifulSoup, or Scrapy.

#### 3. Can I integrate it with my app?

Absolutely! Use the Amazon Product Scraper API for smooth integration with your CRM or BI tools.

#### 4. Does it work as a Chrome Extension?

Yes, the Amazon Product Scraper Chrome Extension is perfect for quick, small-scale scrapes.

#### 5. What’s the best Apify Actor for this?

The Apify Amazon Product Scraper Actor is ideal for scalable, automated data extraction.

#### 6. Is it safe to scrape Amazon?

Yes, as long as you scrape public data responsibly and comply with Amazon’s guidelines.

#### 7. Can I extract reviews and ratings?

✅ Yes! The scraper can collect star ratings, review counts, and even review text.

***

### 🌍 Final Thoughts

The Amazon Product Scraper — whether it’s a GitHub script, Apify Actor, or Chrome Extension — is your key to unlocking powerful e-commerce insights 💥. Use it to monitor trends, optimize pricing, and gain a competitive edge in the marketplace.

⚡ Start today with Apify Amazon Scraper or explore Amazon Product Scraper Free options to automate your data collection journey!

# Actor input Schema

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

Use a link to the Amazon category you want to scrape, e.g. video games - https://www.amazon.com/s?bbn=16225016011\&rh=n%3A20972781011, https://www.amazon.com/dp/B0B3BVWJ6Y. You can also filter within the category with almost any filter available, i.e. price, manufacturer, rating, etc. By using a different URL you can also choose a different Amazon country, e.g. Germany: https://www.amazon.de/. You don't need to set a proxy country to do that.

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

Enter the maximum number of results you want to scrape per each start URL. This will let the scraper know when to stop.

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

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

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

You can set proxy country to avoid geo-blocking and access region-specific content. Amazon shows you the products that can be shipped to your address based on the proxy you use. By default, the scraper automatically selects the proxy country based on the used Amazon website domain, ensuring low blocking rates and results relevant to the base domain.

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

Enter the maximum number of search pages to scrape for each start URL. E.g. only scrape the first 5 pages. This field can also be used with the maxItemsPerStartUrl option, the scraper will stop after either one of these limits is reached.

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

Enter the maximum number of product variants you want to scrape per each product, outputted as separate results. Please beware that you can already get most of the variant details changes, in the variantDetails field, which is outputted by default. Note that this will increase the number of requests and extend the scraping time.

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

Enter the maximum number of offers you want to scrape per each product. This will let the scraper know when to stop. Note that this will increase the number of requests and extend the scraping time.

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

Enable this option to extract further information about sellers of the product. Scrapes the featured offer seller (main seller). This option goes hand in hand with the maxOffers option by scraping the seller of each offer. If you set maxOffers to 0, only the featured offer seller will be scraped. Note that this will increase the number of requests and extend the scraping time.

## `ensureLoadedProductDescriptionFields` (type: `boolean`):

Enable this feature to always load all seller-editable product description fields, such as description, aPlusContent, attributes, etc. Amazon sometimes hides these fields as a form of blocking. Enabling this option helps ensure data consistency but will increase the number of requests and may extend scraping time based on the blocking rate. Turn it on only if you need the data.

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

If enabled the scraper will automatically solve captchas thrown by Amazon. This will decrease the amount of request retries and increase the speed of the scraper. IMPORTANT - This option works well only for the '.com' Amazon domain, but even for that one Amazon doesn't show a few product fields after solving a captcha (specifically: 'attributes', 'manufacturer attributes', and 'bestseller ranks').

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

Enable this option to extract prices of different variations of a product. Useful when you need prices for each variant. Note that this will increase the number of requests and extend the scraping time.

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

If enabled, the scraper will extract each found product from the category page in detail (this is the default behavior). If disabled, the scraper will only extract the quick product information from the category page. Useful for faster and more lightweight searches for products.

## `maxConcurrentRequests` (type: `integer`):

Number of concurrent product page requests.

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

The country code to use as the delivery location.

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

The zip code to use as the delivery location. This is useful for more precise location settings, especially in larger countries.

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

The list of routes/page types, for which the deliverable location settings should be applied. This is useful for speeding up the scraping process by not applying the location settings to all pages, for which you don't need the localized data for. For example, you can set it to \['SEARCH', 'PRODUCT'] to apply the location settings only to search and product pages. By default, all pages are included.

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

🔒 Apify proxy settings. Use residential proxy for best results and fewer blocks.

## Actor input object example

```json
{
  "categoryOrProductUrls": [
    "https://www.amazon.com/s?k=keyboard"
  ],
  "maxItemsPerStartUrl": 10,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
  "maxSearchPagesPerStartUrl": 9999,
  "maxOffers": 0,
  "scrapeSellers": false,
  "ensureLoadedProductDescriptionFields": false,
  "useCaptchaSolver": false,
  "scrapeProductVariantPrices": false,
  "scrapeProductDetails": true,
  "maxConcurrentRequests": 10,
  "locationDeliverableRoutes": [
    "PRODUCT",
    "SEARCH",
    "OFFERS"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": [
        "https://www.amazon.com/s?k=keyboard"
    ],
    "locationDeliverableRoutes": [
        "PRODUCT",
        "SEARCH",
        "OFFERS"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/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": ["https://www.amazon.com/s?k=keyboard"],
    "locationDeliverableRoutes": [
        "PRODUCT",
        "SEARCH",
        "OFFERS",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/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": [
    "https://www.amazon.com/s?k=keyboard"
  ],
  "locationDeliverableRoutes": [
    "PRODUCT",
    "SEARCH",
    "OFFERS"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call simpleapi/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Scraper",
        "description": "\"Amazon Product Scraper extracts product data with precision. Capture titles, prices, images, reviews, ratings, variations, and seller details fast. Ideal for market research, price tracking, and e-commerce insights with clean, structured JSON output",
        "version": "0.2",
        "x-build-id": "0apBNzDGGxbstGM5x"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/simpleapi~amazon-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-simpleapi-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/simpleapi~amazon-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-simpleapi-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/simpleapi~amazon-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-simpleapi-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": "🔗 Enter one or more Amazon category or product URLs",
                        "type": "array",
                        "description": "Use a link to the Amazon category you want to scrape, e.g. video games - https://www.amazon.com/s?bbn=16225016011&rh=n%3A20972781011, https://www.amazon.com/dp/B0B3BVWJ6Y. You can also filter within the category with almost any filter available, i.e. price, manufacturer, rating, etc. By using a different URL you can also choose a different Amazon country, e.g. Germany: https://www.amazon.de/. You don't need to set a proxy country to do that.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerStartUrl": {
                        "title": "📊 Max results (per start URL)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Enter the maximum number of results you want to scrape per each start URL. This will let the scraper know when to stop.",
                        "default": 10
                    },
                    "language": {
                        "title": "🌐 Language",
                        "enum": [
                            "cs",
                            "da",
                            "de",
                            "en",
                            "es",
                            "fr",
                            "nl",
                            "pl",
                            "pt",
                            "sv",
                            "tr",
                            "he",
                            "ar",
                            "mrta",
                            "hi",
                            "bn",
                            "ta",
                            "te",
                            "kn",
                            "ml",
                            "ko",
                            "zh_CN",
                            "zh_TW",
                            "ja"
                        ],
                        "type": "string",
                        "description": "Language to use on Amazon. Disclaimer: each Amazon domain has a different set of supported languages. If you choose a language that is not supported by the domain, the scraper will use the default language of the domain."
                    },
                    "proxyCountry": {
                        "title": "🌍 Proxy country",
                        "enum": [
                            "AUTO_SELECT_PROXY_COUNTRY",
                            "NO_PROXY",
                            "AF",
                            "AL",
                            "DZ",
                            "AS",
                            "AD",
                            "AO",
                            "AI",
                            "AQ",
                            "AG",
                            "AR",
                            "AM",
                            "AW",
                            "AU",
                            "AT",
                            "AZ",
                            "BS",
                            "BH",
                            "BD",
                            "BB",
                            "BY",
                            "BE",
                            "BZ",
                            "BJ",
                            "BM",
                            "BT",
                            "BO",
                            "BQ",
                            "BA",
                            "BW",
                            "BV",
                            "BR",
                            "IO",
                            "VG",
                            "BN",
                            "BG",
                            "BF",
                            "BI",
                            "KH",
                            "CM",
                            "CA",
                            "CV",
                            "KY",
                            "CF",
                            "TD",
                            "CL",
                            "CN",
                            "CX",
                            "CC",
                            "CO",
                            "KM",
                            "CK",
                            "CR",
                            "HR",
                            "CU",
                            "CW",
                            "CY",
                            "CZ",
                            "CD",
                            "DK",
                            "DJ",
                            "DM",
                            "DO",
                            "TL",
                            "EC",
                            "EG",
                            "SV",
                            "GQ",
                            "ER",
                            "EE",
                            "ET",
                            "FK",
                            "FO",
                            "FJ",
                            "FI",
                            "FR",
                            "GF",
                            "PF",
                            "TF",
                            "GA",
                            "GM",
                            "GE",
                            "DE",
                            "GH",
                            "GI",
                            "GR",
                            "GL",
                            "GD",
                            "GP",
                            "GU",
                            "GT",
                            "GG",
                            "GW",
                            "GN",
                            "GY",
                            "HT",
                            "HM",
                            "HN",
                            "HK",
                            "HU",
                            "IS",
                            "IN",
                            "ID",
                            "IR",
                            "IQ",
                            "IE",
                            "IM",
                            "IL",
                            "IT",
                            "CI",
                            "JM",
                            "JP",
                            "JE",
                            "JO",
                            "KZ",
                            "KE",
                            "KI",
                            "XK",
                            "KW",
                            "KG",
                            "LA",
                            "LV",
                            "LB",
                            "LS",
                            "LR",
                            "LY",
                            "LI",
                            "LT",
                            "LU",
                            "MO",
                            "MG",
                            "MW",
                            "MY",
                            "MV",
                            "ML",
                            "MT",
                            "MH",
                            "MQ",
                            "MR",
                            "MU",
                            "YT",
                            "MX",
                            "FM",
                            "MD",
                            "MC",
                            "MN",
                            "ME",
                            "MS",
                            "MA",
                            "MZ",
                            "MM",
                            "NA",
                            "NR",
                            "NP",
                            "NL",
                            "NC",
                            "NZ",
                            "NI",
                            "NE",
                            "NG",
                            "NU",
                            "NF",
                            "KP",
                            "MK",
                            "MP",
                            "NO",
                            "OM",
                            "PK",
                            "PW",
                            "PS",
                            "PA",
                            "PG",
                            "PY",
                            "PE",
                            "PH",
                            "PN",
                            "PL",
                            "PT",
                            "PR",
                            "QA",
                            "CG",
                            "RE",
                            "RO",
                            "RU",
                            "RW",
                            "BL",
                            "SH",
                            "KN",
                            "LC",
                            "MF",
                            "PM",
                            "VC",
                            "WS",
                            "SM",
                            "ST",
                            "SA",
                            "SN",
                            "RS",
                            "SC",
                            "SL",
                            "SG",
                            "SX",
                            "SK",
                            "SI",
                            "SB",
                            "SO",
                            "ZA",
                            "GS",
                            "KR",
                            "SS",
                            "ES",
                            "LK",
                            "SD",
                            "SR",
                            "SJ",
                            "SZ",
                            "SE",
                            "CH",
                            "SY",
                            "TW",
                            "TJ",
                            "TZ",
                            "TH",
                            "TG",
                            "TK",
                            "TO",
                            "TT",
                            "TN",
                            "TR",
                            "TM",
                            "TC",
                            "TV",
                            "UM",
                            "VI",
                            "UG",
                            "UA",
                            "AE",
                            "GB",
                            "US",
                            "UY",
                            "UZ",
                            "VU",
                            "VA",
                            "VE",
                            "VN",
                            "WF",
                            "EH",
                            "YE",
                            "ZM",
                            "ZW",
                            "AX"
                        ],
                        "type": "string",
                        "description": "You can set proxy country to avoid geo-blocking and access region-specific content. Amazon shows you the products that can be shipped to your address based on the proxy you use. By default, the scraper automatically selects the proxy country based on the used Amazon website domain, ensuring low blocking rates and results relevant to the base domain.",
                        "default": "AUTO_SELECT_PROXY_COUNTRY"
                    },
                    "maxSearchPagesPerStartUrl": {
                        "title": "📄 Maximum search pages (per start URL)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Enter the maximum number of search pages to scrape for each start URL. E.g. only scrape the first 5 pages. This field can also be used with the maxItemsPerStartUrl option, the scraper will stop after either one of these limits is reached.",
                        "default": 9999
                    },
                    "maxProductVariantsAsSeparateResults": {
                        "title": "🔄 Maximum product variants (as separate results)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Enter the maximum number of product variants you want to scrape per each product, outputted as separate results. Please beware that you can already get most of the variant details changes, in the variantDetails field, which is outputted by default. Note that this will increase the number of requests and extend the scraping time."
                    },
                    "maxOffers": {
                        "title": "💰 Maximum scraped offers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Enter the maximum number of offers you want to scrape per each product. This will let the scraper know when to stop. Note that this will increase the number of requests and extend the scraping time.",
                        "default": 0
                    },
                    "scrapeSellers": {
                        "title": "👤 Scrape sellers",
                        "type": "boolean",
                        "description": "Enable this option to extract further information about sellers of the product. Scrapes the featured offer seller (main seller). This option goes hand in hand with the maxOffers option by scraping the seller of each offer. If you set maxOffers to 0, only the featured offer seller will be scraped. Note that this will increase the number of requests and extend the scraping time.",
                        "default": false
                    },
                    "ensureLoadedProductDescriptionFields": {
                        "title": "📝 Ensure loaded product description fields",
                        "type": "boolean",
                        "description": "Enable this feature to always load all seller-editable product description fields, such as description, aPlusContent, attributes, etc. Amazon sometimes hides these fields as a form of blocking. Enabling this option helps ensure data consistency but will increase the number of requests and may extend scraping time based on the blocking rate. Turn it on only if you need the data.",
                        "default": false
                    },
                    "useCaptchaSolver": {
                        "title": "🤖 Use Captcha solver (warning: see description)",
                        "type": "boolean",
                        "description": "If enabled the scraper will automatically solve captchas thrown by Amazon. This will decrease the amount of request retries and increase the speed of the scraper. IMPORTANT - This option works well only for the '.com' Amazon domain, but even for that one Amazon doesn't show a few product fields after solving a captcha (specifically: 'attributes', 'manufacturer attributes', and 'bestseller ranks').",
                        "default": false
                    },
                    "scrapeProductVariantPrices": {
                        "title": "💵 Scrape product variant prices",
                        "type": "boolean",
                        "description": "Enable this option to extract prices of different variations of a product. Useful when you need prices for each variant. Note that this will increase the number of requests and extend the scraping time.",
                        "default": false
                    },
                    "scrapeProductDetails": {
                        "title": "📦 Scrape product details",
                        "type": "boolean",
                        "description": "If enabled, the scraper will extract each found product from the category page in detail (this is the default behavior). If disabled, the scraper will only extract the quick product information from the category page. Useful for faster and more lightweight searches for products.",
                        "default": true
                    },
                    "maxConcurrentRequests": {
                        "title": "⚡ Maximum concurrent requests",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of concurrent product page requests.",
                        "default": 10
                    },
                    "countryCode": {
                        "title": "🏳️ Country code",
                        "enum": [
                            "AF",
                            "AX",
                            "AL",
                            "DZ",
                            "AS",
                            "AD",
                            "AO",
                            "AI",
                            "AG",
                            "AR",
                            "AM",
                            "AW",
                            "AU",
                            "AT",
                            "AZ",
                            "BS",
                            "BH",
                            "BD",
                            "BB",
                            "BY",
                            "BE",
                            "BZ",
                            "BJ",
                            "BM",
                            "BT",
                            "BO",
                            "BQ",
                            "BA",
                            "BW",
                            "BV",
                            "BR",
                            "IO",
                            "BN",
                            "BG",
                            "BF",
                            "BI",
                            "KH",
                            "CM",
                            "CA",
                            "CV",
                            "KY",
                            "CF",
                            "TD",
                            "CL",
                            "CN",
                            "CX",
                            "CC",
                            "CO",
                            "KM",
                            "CD",
                            "CG",
                            "CK",
                            "CR",
                            "CI",
                            "HR",
                            "CW",
                            "CY",
                            "CZ",
                            "DK",
                            "DJ",
                            "DM",
                            "DO",
                            "EC",
                            "EG",
                            "SV",
                            "GQ",
                            "ER",
                            "EE",
                            "ET",
                            "FK",
                            "FO",
                            "FJ",
                            "FI",
                            "FR",
                            "GF",
                            "PF",
                            "TF",
                            "GA",
                            "GM",
                            "GE",
                            "DE",
                            "GH",
                            "GI",
                            "GR",
                            "GL",
                            "GD",
                            "GP",
                            "GT",
                            "GG",
                            "GW",
                            "GN",
                            "GY",
                            "HT",
                            "HM",
                            "VA",
                            "HN",
                            "HK",
                            "HU",
                            "IS",
                            "IN",
                            "ID",
                            "IQ",
                            "IE",
                            "IM",
                            "IL",
                            "IT",
                            "JM",
                            "JP",
                            "JE",
                            "JO",
                            "KZ",
                            "KE",
                            "KI",
                            "XK",
                            "KW",
                            "KG",
                            "LA",
                            "LV",
                            "LB",
                            "LS",
                            "LR",
                            "LY",
                            "LI",
                            "LT",
                            "LU",
                            "MO",
                            "MK",
                            "MG",
                            "MW",
                            "MY",
                            "MV",
                            "ML",
                            "MT",
                            "MH",
                            "MQ",
                            "MR",
                            "MU",
                            "YT",
                            "MX",
                            "FM",
                            "MD",
                            "MC",
                            "MN",
                            "ME",
                            "MS",
                            "MA",
                            "MZ",
                            "MM",
                            "NA",
                            "NR",
                            "NP",
                            "AN",
                            "NL",
                            "NC",
                            "NZ",
                            "NI",
                            "NE",
                            "NG",
                            "NU",
                            "NF",
                            "NO",
                            "OM",
                            "PK",
                            "PW",
                            "PS",
                            "PA",
                            "PG",
                            "PY",
                            "PE",
                            "PH",
                            "PN",
                            "PL",
                            "PT",
                            "QA",
                            "KR",
                            "RE",
                            "RO",
                            "RU",
                            "RW",
                            "BL",
                            "SH",
                            "KN",
                            "LC",
                            "MF",
                            "PM",
                            "VC",
                            "WS",
                            "SM",
                            "ST",
                            "SA",
                            "SN",
                            "RS",
                            "SC",
                            "SL",
                            "SG",
                            "SX",
                            "SK",
                            "SI",
                            "SB",
                            "SO",
                            "ZA",
                            "GS",
                            "ES",
                            "LK",
                            "SR",
                            "SJ",
                            "SZ",
                            "SE",
                            "CH",
                            "TW",
                            "TJ",
                            "TZ",
                            "TH",
                            "TL",
                            "TG",
                            "TK",
                            "TO",
                            "TT",
                            "TN",
                            "TR",
                            "TM",
                            "TC",
                            "TV",
                            "UG",
                            "UA",
                            "AE",
                            "GB",
                            "UM",
                            "US",
                            "UY",
                            "UZ",
                            "VU",
                            "VE",
                            "VN",
                            "VG",
                            "WF",
                            "EH",
                            "YE",
                            "ZM",
                            "ZW"
                        ],
                        "type": "string",
                        "description": "The country code to use as the delivery location."
                    },
                    "zipCode": {
                        "title": "📮 Zip code",
                        "type": "string",
                        "description": "The zip code to use as the delivery location. This is useful for more precise location settings, especially in larger countries."
                    },
                    "locationDeliverableRoutes": {
                        "title": "🛣️ Location deliverable routes",
                        "type": "array",
                        "description": "The list of routes/page types, for which the deliverable location settings should be applied. This is useful for speeding up the scraping process by not applying the location settings to all pages, for which you don't need the localized data for. For example, you can set it to ['SEARCH', 'PRODUCT'] to apply the location settings only to search and product pages. By default, all pages are included.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "PRODUCT",
                                "SEARCH",
                                "OFFERS"
                            ]
                        },
                        "default": [
                            "PRODUCT",
                            "SEARCH",
                            "OFFERS"
                        ]
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy configuration",
                        "type": "object",
                        "description": "🔒 Apify proxy settings. Use residential proxy for best results and fewer blocks."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
