# Amazon Product Reviews Scraper API - ASIN & Ratings (`vonsensey/amazon-reviews-scraper-api`) Actor

Scrape Amazon product reviews by ASIN or URL as JSON or CSV: rating, title, text, date, verified purchase, helpful votes and images. Free star histogram per product. Checks 24 Amazon marketplaces, which each publish different reviews, and deduplicates. No start fee, failures are free.

- **URL**: https://apify.com/vonsensey/amazon-reviews-scraper-api.md
- **Developed by:** [Blackcube Agency AB](https://apify.com/vonsensey) (community)
- **Categories:** E-commerce, SEO tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 reviews

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

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

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

# README

## Amazon Product Reviews Scraper API — reviews and ratings by ASIN

**You are charged per review returned. There is no start fee, and a run that returns no reviews costs you nothing.**

Give it an ASIN or an Amazon URL and get back every review Amazon publishes for that product — rating, title, full text, date, verified-purchase badge, helpful votes, product variant and review images — as JSON, CSV or Excel. Every product also gets a free summary row with its average rating, total rating count and the **complete 1–5 star histogram**.

Unofficial tool. Not affiliated with, endorsed by, or connected to Amazon.com, Inc.

***

### Read this first: how many reviews you actually get

Most tools in this category quietly promise hundreds of reviews per product and return a handful. Here is the honest number.

Amazon publishes only a limited set of reviews on a product's public page — typically **8 to 13**. That is the ceiling for every public tool, including this one, and any listing claiming to return "all 2,000 reviews" for an ASIN is describing something that no longer exists.

What this Actor does about it: **Amazon publishes a different set of reviews on each of its marketplaces**, so it checks the marketplaces you select and merges the results, removing duplicates by review ID.

Measured on a 12-product, 8-marketplace benchmark run on 2026-08-17:

| Metric | Result |
|---|---|
| Unique reviews per product, mean | **22.2** |
| Median | 20 |
| Best product in the set | 37 |
| Worst product in the set | 8 |
| Pages blocked by Amazon | **0 of 96** |

The marketplaces really are additive, not repeats. Across every pair of marketplaces in that
run — 44 pairs over 11 products — the overlap was **zero shared reviews**. Adding a marketplace
that lists your product has never once returned a review another marketplace already gave us.

You control this directly. Leave **Marketplaces** on its default and you get one page per product. Add marketplaces and you add genuinely new reviews.

### What you get for every review

Measured field coverage on the same 244-review benchmark:

| Field | Coverage |
|---|---|
| `reviewId`, `rating`, `title`, `body` | 100% |
| `reviewedAt` (ISO date) + `reviewedAtRaw` | 100% |
| `reviewUrl`, `productUrl`, `asin`, `marketplace`, `countryCode` | 100% |
| `verifiedPurchase` | 98.0% |
| `helpfulVotes` | 53.7% |
| `variant` (colour / size / configuration reviewed) | 47.1% |
| `images` (full-resolution, not thumbnails) | 20.1% |
| `authorName`, `authorId`, `authorProfileUrl` | 100% — off by default, see GDPR below |
| `vineVoice` | present on every row, but **0 of 244** benchmark reviews were Vine — treat as unproven, not as "no Vine reviews exist" |

`reviewedAt` is a real ISO date on every marketplace, including the ones Amazon writes in German, Italian, Spanish, French and Portuguese. When a date genuinely cannot be read it is returned as `null` and the original text is kept in `reviewedAtRaw` — a guessed date would silently corrupt your date filter, so this Actor never guesses one.

### The star histogram — sentiment over every rating, not a sample of 8

Every product returns a free `product` row:

```json
{
  "rowType": "product",
  "asin": "B07PXGQC1Q",
  "marketplace": "amazon.com",
  "countryCode": "US",
  "averageRating": 4.7,
  "totalRatings": 635244,
  "ratingHistogram":       { "fiveStar": 87, "fourStar": 8, "threeStar": 3, "twoStar": 0, "oneStar": 2 },
  "estimatedRatingCounts": { "fiveStar": 552662, "fourStar": 50820, "threeStar": 19057, "twoStar": 0, "oneStar": 12705 },
  "positiveSharePct": 95,
  "negativeSharePct": 2,
  "histogramAverage": 4.78,
  "reviewsReturned": 8,
  "duplicatesSuppressed": 0
}
```

Amazon publishes the percentages and the grand total but never the count at each star level, so
`estimatedRatingCounts` works it out — percentage × total, normalised against the real percentage
sum, because Amazon's five buckets round and rarely add to exactly 100. They are labelled
`estimated` because they are: close, not exact. Every derived field is `null` rather than zero
when the underlying data is missing.

That histogram is the distribution across **all 635,244 ratings**, not across the 8 reviews you can read. For sentiment work it is strictly better input than a truncated sample of review text, and it is present on 89% of product rows with the average and total on 96%. No other Actor in this category returns it.

It is also per marketplace, so you can compare how the same product is received in the US, Germany and Japan — with the rating counts to weight it.

***

### How to scrape Amazon reviews by ASIN

Paste ASINs, one per line:

```json
{
  "products": ["B07PXGQC1Q", "B09B8V1LZ3", "B0CWXNS552"]
}
```

A bare ASIN defaults to `amazon.com`. That is the whole setup — no login, no cookies, no API key.

### How to scrape Amazon reviews from a product URL

Paste the URL straight from your browser. Any Amazon product URL works, including the long ones with a slug and tracking parameters:

```json
{
  "products": [
    "https://www.amazon.co.uk/dp/B08H93ZRK9",
    "https://www.amazon.com/Sceptre-E248W-19203R-Monitor-Speakers/dp/B0773ZY26F/ref=sr_1_3"
  ]
}
```

If your URL is a marketplace URL, that marketplace is used. A link you paste from `amazon.co.uk` is never silently scraped on `amazon.com`.

### How to get more reviews per product across Amazon marketplaces

Select the marketplaces you want. All 24 Amazon retail marketplaces are supported: `amazon.com`, `.co.uk`, `.de`, `.fr`, `.it`, `.es`, `.ca`, `.co.jp`, `.in`, `.com.au`, `.com.br`, `.com.mx`, `.nl`, `.se`, `.pl`, `.sa`, `.ae`, `.sg`, `.com.tr`, `.eg`, `.com.be`, `.ie`, `.cl`, `.co.za`.

```json
{
  "products": ["B07PXGQC1Q"],
  "marketplaces": ["amazon.com", "amazon.ca", "amazon.co.uk", "amazon.de", "amazon.com.au"]
}
```

Duplicates are removed automatically and **you are never charged twice for the same review**, no matter how many marketplaces return it. A product that is not sold in a marketplace gets a free `not-listed-in-marketplace` row instead of silently vanishing from your results.

### How to filter Amazon reviews by star rating, date or verified purchase

```json
{
  "products": ["B07PXGQC1Q"],
  "filterByStars": ["1", "2"],
  "onlyVerifiedPurchases": true,
  "reviewsNewerThan": "90 days"
}
```

`reviewsNewerThan` takes a date (`2026-01-15`) or a period (`30 days`, `6 months`, `1 year`).

**Every filter is free.** Reviews removed by a filter are never charged, so pulling only the 1-star reviews costs you only the 1-star reviews. If a filter removes everything for a product you get a row saying exactly that, rather than an empty result you have to guess about.

### How to monitor new Amazon reviews on a schedule

Turn on **Charge once per review, ever** and run the Actor on an Apify schedule:

```json
{
  "products": ["B07PXGQC1Q", "B09B8V1LZ3"],
  "onlyChargeNewReviews": true
}
```

Every run returns the full current review set so your data stays complete, but reviews you already paid for come back **free** and flagged `alreadyPaidForInPreviousRun: true`. Poll daily if you like — you pay once per review, ever, not once per run.

This is the setting that makes review monitoring affordable, and it is off by default so your first run behaves exactly as you expect.

### How to export Amazon reviews to CSV, JSON or Excel

Every run's dataset exports from the Apify UI or the API in JSON, CSV, Excel, XML or HTML. Two prepared views are included: **Reviews**, and **Product ratings and histograms**.

### How to call the Amazon Reviews Scraper API from Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("vonsensey/amazon-reviews-scraper-api").call(run_input={
    "products": ["B07PXGQC1Q"],
    "marketplaces": ["amazon.com", "amazon.ca"],
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["rowType"] == "review":
        print(row["rating"], row["reviewedAt"], row["title"])
```

Node.js:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('vonsensey/amazon-reviews-scraper-api').call({
    products: ['B07PXGQC1Q'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

***

### What it costs

You are charged **per review row returned**. Nothing else is billable.

- **No actor start fee.** Three of the actors in this category charge one; this one does not.
- **Failures are free.** A blocked page, a product that is not listed, a product with no reviews, an input that is not a valid ASIN — all return an explanatory row and cost nothing.
- **Product summary rows are free.** The histogram, average and rating totals never cost anything.
- **Filtered-out reviews are free.** You pay for what you keep.
- **Duplicates are free.** The same review found on five marketplaces is charged once.
- **With repeat-run billing on, previously-paid reviews are free forever.**

Set **Maximum reviews** for a hard cap on a run's bill. It is exact.

### Every input either returns reviews or tells you why not

There are no silent gaps. Any input that produces no reviews produces a `notice` row with a stable, machine-readable `reason` you can filter on:

| `reason` | Meaning |
|---|---|
| `not-listed-in-marketplace` | Amazon has no listing for this ASIN on that marketplace |
| `no-reviews-published` | The listing exists but Amazon publishes no reviews on it |
| `blocked-by-amazon` | Amazon served a wall on every attempt. Not charged |
| `reviews-section-missing` | The page loaded but its reviews section never rendered, so nothing can be concluded about this product's reviews. Retried first, then reported rather than guessed. Not charged |
| `invalid-input` | The value could not be read as an ASIN or Amazon URL |
| `fetch-failed` | Network or server error that survived every retry |
| `skipped-run-limit-reached` | The run hit your `maxReviews` cap before reaching this product |

Each run also writes a `RUN_REPORT` record with the counts — how many pages were fetched, how many had reviews, how many were blocked, how many reviews were charged.

### Personal data and GDPR

Reviewer name, profile ID and profile URL are personal data. They are **off by default** and are only returned if you explicitly enable **Include reviewer names and profile links**. Everything else — rating, text, dates, badges, votes, images — is returned either way. Only enable it if you have a lawful basis for processing it.

This Actor collects only data Amazon publishes publicly to anyone with a browser. It does not log in, does not use anyone's account, and does not touch anything behind a sign-in wall.

### Proxy

A proxy is required and enabled by default — Amazon serves a CAPTCHA to unproxied cloud IP addresses. The default configuration works; you do not need to buy a residential proxy add-on.

### Limitations, stated plainly

- **8–13 reviews per product per marketplace** is Amazon's public ceiling. This Actor cannot exceed it and neither can anything else that scrapes public pages.
- **An ASIN is not global.** The same product usually has a different ASIN in each marketplace, so requesting many marketplaces for one ASIN will produce `not-listed-in-marketplace` rows for the ones where that exact ASIN is not sold. Those are free.
- **Review sort order is Amazon's**, and Amazon no longer honours sort or star parameters on the public product page. Star, date and verified filters are therefore applied after fetching — which is also why they are free.
- **Reviewer names** are returned only with personal data enabled.
- Amazon changes its pages. If something breaks, open an issue — issues are answered.

### Support

Open an issue on the Actor's Issues tab. Bugs that produce wrong or missing data are treated as the priority.

***

*Unofficial tool. Not affiliated with, endorsed by, or connected to Amazon.com, Inc. "Amazon" is a trademark of Amazon.com, Inc., used here only to describe what this tool reads. This Actor collects publicly available data only.*

# Actor input Schema

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

One per line. Accepts a bare ASIN (B07PXGQC1Q) or any Amazon product URL pasted from your browser. If you paste a marketplace URL such as amazon.co.uk, that marketplace is used — your link is never silently redirected to amazon.com.

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

Amazon publishes a DIFFERENT set of reviews on each marketplace, so adding marketplaces adds genuinely new reviews rather than repeats. Measured on a test ASIN: 8 reviews on amazon.com alone, 36 unique across five marketplaces. Leave as 'Same marketplace as the product' to fetch only one page per product. Duplicates are removed automatically and you are never charged twice for the same review.

## `maxReviews` (type: `integer`):

Hard cap on billable reviews for the entire run. 0 means no cap. Amazon publishes roughly 8 reviews per product per marketplace, so a run is naturally small: 20 products on one marketplace is about 160 reviews.

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

Leave empty for all ratings. Amazon no longer honours star filters on the public product page, so this is applied to the reviews after we fetch them — which means you are only ever charged for the reviews you actually keep.

## `onlyVerifiedPurchases` (type: `boolean`):

Return only reviews carrying Amazon's Verified Purchase badge.

## `reviewsNewerThan` (type: `string`):

A date (2026-01-15) or a relative period (30 days, 6 months, 1 year). Left empty, all dates are returned. Reviews whose date could not be read in the marketplace's language are excluded when you set this, rather than being guessed at.

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

Adds one free row per product per marketplace with the average rating, the total number of ratings, and the full 1-5 star histogram. The histogram covers EVERY rating on the listing, not just the reviews returned, which is what makes sentiment work on products with hundreds of thousands of ratings. Always free.

## `onlyChargeNewReviews` (type: `boolean`):

For repeat runs on the same products. Reviews you were already charged for in an earlier run are still returned in full, but free, and marked alreadyPaidForInPreviousRun. Turn this on for a daily or weekly monitoring schedule so you are not re-billed for the same reviews every run. Off by default so a first run behaves exactly as you expect.

## `includePersonalData` (type: `boolean`):

Reviewer name, profile ID and profile URL are personal data under GDPR and similar laws. Off by default. Only turn this on if you have a lawful basis for processing it.

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

Required. Amazon serves a CAPTCHA to unproxied cloud IP addresses, so a run without a proxy returns no reviews. The default works and no residential proxy is needed.

## Actor input object example

```json
{
  "products": [
    "B07PXGQC1Q"
  ],
  "marketplaces": [
    "auto"
  ],
  "maxReviews": 200,
  "filterByStars": [],
  "onlyVerifiedPurchases": false,
  "reviewsNewerThan": "",
  "includeProductSummary": true,
  "onlyChargeNewReviews": false,
  "includePersonalData": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `csv` (type: `string`):

No description

## `runReport` (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 = {
    "products": [
        "B07PXGQC1Q"
    ],
    "marketplaces": [
        "auto"
    ],
    "maxReviews": 200,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("vonsensey/amazon-reviews-scraper-api").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": ["auto"],
    "maxReviews": 200,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("vonsensey/amazon-reviews-scraper-api").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 '{
  "products": [
    "B07PXGQC1Q"
  ],
  "marketplaces": [
    "auto"
  ],
  "maxReviews": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call vonsensey/amazon-reviews-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

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/JLiWdduSI9SJccxI9/builds/h4M6YKj5Cody9WIX1/openapi.json