# Amazon Reviews Scraper (`s-r/amazon-reviews-scraper`) Actor

Scrape Amazon customer reviews by ASIN: star rating, title, full review text, author, date, verified-purchase badge and helpful votes, plus the product's overall rating and how many ratings it rests on. One row per review, across any Amazon marketplace.

- **URL**: https://apify.com/s-r/amazon-reviews-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 review returneds

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/actors/running/actors-in-store.md#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 Reviews Scraper: what buyers actually wrote, by ASIN

This amazon reviews scraper takes a list of ASINs and returns the customer
reviews as structured JSON: the star rating, the headline, the full review
text, who wrote it, when, whether Amazon confirmed they bought it, and how many
people found the review useful. One row per review.

Every row also carries the product's overall rating and the number of ratings
behind it, so a single row tells you both what one buyer said and how much that
opinion counts against the rest.

### What you get

- **The full review text** (`body`), not a truncated preview. Amazon hides part
  of a long review behind an expand control; the whole thing comes back.
- **The headline and the star rating** as separate fields (`title`, `rating`),
  so a one-star complaint and its subject line are both queryable.
- **Verified-purchase status** (`verified_purchase`) as a real boolean, which is
  the fastest filter for separating buyers from commenters.
- **Helpful votes** (`helpful_votes`) as a number, parsed out of Amazon's
  localised phrasing.
- **The reviewer's marketplace** (`reviewer_country`). Amazon mixes reviews
  written on other marketplaces into a product page, and that field is what
  tells you which ones.
- **The product's aggregate** on every row: `product_average_rating` and
  `product_total_ratings`.
- **Any Amazon marketplace**, by two-letter country code.

### Why scrape Amazon reviews

Reviews are the only place a product's real failure modes are written down. A
spec sheet says the battery is 5000 mAh; the reviews say it drops to half after
four months, and they say it in the buyer's own words with a date attached.
For anyone selling, sourcing, or competing against a product, that text is the
research.

The reason it needs scraping is that Amazon stopped serving its dedicated
reviews page to anyone without an account. A request for it now returns a
page-shaped response with no reviews in it, no error, and no sign that anything
was withheld, which is the worst possible failure for a pipeline: it looks like
the product has no reviews. This actor reads them where they are still served.

That does set the ceiling. What comes back is the set Amazon shows on the
product page, a mix of most-helpful and most-recent, typically eight to
thirteen per product. It is a representative sample with the aggregate attached,
not the complete review history.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `asins` | array of strings | yes | — | One ASIN per line, e.g. `B0BXLJ936Z`. |
| `country` | string | no | `de` | Marketplace country code: de, nl, us, uk, fr, it, es. |
| `maxReviewsPerProduct` | integer | no | `20` | Cap per product, 1 to 50. |

The ASIN is in every Amazon product URL, directly after `/dp/`. Pick the
marketplace the product is actually sold in: an ASIN that does not exist on
that marketplace is reported rather than returned empty.

### Output

One row per review.

```json
{
  "asin": "B0BXLJ936Z",
  "marketplace": "www.amazon.de",
  "product_average_rating": 4.5,
  "product_total_ratings": 771,

  "review_id": "R1N3PB2BWLOARX",
  "rating": 5.0,
  "title": "Sound-Revolution für das Wohnzimmer – Aber mit einem kleinen „Aber\"",
  "body": "Design & Erster Eindruck. Das Design des Era 300 ist eigenwillig ...",

  "author": "In recensione veritas",
  "date": "Bewertet in Deutschland am 29. April 2026",
  "reviewer_country": "Deutschland",
  "verified_purchase": true,
  "helpful_votes": 23
}
```

### Use cases

**Finding the real objections before you sell.** Pull the reviews for the
products you compete with and read the one- and two-star bodies. What buyers
complain about is the copy your own listing needs to answer, and it is written
in their vocabulary rather than yours.

**Sourcing and quality control.** Before committing to a supplier's product,
read what buyers of the equivalent listings say breaks. Filter on
`verified_purchase` to drop the noise, then sort by `helpful_votes` to find the
complaints other buyers recognised.

**Tracking sentiment after a change.** Run the same ASIN on a schedule and
watch `date` and `rating` move. A packaging change, a supplier switch or a
firmware update shows up in reviews within weeks, well before it shows up in
the aggregate, because the aggregate is diluted by every rating that came
before.

**Feeding a summarisation pipeline.** Each row is a complete review with its
rating, date and credibility signals attached. That is enough context for a
model to weigh a review rather than just read it, and the aggregate on every
row gives it the baseline to compare against.

### How it compares

| | This actor | Typical alternative |
|---|---|---|
| Review text | Full body, expand control's hidden text removed | Often truncated at the fold |
| Verified purchase | Boolean field | Sometimes absent |
| Helpful votes | Parsed to a number from localised text | Left as a raw string, or missing |
| Reviewer marketplace | Returned per review | Not distinguished |
| Product aggregate | On every row | Separate call, or absent |
| Depth | The product page's set, typically 8-13 | Claims of full pagination, which now needs an account |

Be sceptical of any Amazon review scraper advertising unlimited pagination
today. The paginated reviews page requires a signed-in session, so a tool
reaching it is either using someone's account credentials or quietly returning
the same product-page set this one does.

### Pricing

Priced per review returned. Products with no reviews are reported in the run
summary and cost nothing. All pricing is pay-per-event, so you only pay for
results you receive. There are no per-compute-unit charges.

### Limits and gotchas

- Roughly 8 to 13 reviews per product, not the full history. Amazon's paginated
  review pages require an account and are not used here.
- The selection is Amazon's, weighted to most-helpful and most-recent. Treat it
  as a sample, and use `product_total_ratings` for the population size.
- `date` is the line Amazon printed, in that marketplace's language and format,
  rather than a normalised timestamp. `reviewer_country` is extracted from it.
- `rating` and `helpful_votes` come from localised text ("4,5 von 5", "1.234
  Personen"). Where a value cannot be parsed cleanly it is left empty rather
  than guessed at.
- An ASIN absent from the chosen marketplace returns an error for that row, not
  an empty review list. Change `country` rather than retrying.
- Free Apify plans are capped at 10 rows per run. Split larger lists across runs
  or upgrade to remove the cap.

### FAQ

**Where do I find a product's ASIN?**
In the product URL, straight after `/dp/`. For
`amazon.de/dp/B0BXLJ936Z` the ASIN is `B0BXLJ936Z`.

**Can I get every review a product has?**
No, and be wary of anything claiming otherwise. Amazon's full review history is
behind a signed-in session. This returns the set shown on the product page,
with the aggregate so you know what fraction that is.

**Why is a review in a different language than the marketplace I asked for?**
Amazon shows reviews written on other marketplaces alongside local ones.
`reviewer_country` tells you which, so you can filter them out.

**Can I sort or filter by star rating?**
Not at fetch time; the actor returns what the product page shows. Filter the
dataset on `rating` afterwards.

**Does it work for any Amazon country?**
Yes, pass the two-letter code in `country`. The product must exist on that
marketplace.

### Related Actors

- [Amazon Offers](https://apify.com/s-r/amazon-offers) for every seller and
  price on a product.
- [Amazon Buybox](https://apify.com/s-r/amazon-buybox) for who currently holds
  the buy box.
- [Amazon Bestsellers](https://apify.com/s-r/amazon-bestsellers) for what is
  ranking in a category.

# Actor input Schema

## `asins` (type: `array`):

One Amazon product id per line, for example B0BXLJ936Z. Find it in any Amazon product URL after /dp/.

## `country` (type: `string`):

Two-letter country code of the Amazon marketplace, for example de, nl, us, uk, fr, it, es. Pick the one the product is actually sold in.

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

Cap on reviews per product, 1 to 50. Amazon shows roughly 8 to 13 on a product page, so this mostly trims rather than extends.

## Actor input object example

```json
{
  "asins": [
    "B08N5WRWNW"
  ],
  "country": "de",
  "maxReviewsPerProduct": 20
}
```

# Actor output Schema

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

One row per review.

## `output` (type: `string`):

OUTPUT record with the run's counts and status flags.

## `errors` (type: `string`):

Failures with a code and a redacted message. Absent when the run had none.

# 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 = {
    "asins": [
        "B0BXLJ936Z"
    ],
    "country": "de",
    "maxReviewsPerProduct": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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 = {
    "asins": ["B0BXLJ936Z"],
    "country": "de",
    "maxReviewsPerProduct": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/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 '{
  "asins": [
    "B0BXLJ936Z"
  ],
  "country": "de",
  "maxReviewsPerProduct": 20
}' |
apify call s-r/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/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/tKbat9D4SdDPiKbmE/builds/HYYpieqnq6i78LBYq/openapi.json