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

Scrape the top customer reviews from an Amazon product page by ASIN or URL — rating, title, body, verified-purchase flag, date, and helpful-vote count per review. Pay-Per-Event, no login, no API key.

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

## Pricing

from $2.50 / 1,000 results

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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## Amazon Reviews Scraper

**💰 $2.50 / 1 000 results**  ·  pay only for results  ·  no credit card to try

*We do the dirty work so your dataset stays clean.* 😈

Scrape the top customer reviews Amazon shows right on a product's own page — by ASIN or product URL — rating, title, body, verified-purchase flag, date, and helpful-vote count per review. Pay-Per-Event, no login, no API key.

</div>

***

### 🎯 What this scrapes

Amazon doesn't publish a public reviews API, and its dedicated all-reviews listing page requires a signed-in session — so this Actor targets the real, keyless surface every visitor sees without logging in: the "Top reviews" widget embedded right on a product's own page (`amazon.com/dp/<ASIN>`). This Actor takes a list of ASINs or product URLs and returns one clean row per top review — reviewer name, star rating, title, body, verified-purchase flag, date, and helpful-vote count — up to the cap you set.

**Honest scope**: a product page typically embeds 6-10 top reviews, not Amazon's full review history. If you need the full corpus you'd have to be logged in to Amazon yourself — this Actor doesn't pretend otherwise. What it gives you is real, structured, no-login top-review data across as many ASINs as you throw at it in one run.

### 🔥 Features

- 🛡️ **We rotate browser fingerprints** — `curl-cffi` impersonation (Chrome / Firefox / Safari) so Amazon sees a real browser's TLS handshake, not Python.
- 🔁 **We retry with exponential backoff** on `408 / 429 / 5xx` and honour `Retry-After` — up to 5 attempts per page.
- 🌐 **We rotate proxy sessions** through Apify Proxy on every block — a fresh session and fingerprint the moment one gets flagged.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated, ISO-8601 dates, `verified_purchase` and `helpful_vote_count` always resolve to `true`/`false` and a number, never `null`.
- 🔗 **Dedupe built in** — any duplicate review block is collapsed to a single dataset row.
- 💰 **You pay only for results that land.** No reviews, no per-review charge — only the small `actor-start` warm-up fee.

### 💡 Use cases

- **Product research** — pull each competitor ASIN's top reviews before a launch or a pricing decision.
- **Voice-of-customer analysis** — feed top-review text and ratings into your own sentiment or topic-modeling pipeline.
- **Review monitoring** — re-run against the same ASINs on a schedule to track how the surfaced top reviews shift.
- **Catalog QA** — spot-check verified-purchase ratios and helpful-vote signals across a product line's top reviews.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page.
2. Add one or more **ASINs** and/or **Product URLs** — at least one of the two is required.
3. Set **Max reviews per product** (a ceiling — most ASINs surface 6-10 top reviews) and leave **Marketplace domain** at `amazon.com` (the only supported marketplace in v1).
4. Click **Start**. Output streams into the run's dataset.
5. Export from **Storage → Dataset** as JSON, CSV, or Excel — or fetch via the API.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `asins` | `array` | no\* | `[]` | 10-character Amazon ASINs, e.g. `B0BSHF7WHW`. |
| `productUrls` | `array` | no\* | `[]` | Amazon product URLs (`/dp/...`, `/gp/product/...`, `/product-reviews/...`) — the ASIN is extracted automatically; reviews are always fetched from the product's own page. |
| `maxReviewsPerProduct` | `integer` | no | `10` | Cap on review rows emitted per ASIN (1-20) — a ceiling, not a guarantee. |
| `marketplaceDomain` | `string` | no | `"amazon.com"` | Single-value enum; v1 is US-only. |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": true}` | Standard Apify Proxy block — escalate to `RESIDENTIAL` if you ever see a block. |

\* At least one of `asins` / `productUrls` must be non-empty.

#### Example input

```json
{
  "asins": ["B0BSHF7WHW"],
  "productUrls": [],
  "maxReviewsPerProduct": 10,
  "marketplaceDomain": "amazon.com",
  "proxyConfiguration": {"useApifyProxy": true}
}
```

### 📤 Output

Every row is one review.

| Field | Type | Notes |
|---|---|---|
| `asin` | `string` | 10-character Amazon ASIN. |
| `product_url` | `string \| null` | Canonical `amazon.com/dp/<asin>` URL. |
| `product_title` | `string \| null` | Product title, when present on the fetched review page. |
| `review_id` | `string \| null` | Amazon's internal review ID, when exposed. |
| `reviewer_name` | `string \| null` | Display name of the reviewer. |
| `rating` | `number` | Star rating, 1-5. |
| `review_title` | `string \| null` | Review headline. |
| `review_text` | `string` | Review body. |
| `verified_purchase` | `boolean` | `true`/`false`, never `null`. |
| `review_date` | `string` | ISO-8601 date. |
| `helpful_vote_count` | `integer` | Defaults to `0` when the source shows none — never `null`. |
| `marketplace_domain` | `string` | Echoes the input, e.g. `"amazon.com"`. |
| `scraped_at` | `string` | ISO 8601 UTC timestamp when the row was fetched. |

#### Example output

```json
{
  "asin": "B0BSHF7WHW",
  "product_url": "https://www.amazon.com/dp/B0BSHF7WHW",
  "product_title": "Example Wireless Noise-Cancelling Headphones",
  "review_id": "R2X9EXAMPLE123",
  "reviewer_name": "J. Rivera",
  "rating": 4.0,
  "review_title": "Great sound, so-so battery",
  "review_text": "Comfortable fit and clear mids. Battery drains faster than advertised after a few months.",
  "verified_purchase": true,
  "review_date": "2026-06-14",
  "helpful_vote_count": 12,
  "marketplace_domain": "amazon.com",
  "scraped_at": "2026-07-30T00:00:00Z"
}
```

### 💰 Pricing

Pay-Per-Event — you pay only when these events fire:

| Event | USD | What it is |
|---|---:|---|
| `actor-start` | $0.01 | One-off warm-up charge per run |
| `review-scraped` | $0.0025 | Per review row written to the dataset — **$2.50 / 1 000 results** |

No subscription, no minimum, no card required to start — Apify gives every new account $5 of free credit.

### 🚧 Limitations

This Actor returns the **top reviews Amazon embeds on the product page itself** — typically 6-10 per ASIN — not Amazon's full, paginated review history (that listing requires a signed-in Amazon session, which this Actor deliberately does not use). `maxReviewsPerProduct` is a ceiling, not a guarantee, and a run can legitimately return fewer rows than requested when a product's page embeds fewer. v1 covers `amazon.com` only (no other country marketplaces), product reviews only (no seller/marketplace-offer reviews), and excludes review images/video, product-detail fields beyond title/URL, rating-histogram summaries, and any login-gated or Amazon Vine-exclusive content.

### ❓ FAQ

**Do I need an Amazon account or API key?**

No. This Actor reads the same public product page a signed-out visitor sees — no login, no key.

**Can I pass a product URL instead of an ASIN?**

Yes — `productUrls` accepts standard Amazon product links (`/dp/...`, `/gp/product/...`, `/product-reviews/...`); the ASIN is extracted automatically and its reviews are fetched from the product's own page.

**Does this return every review a product has, or just some?**

Just the top reviews Amazon surfaces on the product page — typically 6-10 per ASIN. Amazon's full paginated review archive sits behind a signed-in session; this Actor stays keyless by design rather than faking a login.

**What happens if a product has fewer reviews than my `maxReviewsPerProduct`?**

The run still succeeds — the status message reports the actual count scraped per ASIN rather than treating an under-fill as a failure.

**Which countries does this cover?**

`amazon.com` (United States) only in v1. Other Amazon marketplaces are a future addition, not yet supported.

### 💬 Your feedback

Spotted a bug, hit a weird edge case, or need a new field? Open an issue on the Actor's **Issues** tab on Apify Console — we ship fixes weekly and we read every report.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

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

Amazon ASINs to scrape top reviews for (10-character alphanumeric code, e.g. B0BSHF7WHW). One of ASINs / Product URLs is required.

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

Amazon product page URLs (amazon.com/dp/..., /gp/product/..., or /product-reviews/...) — the ASIN is extracted automatically and reviews are always fetched from the product's own page. One of ASINs / Product URLs is required.

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

Cap on review rows emitted per ASIN. A ceiling, not a guarantee — the product page typically embeds only its top 6-10 reviews.

## `marketplaceDomain` (type: `string`):

Amazon marketplace host. v1 is US-only.

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

Apify Proxy routes every request. Defaults to the RESIDENTIAL group — Amazon soft-blocks datacenter IPs. Overridden by the WEBSHARE\_PROXY\_URL environment variable when set.

## Actor input object example

```json
{
  "asins": [
    "B0BSHF7WHW"
  ],
  "productUrls": [],
  "maxReviewsPerProduct": 10,
  "marketplaceDomain": "amazon.com",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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": [
        "B0BSHF7WHW"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/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": ["B0BSHF7WHW"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/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 '{
  "asins": [
    "B0BSHF7WHW"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call devilscrapes/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/8gL0zbaIxPyMLYVrq/builds/i11Ffas164SUac5Ws/openapi.json