# Amazon Reviews Scraper — No-Login Depth + AI Summary (`memo23/amazon-reviews-scraper`) Actor

Extract Amazon product reviews with the deepest no-login coverage available: reviews aggregated across 18 marketplaces, ratings histogram, and Amazon's 'Customers say' AI summary with aspect sentiment. Optional cookie mode unlocks full pagination (100s of reviews per product). JSON/CSV

- **URL**: https://apify.com/memo23/amazon-reviews-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 17 total users, 16 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 review scrapeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Reviews Scraper — Deep No-Login Reviews, Histogram & AI Summary 🛒⭐

Extract Amazon customer reviews for any product — **without login, at the deepest coverage still possible** — plus data no other reviews scraper structures: the full ratings histogram and Amazon's own AI-generated **"Customers say"** summary with per-aspect sentiment. Paste ASINs or product URLs, pick your marketplaces, export JSON/CSV/Excel.

![How it works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-amazon-reviews.png)

### Why use this Amazon Reviews Scraper? 💡

**An honest note first.** In late 2024 Amazon locked its review pages (`/product-reviews/…`) behind a login wall — page 1 included. Every reviews scraper on the market was affected: tools that used to return 100+ reviews per product silently dropped to the ~8–14 reviews embedded on the product page, while their descriptions kept promising "all reviews." This scraper is built for that new reality:

- 🌍 **Multi-marketplace harvesting** — the same product carries *different* locally-written reviews on amazon.com, .co.uk, .de, .ca, … This scraper fetches the product on **every marketplace you select** and merges the deduplicated reviews: typically **8–14 extra unique reviews per marketplace** the product is listed on, instead of the usual single-page 8–14 total.
- 🧠 **"Customers say" AI summary + aspect sentiment** — Amazon's own AI digest of all reviews ("Battery life: mixed, 5.4K mentions") as structured fields. It condenses *every* review ever written for the product — including the millions behind the login wall.
- 📊 **Ratings histogram + totals** — the 5→1 star percentage distribution and total ratings count per product.
- ⭐ **Filters that actually work** — star rating, Verified Purchase, keyword, and date range are applied honestly: rows that don't match are never returned and **never billed**.
- 🔐 **Optional cookie mode** — bring your own Amazon session cookie and unlock the paginated reviews route: up to ~100 reviews per star filter per product. Validated up-front; an expired cookie **fails loudly with instructions instead of silently returning nothing**.
- ⚡ **Pure HTTP** — no browser, fast and cheap, with automatic retry on fresh residential IPs when Amazon serves an interstitial.

### What does Amazon Reviews Scraper do? 🔍

For every ASIN or product URL you provide, the actor:

1. Fetches the product page on each selected marketplace (with an automatic fallback route when Amazon serves its lazy page variant that hides reviews).
2. Extracts every embedded review — rating, title, full text, ISO date + review country, author + profile link, Verified Purchase badge, helpful votes, variant attributes, full-resolution image URLs, and the review permalink.
3. Optionally deep-dives via your session cookie (star-by-star pagination, Amazon-side sorting and keyword search).
4. Deduplicates across marketplaces, applies your filters, sorts (most recent / most helpful), and pushes **one row per unique review** plus an optional **product-summary row** per product.

### Supported input 📥

| Input | Example |
|---|---|
| Bare ASIN | `B07PXGQC1Q` |
| Product URL | `https://www.amazon.com/dp/B07PXGQC1Q` |
| `/gp/product/` URL | `https://www.amazon.de/gp/product/B0D1XD1ZV3` |
| Reviews URL | `https://www.amazon.com/product-reviews/B07PXGQC1Q` |

Mixed freely, any of the 18 supported marketplaces: US, UK, Germany, France, Italy, Spain, Canada, Australia, Japan, India, Netherlands, Sweden, Poland, Belgium, UAE, Mexico, Turkey, Singapore.

### Use cases 🎯

- **Product & market research** — what buyers love and hate before you source or build a competing product.
- **Review sentiment analysis / LLM pipelines** — clean structured text + Amazon's own AI aspect summary as ground truth.
- **Brand & reputation monitoring** — track critical (1–2★) reviews on your own or competitor listings, filtered by date.
- **E-commerce copywriting** — mine review language for listing copy and ads.
- **Dropshipping / FBA product vetting** — histogram + "Customers say" per candidate ASIN in one run.

### Input configuration ⚙️

```json
{
    "products": ["B07PXGQC1Q", "https://www.amazon.de/dp/B0D1XD1ZV3"],
    "marketplaces": ["com", "co.uk", "ca", "de"],
    "aggregateMarketplaces": true,
    "maxReviewsPerProduct": 50,
    "filterByStars": [1, 2],
    "verifiedOnly": true,
    "sort": "recent",
    "includeProductSummary": true
}
````

Key options:

| Field | What it does |
|---|---|
| `marketplaces` + `aggregateMarketplaces` | The no-login depth multiplier — each marketplace adds its own local reviews. |
| `filterByStars` | e.g. `[1,2]` for critical only. In cookie mode this is also sent to Amazon so pagination digs directly into those ratings. |
| `dateFrom` / `dateTo` | ISO dates; applied to the parsed review date. |
| `includeVariantReviews` | `false` drops reviews attributed to a different variant ASIN (each row carries `reviewedAsin` + `variantAttributes` either way). |
| `amazonCookies` + `cookieMarketplace` | Optional deep pagination — see FAQ before using. |

### Output overview 📤

Two row types (`type` field):

- **`review`** — one per unique review.
- **`product-summary`** — one per product (disable with `includeProductSummary: false`).

### Output sample — review row

```json
{
    "type": "review",
    "reviewId": "R12KKP9H1D3C3I",
    "asin": "B07PXGQC1Q",
    "reviewedAsin": null,
    "marketplace": "com",
    "rating": 5,
    "title": "Great wireless earpods",
    "text": "Been using these for a while now, still my go-to for everyday listening. Pairing with my iPhone…",
    "date": "2026-07-02",
    "dateRaw": "Reviewed in the United States on July 2, 2026",
    "reviewCountry": "United States",
    "author": "Henry W",
    "authorProfileUrl": "https://www.amazon.com/gp/profile/amzn1.account.AHLEYE45VGG…",
    "verifiedPurchase": true,
    "helpfulVotes": 111,
    "variantAttributes": "Set: Without AppleCare+",
    "images": ["https://m.media-amazon.com/images/I/61UzPGU7rxL.jpg"],
    "reviewUrl": "https://www.amazon.com/gp/customer-reviews/R12KKP9H1D3C3I",
    "source": "product-page"
}
```

### Output sample — product-summary row

```json
{
    "type": "product-summary",
    "asin": "B07PXGQC1Q",
    "marketplace": "com",
    "productTitle": "Apple AirPods Wireless Ear Buds, Bluetooth Headphones…",
    "averageRating": 4.7,
    "totalRatings": 635952,
    "ratingsHistogram": { "5": 87, "4": 8, "3": 3, "2": 0, "1": 2 },
    "customersSay": "Customers find these wireless earbuds to be of good quality, with clear sound and great functionality. …",
    "aspects": [
        { "aspect": "Quality", "sentiment": "positive", "mentions": 9500 },
        { "aspect": "Battery life", "sentiment": "mixed", "mentions": 5400 }
    ],
    "url": "https://www.amazon.com/dp/B07PXGQC1Q"
}
```

### Key output fields 🗝️

| Field | Notes |
|---|---|
| `date` / `dateRaw` / `reviewCountry` | Localized date lines are parsed to ISO dates across EN/DE/FR/ES/IT/NL/JA; when parsing fails the raw string is always preserved and the row is kept. |
| `images` | Full-resolution URLs (Amazon's thumbnail size suffix stripped). |
| `helpfulVotes` | Integer, parsed from "One person/111 people found this helpful" incl. localized forms. |
| `reviewedAsin` + `variantAttributes` | Variant attribution, best-effort — Amazon mixes reviews across a product family. |
| `aspects[].sentiment` | `positive` / `mixed` / `negative` — same signal Amazon shows as green/orange chips. |

### FAQ ❓

**How many reviews will I get per product?**
Without cookies: roughly **8–14 per marketplace** the product is listed on — a run across 5–10 marketplaces typically yields **30–80+ unique reviews** per popular product, plus the histogram and AI summary. With cookie mode: up to ~100 per star filter per product (Amazon caps pagination at 10 pages per filter). Anyone promising "all reviews" without login is describing a capability Amazon removed in 2024.

**Why did every Amazon reviews scraper get worse in 2024/2025?**
Amazon put `/product-reviews/…` behind a sign-in wall — even page 1, even star filters. Public complaints on other scrapers ("only 8 reviews instead of 100", "star filter doesn't work") are that wall. This actor is designed around it rather than pretending it doesn't exist.

**How does cookie mode work, and is it safe?**
You export the `cookie` request-header value from a logged-in Amazon browser tab (DevTools → Network → any request → Request Headers) and paste it into `amazonCookies`. The cookie is validated before scraping starts — if it's expired or from the wrong marketplace the run **fails immediately with clear instructions and nothing is charged**. ⚠️ Automated access can lead Amazon to sign the session out or restrict the account: **use a throwaway account**, never one holding payment methods or order history you care about.

**Do the filters cost me anything?**
No. Filters run before billing — you're only charged for review rows actually pushed to the dataset. Empty runs charge nothing beyond the actor-start event.

**What about reviews in other languages?**
Reviews come back in each marketplace's language (that's the point of aggregation — they're *different* reviews). Dates are parsed to ISO across major locales; the raw localized strings are always preserved.

**A product returned no reviews at all — why?**
Either the ASIN isn't listed on the selected marketplaces (rows are skipped, not billed), or Amazon served its lazy page variant repeatedly. The actor auto-retries through a fallback route (`/gp/aw/d/`) on fresh residential IPs, which recovers almost all cases — if a specific ASIN consistently fails, open an issue with the ASIN and marketplace.

### Support 🤝

Found a bug or missing a feature? Open an issue on the [actor's Issues tab](https://apify.com/memo23/amazon-reviews-scraper/issues) — issues are answered, and the actor is actively maintained (that's the whole pitch).

### Additional services 🚀

Need review data at custom scale, a different output shape, webhook delivery, or a private variant of this actor? Reach out via the Issues tab or my Apify profile.

### Explore more scrapers 🕸️

More e-commerce and review scrapers on [my Apify profile](https://apify.com/memo23): Trustpilot, Capterra, Google Maps Reviews, Amazon Sellers, Etsy, eBay, and 250+ others.

### ⚠️ Disclaimer

This actor collects **publicly visible data only** and does not bypass authentication on your behalf: cookie mode uses a session **you** provide from **your own** Amazon account, at your own discretion and risk. Respect Amazon's Terms of Service and applicable laws (GDPR/CCPA) when storing reviewer names and profile links. This actor is not affiliated with, endorsed by, or sponsored by Amazon.com, Inc. "Amazon" is a trademark of Amazon.com, Inc.

### SEO Keywords

amazon reviews scraper, scrape amazon reviews, amazon review extractor, amazon product reviews api, amazon reviews dataset, extract amazon reviews to csv, amazon review sentiment analysis, amazon customers say scraper, amazon ratings histogram, amazon reviews without login, amazon review scraper 2026, bulk amazon reviews export, amazon asin reviews, amazon critical reviews scraper, amazon verified purchase reviews

# Actor input Schema

## `products` (type: `array`):

Amazon ASINs (e.g. "B07PXGQC1Q") or full product URLs (/dp/…, /gp/product/…), mixed freely. A URL pins its marketplace; bare ASINs use the Marketplaces field below.

## `marketplaces` (type: `array`):

Marketplaces to harvest. Each additional marketplace where the product is listed typically adds ~8–14 more unique, locally-written reviews per product (reviews are deduplicated). Bare ASINs are fetched on all of these; product URLs add their own marketplace automatically.

## `aggregateMarketplaces` (type: `boolean`):

Harvest every product on ALL selected marketplaces and merge the deduplicated reviews — the main no-login depth multiplier. Turn off to fetch each product on a single marketplace only.

## `maxReviewsPerProduct` (type: `integer`):

Ceiling of review rows per product (after dedup and filters). Without cookies, expect roughly 8–14 reviews per marketplace the product is listed on. With cookie mode, up to ~100 per star filter per product.

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

Hard ceiling of review rows across the whole run. Also capped by your plan and charge limit.

## `filterByStars` (type: `array`):

Keep only reviews with the selected star ratings — pick 1★ + 2★ for critical, 5★ for glowing. Leave empty for all ratings. Applied honestly: rows that don't match are never returned or charged. In cookie mode the filter is also sent to Amazon so pagination digs directly into those ratings.

## `verifiedOnly` (type: `boolean`):

Keep only reviews with the Verified Purchase badge.

## `filterByKeyword` (type: `string`):

Keep only reviews whose title or text contains this text (case-insensitive). In cookie mode it is also passed to Amazon's own review search.

## `dateFrom` (type: `string`):

Keep only reviews dated on/after this date. Reviews whose localized date can't be parsed are kept and carry the raw date string.

## `dateTo` (type: `string`):

Keep only reviews dated on/before this date.

## `sort` (type: `string`):

Order of the review rows: most recent first, or most helpful votes first. In cookie mode this also drives Amazon-side pagination order.

## `includeVariantReviews` (type: `boolean`):

Amazon mixes reviews from all variants (colors, sizes) of a product family. Keep on for maximum depth; turn OFF to drop reviews attributed to a different variant ASIN than the one you asked for (each row carries `reviewedAsin` and `variantAttributes` either way).

## `includeProductSummary` (type: `boolean`):

Emit one extra row per product with the average rating, total ratings count, 5→1 star histogram percentages, and Amazon's AI-generated 'Customers say' summary with per-aspect sentiment (data no other scraper structures). Charged as its own cheap event.

## `amazonCookies` (type: `string`):

OPTIONAL. Your own Amazon session cookie string (the full `cookie` request-header value from a logged-in browser tab). Unlocks the paginated reviews route: up to ~100 reviews per star filter per product instead of the no-login page depth. Validated up-front — an expired cookie fails the run immediately with clear instructions instead of silently returning nothing, and nothing is charged. ⚠️ Use a throwaway account you can afford to lose; automated access can lead Amazon to log the account out or restrict it. Never share a cookie from an account with payment methods you care about.

## `cookieMarketplace` (type: `string`):

Which Amazon site the cookie session belongs to (the one you logged into). Deep pagination runs on this marketplace.

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

How many pages to fetch in parallel. Automatically clamped to what the run's memory can safely hold (Amazon product pages are large, ~1.5–3MB each) — raise the run's memory to go faster. Default 8.

## Actor input object example

```json
{
  "products": [
    "B07PXGQC1Q"
  ],
  "marketplaces": [
    "com",
    "co.uk",
    "ca"
  ],
  "aggregateMarketplaces": true,
  "maxReviewsPerProduct": 50,
  "maxItems": 200,
  "filterByStars": [],
  "verifiedOnly": false,
  "sort": "recent",
  "includeVariantReviews": true,
  "includeProductSummary": true,
  "cookieMarketplace": "com",
  "concurrency": 8
}
```

# 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 = {
    "products": [
        "B07PXGQC1Q"
    ],
    "marketplaces": [
        "com",
        "co.uk",
        "ca"
    ],
    "maxReviewsPerProduct": 50,
    "maxItems": 200,
    "filterByKeyword": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/amazon-reviews-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 = {
    "products": ["B07PXGQC1Q"],
    "marketplaces": [
        "com",
        "co.uk",
        "ca",
    ],
    "maxReviewsPerProduct": 50,
    "maxItems": 200,
    "filterByKeyword": "",
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/amazon-reviews-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 '{
  "products": [
    "B07PXGQC1Q"
  ],
  "marketplaces": [
    "com",
    "co.uk",
    "ca"
  ],
  "maxReviewsPerProduct": 50,
  "maxItems": 200,
  "filterByKeyword": ""
}' |
apify call memo23/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Reviews Scraper — No-Login Depth + AI Summary",
        "description": "Extract Amazon product reviews with the deepest no-login coverage available: reviews aggregated across 18 marketplaces, ratings histogram, and Amazon's 'Customers say' AI summary with aspect sentiment. Optional cookie mode unlocks full pagination (100s of reviews per product). JSON/CSV",
        "version": "0.0",
        "x-build-id": "dSoaayIfXRA7wlqP9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~amazon-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-amazon-reviews-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/memo23~amazon-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-amazon-reviews-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/memo23~amazon-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-amazon-reviews-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": [
                    "products"
                ],
                "properties": {
                    "products": {
                        "title": "⭐ ASINs or product URLs",
                        "type": "array",
                        "description": "Amazon ASINs (e.g. \"B07PXGQC1Q\") or full product URLs (/dp/…, /gp/product/…), mixed freely. A URL pins its marketplace; bare ASINs use the Marketplaces field below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "marketplaces": {
                        "title": "🌍 Marketplaces",
                        "type": "array",
                        "description": "Marketplaces to harvest. Each additional marketplace where the product is listed typically adds ~8–14 more unique, locally-written reviews per product (reviews are deduplicated). Bare ASINs are fetched on all of these; product URLs add their own marketplace automatically.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "com",
                                "co.uk",
                                "de",
                                "fr",
                                "it",
                                "es",
                                "ca",
                                "com.au",
                                "co.jp",
                                "in",
                                "nl",
                                "se",
                                "pl",
                                "com.be",
                                "ae",
                                "com.mx",
                                "com.tr",
                                "sg"
                            ],
                            "enumTitles": [
                                "amazon.com (US)",
                                "amazon.co.uk (UK)",
                                "amazon.de (Germany)",
                                "amazon.fr (France)",
                                "amazon.it (Italy)",
                                "amazon.es (Spain)",
                                "amazon.ca (Canada)",
                                "amazon.com.au (Australia)",
                                "amazon.co.jp (Japan)",
                                "amazon.in (India)",
                                "amazon.nl (Netherlands)",
                                "amazon.se (Sweden)",
                                "amazon.pl (Poland)",
                                "amazon.com.be (Belgium)",
                                "amazon.ae (UAE)",
                                "amazon.com.mx (Mexico)",
                                "amazon.com.tr (Turkey)",
                                "amazon.sg (Singapore)"
                            ]
                        },
                        "default": [
                            "com"
                        ]
                    },
                    "aggregateMarketplaces": {
                        "title": "Aggregate reviews across marketplaces",
                        "type": "boolean",
                        "description": "Harvest every product on ALL selected marketplaces and merge the deduplicated reviews — the main no-login depth multiplier. Turn off to fetch each product on a single marketplace only.",
                        "default": true
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Ceiling of review rows per product (after dedup and filters). Without cookies, expect roughly 8–14 reviews per marketplace the product is listed on. With cookie mode, up to ~100 per star filter per product.",
                        "default": 100
                    },
                    "maxItems": {
                        "title": "Max reviews (whole run)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard ceiling of review rows across the whole run. Also capped by your plan and charge limit."
                    },
                    "filterByStars": {
                        "title": "⭐ Filter by star rating",
                        "type": "array",
                        "description": "Keep only reviews with the selected star ratings — pick 1★ + 2★ for critical, 5★ for glowing. Leave empty for all ratings. Applied honestly: rows that don't match are never returned or charged. In cookie mode the filter is also sent to Amazon so pagination digs directly into those ratings.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "★☆☆☆☆  1 star (critical)",
                                "★★☆☆☆  2 stars",
                                "★★★☆☆  3 stars",
                                "★★★★☆  4 stars",
                                "★★★★★  5 stars (glowing)"
                            ]
                        },
                        "default": []
                    },
                    "verifiedOnly": {
                        "title": "✅ Verified Purchase only",
                        "type": "boolean",
                        "description": "Keep only reviews with the Verified Purchase badge.",
                        "default": false
                    },
                    "filterByKeyword": {
                        "title": "🔍 Keyword filter",
                        "type": "string",
                        "description": "Keep only reviews whose title or text contains this text (case-insensitive). In cookie mode it is also passed to Amazon's own review search."
                    },
                    "dateFrom": {
                        "title": "📅 Date from",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Keep only reviews dated on/after this date. Reviews whose localized date can't be parsed are kept and carry the raw date string."
                    },
                    "dateTo": {
                        "title": "📅 Date to",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Keep only reviews dated on/before this date."
                    },
                    "sort": {
                        "title": "🔀 Sort output by",
                        "enum": [
                            "recent",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Order of the review rows: most recent first, or most helpful votes first. In cookie mode this also drives Amazon-side pagination order.",
                        "default": "recent"
                    },
                    "includeVariantReviews": {
                        "title": "Include variant reviews",
                        "type": "boolean",
                        "description": "Amazon mixes reviews from all variants (colors, sizes) of a product family. Keep on for maximum depth; turn OFF to drop reviews attributed to a different variant ASIN than the one you asked for (each row carries `reviewedAsin` and `variantAttributes` either way).",
                        "default": true
                    },
                    "includeProductSummary": {
                        "title": "📊 Product summary row",
                        "type": "boolean",
                        "description": "Emit one extra row per product with the average rating, total ratings count, 5→1 star histogram percentages, and Amazon's AI-generated 'Customers say' summary with per-aspect sentiment (data no other scraper structures). Charged as its own cheap event.",
                        "default": true
                    },
                    "amazonCookies": {
                        "title": "🔐 Amazon session cookie (optional — deep pagination)",
                        "type": "string",
                        "description": "OPTIONAL. Your own Amazon session cookie string (the full `cookie` request-header value from a logged-in browser tab). Unlocks the paginated reviews route: up to ~100 reviews per star filter per product instead of the no-login page depth. Validated up-front — an expired cookie fails the run immediately with clear instructions instead of silently returning nothing, and nothing is charged. ⚠️ Use a throwaway account you can afford to lose; automated access can lead Amazon to log the account out or restrict it. Never share a cookie from an account with payment methods you care about."
                    },
                    "cookieMarketplace": {
                        "title": "Cookie marketplace",
                        "enum": [
                            "com",
                            "co.uk",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "ca",
                            "com.au",
                            "co.jp",
                            "in",
                            "nl",
                            "se",
                            "pl",
                            "com.be",
                            "ae",
                            "com.mx",
                            "com.tr",
                            "sg"
                        ],
                        "type": "string",
                        "description": "Which Amazon site the cookie session belongs to (the one you logged into). Deep pagination runs on this marketplace.",
                        "default": "com"
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many pages to fetch in parallel. Automatically clamped to what the run's memory can safely hold (Amazon product pages are large, ~1.5–3MB each) — raise the run's memory to go faster. Default 8.",
                        "default": 8
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```