# ⭐ Amazon Reviews Scraper: Verified & Star · $3.42/1k (`themineworks/amazon-reviews`) Actor

Scrape Amazon customer reviews by ASIN: star rating, title, body, verified purchase, helpful votes and review images. 8 marketplaces. Use as MCP tool in Claude & AI agents.

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

## Pricing

from $3.42 / 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/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: Ratings, Text & Verified Badge

> **The Mine Works:** 544 users across 100 public Actors, >99% run success. Pay only for results delivered. [Browse all Actors](https://apify.com/themineworks).

### Overview

Amazon Reviews Scraper turns any ASIN into clean, structured customer-review JSON: star rating, review title and body, verified-purchase badge, helpful votes, review images, author name, product variant, and date. No Amazon seller account, no SP-API, no login. Works across 8 Amazon marketplaces.

**How many reviews you get per ASIN.** Amazon publishes roughly 5 to 13 reviews on a public product page and no longer serves a public paginated review URL, so that is the ceiling. Setting max reviews to 100 does not get you 100, and it does not cost you anything either: billing is strictly per review delivered.

Yield still varies run to run, because Amazon does not always send a complete page. Three things can come back instead of the product page: a short bot-wall bounce, a page cut off above the reviews section, and, for some products, a reviews section with nothing in it. The actor tells those apart and reports them separately in the run summary. None of them is charged.

Amazon's official Selling Partner API only exposes reviews for products in your own approved catalog, and it requires seller registration, developer approval, and role authorization to get there. You cannot read a competitor's reviews through it at all. This scraper reads the same public product-review pages any shopper sees. Point it at any ASIN and get the reviews.

Reliability posture: blocked, empty, or failed runs are never charged. You only pay for a review record that was actually delivered.

✅ No login | ✅ No SP-API approval | ✅ Pay only per review returned | ✅ MCP-ready for AI agents

### Features

Any public ASIN. Read reviews for your own products or any competitor listing.
8 marketplaces supported. US, UK, DE, FR, JP, IN, CA, AU.
Sort and star filters. Order by recent or helpful, filter to a single star band.
Verified-purchase flag. Every record carries a boolean so you can post-filter genuine buyers.
Rich review payload. Full body text, images, helpful votes, variant purchased, and author profile.
International reviews included and labelled. Amazon's "reviews from other countries" block is returned too, tagged with `reviewSource` and `reviewCountry`, and can be switched off.

### How it works

For each ASIN, the actor fetches the public product page over plain HTTP and reads the reviews Amazon renders into it. No browser, no login.

Amazon does not always send the page. It has two ways of not sending it, and the actor treats them differently. A "Continue shopping" bot wall is retried on a fresh IP, up to five times. A page that arrives cut off above the reviews section is retried too, but only twice on the standard pool before the ASIN moves to a residential IP, because each of those cut pages is still half a megabyte or more to download. A product whose reviews section is present and empty is not retried at all: that is the product's real state, so the actor fetches it once, reports it, and moves on.

Sort order and the star filter are applied to the reviews on that page. Amazon serves one fixed set of top reviews per product, so these order and narrow what came back rather than requesting a different set.

You are billed per review returned, at $5.70 per 1,000 reviews. A blocked page, a missing ASIN, or a filter that matches nothing returns no rows and costs nothing.

### 🧾 Input configuration

```json
{
  "asins": ["B08N5KWB9H", "B0BDHX8Z63"],
  "marketplace": "amazon.com",
  "maxReviews": 13,
  "sortBy": "recent",
  "filterByStar": "all",
  "includeInternational": true,
  "residentialFallback": true,
  "proxyConfig": { "useApifyProxy": true }
}
```

### 📤 Output format

```json
{
  "reviewId": "R2STG6ZAMJNMK5",
  "asin": "B08N5KWB9H",
  "marketplace": "amazon.com",
  "rating": 4,
  "title": "Great product but took a week to ship",
  "body": "Love the build quality and the battery life exceeded expectations. Shipping was slow but the product itself is excellent. Would buy again.",
  "date": "2026-01-15",
  "dateLocalized": "Reviewed in the United States on January 15, 2026",
  "authorName": "J. Smith",
  "authorUrl": "https://www.amazon.com/gp/profile/amzn1.account.XXXX",
  "verifiedPurchase": true,
  "helpfulVotes": 12,
  "images": ["https://images-na.ssl-images-amazon.com/images/I/71xyz.jpg"],
  "variant": "Color: Black | Size: Large",
  "reviewCountry": "United States",
  "reviewSource": "local",
  "productUrl": "https://www.amazon.com/dp/B08N5KWB9H",
  "scraped_at": "2026-07-10T09:15:00.000Z"
}
```

Every review record contains these fields:

| Field | Description |
| --- | --- |
| 🆔 `reviewId` | Amazon review ID. |
| 🏷️ `asin` | Product ASIN. |
| 🌐 `marketplace` | Marketplace domain (e.g. `amazon.com`). |
| ⭐ `rating` | Star rating from 1 to 5. |
| 📝 `title` | Review headline. |
| 📄 `body` | Full review text. |
| 📅 `date` | Review date in ISO-8601 (best effort). |
| 🗓️ `dateLocalized` | Date exactly as shown on the page. |
| 👤 `authorName` | Reviewer display name. |
| 🔗 `authorUrl` | Link to the reviewer profile. |
| ✅ `verifiedPurchase` | True if the Verified Purchase badge is shown. |
| 👍 `helpfulVotes` | Number of helpful votes. |
| 🖼️ `images` | Review photo URLs (array). |
| 🎨 `variant` | Variant purchased (e.g. `Color: Black`). |
| 🌎 `reviewCountry` | Country the review was written in. |
| 🧭 `reviewSource` | `local` for this marketplace's own reviews, `international` for Amazon's "reviews from other countries" block. |
| 🌍 `productUrl` | Product page the review was read from. |
| 🕒 `scraped_at` | ISO-8601 timestamp when scraped. |

### 💼 Common use cases

**Reputation monitoring**
Schedule runs to track review volume, average rating, and sentiment for your own catalog. Catch rating drops early before they hit BSR.

**Sentiment analysis and NLP**
Feed the clean `body` text into classifiers, topic models, or LLMs to surface feature requests and pain points at scale.

**Competitor research**
Filter to one- and two-star reviews with the star filter to read the highest-signal complaints on rival ASINs. Ideal for product design and copy angles.

**Training datasets**
Pull star-labelled natural language for fine-tuning or evaluation without hand-scraping HTML. Every record ships with a clean rating column.

**AI review digests**
Pair with Claude via MCP to summarize what customers love and hate about any product. Live pulls, no stale export snapshots.

### 🚀 Getting started

1. Open Amazon Reviews Scraper in Apify Console, or call it via API or MCP.
2. Under ASINs, paste one or more product IDs (e.g. `B08N5KWB9H`).
3. Pick your Amazon marketplace (default `amazon.com`).
4. Set max reviews per ASIN, a sort order (recent or helpful), and an optional star-rating filter. Expect 5 to 13 reviews per ASIN whatever cap you set.
5. Click Save & Start, then download the dataset as JSON, CSV, or Excel, or pull via the Apify API.

### FAQ

**Do I need an Amazon account or the SP-API?**
No. The scraper reads public product-review pages, the same data any shopper sees. No seller account, no SP-API approval, no login.

**How many reviews can I scrape per ASIN?**
Roughly 5 to 13. That is what Amazon publishes on a public product page, and there is no longer a public paginated review URL behind it, so deeper history is not reachable without a logged-in session. The max reviews field caps the result but cannot raise that ceiling. Since billing is per review delivered, asking for more than Amazon has costs nothing extra.

**Why did this actor used to promise more?**
It scraped `/product-reviews/{ASIN}` and paginated. Amazon now redirects that URL to its sign-in page, which is why the actor returned zero rows until this rebuild. The product page is the remaining public source.

**Can I filter reviews by rating?**
Yes. The star-rating filter limits results to a single rating band (5-star through 1-star) or `all`. Every record also returns a `verifiedPurchase` flag so you can post-filter for verified reviews.

**Do I need residential proxies?**
The residential fallback is on by default and you should leave it on. Amazon walls the shared datacenter pool hard. In a verification run on 20 August 2026, three ASINs came back as a page Amazon had cut short before the reviews section, and all three returned full pages when retried on residential. The actor starts on the cheaper pool and moves an ASIN to residential when it is blocked or when Amazon returns a page it cut short before the reviews section. If you would rather stay on the cheap pool and accept the lower yield, turn the fallback off.

**How is it priced?**
Pay-per-result. You are charged per review returned, at $5.70 per 1,000 reviews. Rows that were never delivered are never charged, so blocked pages, missing ASINs, and empty filters cost nothing.

### Use in Claude, ChatGPT & any MCP agent

```
https://mcp.apify.com/?tools=themineworks/amazon-reviews
```

Or call it from code with the Apify client:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/amazon-reviews').call({
  asins: ['B08N5KWB9H'],
  marketplace: 'amazon.com',
  maxReviews: 13,
  sortBy: 'recent',
  filterByStar: 'all',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### 🛠️ Complete your Amazon research pipeline

Pair with the rest of the suite for a full Amazon intelligence stack:

- **[Amazon Products Scraper](https://apify.com/themineworks/amazon-products)**: price, BSR, rating, and variants by ASIN or keyword.
- **[YouTube Channel Scraper](https://apify.com/themineworks/youtube-channel)**: subscribers, video list, and channel stats, no API key.
- **[YouTube Transcript Scraper](https://apify.com/themineworks/youtube-transcript-scraper)**: timestamped captions as clean JSON for RAG and LLMs.

Found a bug or have a feature request? Open an issue on the actor's Apify Console page or reach out through the Apify profile.

### Related guides

- [Amazon Reviews Scraper: Collect Customer Ratings and Sentiment Without the SP-API](https://themineworks.com/blog/amazon-reviews-scraper-python)

*Last verified: 2026-08*

# Actor input Schema

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

Amazon ASINs or full product URLs. E.g. \["B08N5KWB9H"] or \["https://www.amazon.com/dp/B08N5KWB9H"].

## `marketplace` (type: `string`):

Amazon marketplace domain. Use that marketplace's own ASIN.

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

Upper limit on reviews returned per ASIN. Amazon publishes about 13 reviews per product page and no longer serves a public paginated review URL, so expect roughly 5 to 13 per ASIN whatever you set here. You are charged per review actually delivered, so a higher number costs nothing extra.

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

Order of the returned reviews. Amazon serves one fixed set of top reviews per product, so this sorts what the page returned rather than requesting a different set.

## `filterByStar` (type: `string`):

Keep only reviews with this star rating. Applied to the reviews on the product page, so a narrow filter can return very few rows or none. Filtered-out reviews are never charged.

## `includeInternational` (type: `boolean`):

Amazon shows a "reviews from other countries" block on most listings, typically 5 of the 13 reviews. Every row is tagged with reviewSource (local or international) and reviewCountry. Turn this off to get only the marketplace's own reviews.

## `residentialFallback` (type: `boolean`):

Retry on a residential IP when the standard proxy is blocked, or when Amazon returns a product page it cut short before the reviews section. In a verification run every cut page that was retried on residential came back complete. Leave this on unless you would rather keep the cheaper pool and accept the lower yield. Capped at 2 retries per ASIN.

## `proxyConfig` (type: `object`):

Apify Proxy is used by default. Amazon blocks the datacenter pool often, so leave the residential fallback on as well.

## Actor input object example

```json
{
  "asins": [
    "B08N5KWB9H"
  ],
  "marketplace": "amazon.com",
  "maxReviews": 13,
  "sortBy": "recent",
  "filterByStar": "all",
  "includeInternational": true,
  "residentialFallback": true,
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "asins": [
        "B08N5KWB9H"
    ],
    "maxReviews": 13
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/amazon-reviews").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": ["B08N5KWB9H"],
    "maxReviews": 13,
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/amazon-reviews").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": [
    "B08N5KWB9H"
  ],
  "maxReviews": 13
}' |
apify call themineworks/amazon-reviews --silent --output-dataset

```

## MCP server setup

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

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/zMrIjHh5P2NLrWKNL/builds/VYpIT87jnuZ5TDsyz/openapi.json