# Amazon Reviews Scraper & Extractor (Non-US) (`webdatalabs/amazon-reviews-scraper`) Actor

Extract public reviews from 20 non-US Amazon marketplaces: text, ratings, verified purchase, dates and helpful votes. Amazon.com (US) is temporarily unavailable. Returns product-page reviews, typically 8–16 per ASIN. JSON/CSV for sentiment analysis and automation. No login required.

- **URL**: https://apify.com/webdatalabs/amazon-reviews-scraper.md
- **Developed by:** [WebDataLabs](https://apify.com/webdatalabs) (community)
- **Categories:** E-commerce, Business, Developer tools
- **Features:** Limited permissions
- **Stats:** 484 total users, 16 monthly users, 81.7% runs succeeded, 4 bookmarks
- **User rating**: 1.19 out of 5 stars

## Pricing

from $1.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Amazon Reviews Scraper & Extractor (Non-US)

Extract Amazon customer reviews — full review text, star rating, Verified Purchase badge, author, date and variant — from **20 supported non-US Amazon marketplaces**. Clean, flat JSON/CSV for sentiment analysis, competitor research, and automation in n8n, Zapier, Make.com or your own LLM pipeline.

### Current availability

**Amazon.com (US) review scraping is temporarily unavailable.** Live anonymous tests, including Apify residential, datacenter and Unblocker proxies, did not reliably return US review content. This Actor uses public pages only; it does not sign in or call a paid data provider.

US URLs are reported as `unsupported-marketplace` before any proxy request. Chile (`amazon.cl`), Nigeria (`amazon.com.ng`) South Africa (`amazon.co.za`) and Egypt (`amazon.eg`) are also temporarily unavailable because they did not pass live verification. No `review-scraped` event is charged for a rejected URL; normal Actor-start charges can still apply.

A run containing only unavailable URLs fails immediately with a clear status message. In a mixed run, supported URLs are processed and every rejected URL remains visible in `OUTPUT`. URLs are never silently moved to another marketplace.

### What you get

One flat row per review. This example is from a live Germany run; the review body is shortened here for readability:

```json
{
  "productAsin": "B07BFVKFTK",
  "marketplace": "amazon.de",
  "reviewId": "R183O3NNUD212Q",
  "rating": 5,
  "title": "Top",
  "text": "Absolut überzeugend auf ganzer Linie – Eine klare Kaufempfehlung!​Erwartungen übertroffen: Der erste …",
  "verifiedPurchase": true,
  "reviewDate": "2026-08-05T00:00:00.000Z",
  "reviewCountry": "Germany",
  "helpfulVotes": 9,
  "variant": "Colour Name: WhiteSize Name: 140x200 cm"
}
```

Any field that could not be read from the page is `null`. It is never filled with a placeholder such as `"N/A"`, `"Unknown"`, `0` or today's date.

### How many reviews per product — read this first

**Amazon publishes roughly 8-16 reviews per product to logged-out visitors, and this Actor returns those.**

That is the whole set Amazon serves without a signed-in session: the reviews inlined on the product page, including its "top reviews from other countries" block. The dedicated `/product-reviews/` list now redirects to a sign-in page, so the complete review history is not reachable by any logged-out scraper — including this one.

`maxReviewsPerProduct` is therefore a **cap, not a promise**. Setting it to 1000 does not produce 1000 reviews; the run tells you in the log and in the `OUTPUT` record exactly how many Amazon exposed for each URL.

If you need the full review history of a product, this Actor is not the right tool and you should not buy it expecting that.

### Supported marketplaces

The following 20 marketplaces each returned reviews in live verification on October 28, 2026. Public review availability can still vary by product and session. The marketplace in the URL is preserved.

`amazon.co.uk` · `amazon.de` · `amazon.fr` · `amazon.it` · `amazon.es` · `amazon.nl` · `amazon.se` · `amazon.pl` · `amazon.com.be` · `amazon.ca` · `amazon.com.mx` · `amazon.com.br` · `amazon.in` · `amazon.co.jp` · `amazon.com.au` · `amazon.sg` · `amazon.ae` · `amazon.sa` · `amazon.com.tr` · `amazon.ie`

The default example is `https://www.amazon.de/dp/B07BFVKFTK`. Always submit a full product URL. Bare ASINs imply Amazon.com in older integrations and are now rejected under the US availability restriction.

### Input

```json
{
  "productUrls": [
    { "url": "https://www.amazon.de/dp/B07BFVKFTK" },
    { "url": "https://www.amazon.in/dp/B07PHQ1YP5" }
  ],
  "maxReviewsPerProduct": 20,
  "starRatings": ["1", "2", "3", "4", "5"],
  "verifiedOnly": false,
  "sortBy": "all",
  "includeReviewerNames": true
}
```

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `productUrls` | Array | one example URL | Amazon product URLs. The marketplace in each URL is respected. |
| `maxReviewsPerProduct` | Integer | `20` | Upper cap per product. Amazon exposes about 8-16, so a larger number does not return more. |
| `starRatings` | Array | `["1","2","3","4","5"]` | Keep only these star ratings, e.g. `["1","2"]` for negative reviews. |
| `verifiedOnly` | Boolean | `false` | Keep only reviews with Amazon's Verified Purchase badge. |
| `sortBy` | String | `"all"` | `recent`, `helpful`, or `all` (Amazon's own order). Applied after collection. |
| `includeReviewerNames` | Boolean | `true` | Include each reviewer's public display name as `authorName`. Turn off to leave names out of the results. |
| `proxyConfiguration` | Object | Apify Residential | Amazon serves a captcha wall to a large share of datacenter requests, so residential is the default. |

Because the filters are applied to the ~8-16 reviews Amazon publishes, a narrow filter (for example `verifiedOnly: true` combined with `starRatings: ["1"]`) can legitimately return very few rows or none. The run says so explicitly rather than returning a silent empty dataset.

### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `productAsin` | string | ASIN of the reviewed product |
| `marketplace` | string | Marketplace the review was collected from, e.g. `amazon.in` |
| `reviewId` | string | null | Amazon's own review id — stable across runs, usable as a dedupe key |
| `rating` | integer | null | Star rating 1-5 |
| `title` | string | null | Review headline |
| `text` | string | null | Full review body as plain text |
| `verifiedPurchase` | boolean | Verified Purchase badge present |
| `authorName` | string | null | Reviewer's public display name. Left out when `includeReviewerNames` is `false` |
| `reviewDate` | string | null | ISO 8601 date at UTC midnight |
| `reviewCountry` | string | null | Country the review was written in (differs from `marketplace` for cross-country reviews) |
| `helpfulVotes` | integer | Helpful-vote count. Amazon omits the line entirely at zero, so `0` means "no statement shown". |
| `variant` | string | null | Variant the reviewer bought |

#### Leaving out reviewer names

Reviewer names are included by default as `authorName`. A name is personal data, so if you don't need it, set `includeReviewerNames` to `false`: the Actor then neither reads nor stores names, and records have no `authorName` field at all - it is left out, not set to `null`. Everything else - the other fields, the row count and the price per review - is the same either way.

### Honest run reporting

Every run writes an `OUTPUT` record to its key-value store with one entry per submitted URL, so you always know what happened to each one:

| Status | Meaning |
|--------|---------|
| `ok` | Reviews were delivered |
| `no-reviews` | Amazon itself states this product has no customer reviews yet |
| `all-filtered-out` | Reviews existed, your filters removed all of them |
| `not-found` | That ASIN is not sold on that marketplace |
| `blocked` | Amazon served its anti-bot page on every attempt |
| `login-gated` | Amazon redirected to a sign-in page |
| `review-gated` | Amazon showed "Sign in to see customer reviews" instead of the reviews on every attempt |
| `invalid-url` | The URL contained no usable ASIN |
| `unsupported-marketplace` | That marketplace is temporarily unavailable; no proxy request was made |
| `charge-limit` | The run's maximum cost was reached before these reviews could be stored |

Rules this Actor follows:

- If **nothing** could be delivered because of a problem on our side, the run **fails loudly** instead of reporting success with an empty dataset.
- If nothing could be delivered because the products genuinely have no reviews or your filters removed them all, the run succeeds and says exactly that.
- No number printed in the log is ever larger than what actually landed in the dataset.

### Use cases

- **Sentiment analysis** — feed `text` + `rating` straight into an LLM or classifier
- **Competitor research** — track what buyers praise and complain about across rival ASINs
- **Product development** — mine recurring pain points and feature requests
- **Support monitoring** — filter `starRatings: ["1","2"]` and alert on new negatives
- **Cross-market comparison** — same product across supported marketplaces, such as `amazon.co.uk` and `amazon.de`

### Automation

Works as a normal Apify Actor in n8n, Zapier, Make.com and the Apify API. A typical monitoring setup:

1. Schedule the Actor daily with your ASIN list
2. Filter rows to `rating <= 2`
3. Deduplicate on `reviewId`
4. Post new negatives to Slack or a Notion database

### Pricing

Pay-per-event: you are charged per review that is actually stored in the dataset, plus the platform's standard Actor-start event. Reviews that are not delivered are not charged. Current per-event prices are shown in the Apify Console before you start a run.

If a run hits the "Maximum cost per run" you set, it stops storing and charging, and reports the shortfall explicitly rather than pretending it delivered everything.

### Limitations

1. **About 8-16 reviews per product.** Amazon login-gates the full list; see above. This is a hard ceiling, not a configuration issue.
2. Amazon occasionally serves an anti-bot page. The Actor rotates to a fresh residential IP and retries, then reports `blocked` if it still cannot get through.
3. On supported marketplaces, a **"Sign in to see customer reviews"** prompt triggers up to eight fresh sessions within the per-product time budget. Re-running does not guarantee access. Unavailable marketplaces are rejected before these retries.
4. Sorting is applied after collection, because Amazon does not let logged-out clients re-sort the product page.
5. A product not sold on the marketplace in the URL returns `not-found` — check you are using the right storefront domain.

### Legal & compliance

- Collects publicly accessible review data only — no login, no authentication bypass
- Reviewer names can be left out entirely by setting `includeReviewerNames` to `false`
- No customer account credentials or session cookies are used or requested

This Actor is a general-purpose tool for analyzing publicly accessible web data. The user bears sole responsibility for ensuring their specific use complies with applicable laws (GDPR/DSGVO, copyright law), the target website's Terms of Service, and Apify's Terms of Service. The provider (webdatalabs) expressly disclaims liability for any unauthorized or unlawful use. By using this Actor, the user agrees to indemnify the provider against any third-party claims arising from their use of the data.

***

### Explore more of our Actors

#### E-commerce

| Actor | Description |
|-------|-------------|
| [Shopify Scraper Pro](https://apify.com/webdatalabs/shopify-product-scraper) | Extract complete Shopify product data with variants and sales estimates |
| [Etsy Scraper Pro](https://apify.com/webdatalabs/etsy-scraper-pro) | Fast Etsy product scraper with ratings, reviews, and shop data |
| [TikTok Shop Scraper](https://apify.com/webdatalabs/tiktok-shop-scraper) | Extract TikTok Shop products with sales metrics and reviews |

#### Social media & community

| Actor | Description |
|-------|-------------|
| [Reddit Scraper Pro](https://apify.com/webdatalabs/reddit-scraper-pro) | Monitor subreddits and track keywords with sentiment analysis |
| [YouTube Shorts Scraper](https://apify.com/webdatalabs/youtube-shorts-scraper) | Scrape YouTube Shorts for viral content research |

#### Business intelligence

| Actor | Description |
|-------|-------------|
| [Shopify Store Intelligence](https://apify.com/webdatalabs/shopify-store-intelligence) | Analyze Shopify stores for competitive intelligence and market research |

***

### Need this data as a managed feed?

If you would rather receive this data on a schedule than run the Actor yourself, we can build and operate the feed: the fields you specify, the cadence you set, delivered to a dataset, S3, a webhook, or your database. Every scheduled run is checked against an agreed shape rather than assumed to be fine, missing values are reported as null instead of filled with placeholders, and repairing the collector when the source changes is covered by the monthly rate. Priced as a one-time setup fee plus a monthly rate, scoped in writing before anything is built.

**Contact:** support@webdatalabs.net

### Related actors

- [Google Play Reviews Scraper](https://apify.com/webdatalabs/google-play-reviews-scraper) — Play Store review text, ratings and app versions
- [Etsy Scraper Pro - Sale Prices & Discount Depth](https://apify.com/webdatalabs/etsy-scraper-pro) — sale prices, discount depth and ratings
- [Shopify Product Scraper](https://apify.com/webdatalabs/shopify-product-scraper) — products, variants and prices from any Shopify store
- [AliExpress Scraper — Products, Prices, Variants & Sales Signals](https://apify.com/webdatalabs/aliexpress-product-intelligence) — products, prices, variants and sales signals
- [Reddit Scraper Pro](https://apify.com/webdatalabs/reddit-scraper-pro) — posts and full comment threads

Explore the full portfolio from [WebDataLabs](https://apify.com/webdatalabs).

### Leave a review

Is this Actor saving you time? A quick review on the Store helps other people find it — and tells us which fields to add next. **[Rate this Actor →](https://apify.com/webdatalabs/amazon-reviews-scraper)**

***

*This tool is not affiliated with Amazon. All trademarks belong to their respective owners.*

# Actor input Schema

## `productUrls` (type: `array`):

Full product URLs from a supported non-US Amazon marketplace. Example: https://www.amazon.de/dp/B07BFVKFTK. Amazon.com (US), amazon.cl, amazon.com.ng, amazon.co.za and amazon.eg are temporarily unavailable. Their URLs are reported as unsupported-marketplace without proxy requests. The marketplace is never changed automatically.

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

Upper limit per product. This is a cap, not a promise: Amazon shows only its top reviews to logged-out visitors (typically 8-16 per product, including top reviews from other countries) and requires a signed-in session for the full history. Setting a larger number does not return more reviews - the run will tell you how many Amazon actually exposed.

## `starRatings` (type: `array`):

Keep only reviews with these star ratings. Applied to the reviews Amazon shows on the product page, so narrow filters often return few or no rows.

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

Keep only reviews carrying Amazon's Verified Purchase badge.

## `sortBy` (type: `string`):

Sort order of the returned reviews. Amazon does not let logged-out clients re-sort the product page, so this orders the reviews after they are collected.

## `includeReviewerNames` (type: `boolean`):

Includes each reviewer's public display name as authorName. On by default. Turn it off to leave names out of the results - names are personal data, so skip them if you don't need them.

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

Amazon serves a captcha wall to roughly a quarter of datacenter requests. Residential proxies are the default and are strongly recommended.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://www.amazon.de/dp/B07BFVKFTK"
    }
  ],
  "maxReviewsPerProduct": 20,
  "starRatings": [
    "1",
    "2",
    "3",
    "4",
    "5"
  ],
  "verifiedOnly": false,
  "sortBy": "all",
  "includeReviewerNames": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "productUrls": [
        {
            "url": "https://www.amazon.de/dp/B07BFVKFTK"
        }
    ],
    "maxReviewsPerProduct": 20,
    "includeReviewerNames": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdatalabs/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 = {
    "productUrls": [{ "url": "https://www.amazon.de/dp/B07BFVKFTK" }],
    "maxReviewsPerProduct": 20,
    "includeReviewerNames": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("webdatalabs/amazon-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "productUrls": [
    {
      "url": "https://www.amazon.de/dp/B07BFVKFTK"
    }
  ],
  "maxReviewsPerProduct": 20,
  "includeReviewerNames": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call webdatalabs/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,webdatalabs/amazon-reviews-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/s48J8dqrpf5cDJWSe/builds/c7Ky19DD2F353cXhK/openapi.json