# Amazon Reviews Scraper — Review Text, Ratings & Verified Data (`george.the.developer/amazon-review-intelligence`) Actor

Amazon reviews scraper returning complete review records: body text, star rating, title, date, country, verified-purchase flag, helpful votes and variant. Validates every record and charges only for complete ones. Free per-product summary with the rating distribution.

- **URL**: https://apify.com/george.the.developer/amazon-review-intelligence.md
- **Developed by:** [George Kioko](https://apify.com/george.the.developer) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Amazon Reviews Scraper — Review Text, Ratings & Verified Data

Extract Amazon product reviews as clean, structured records: **the actual review body**, star
rating, title, date, country, verified-purchase status, helpful votes and the variant reviewed.
Works with ASINs, product URLs or a Best Sellers page, across ten Amazon marketplaces.

You are charged **only for complete reviews**. Anything that comes back partial is still
delivered to your dataset — flagged, with the reason attached — and costs you nothing.

### How it works

```
   ASINs · product URLs · Best-Sellers page
                    │
                    ▼
        real browser + Apify proxy      ← Amazon blocks plain HTTP requests
                    │
                    ▼
     parse Amazon's current review markup
                    │
                    ▼
   completeness gate: body + rating + id + date?
          │ yes                    │ no
          ▼                        ▼
   charged `review` row     delivered FREE with
      ($0.002 each)         `validationErrors`
                    │
                    ▼
     free `product-summary` row per product
   (rating histogram, coverage note, charges)
```

No cookies, no login, no Amazon account. Every row states whether it was billed and why.

### What data does it extract?

Two kinds of row, told apart by `recordType`.

**`review`** — one per review:

| Field | Example |
|---|---|
| `asin` | `B0DCH8VDXF` |
| `reviewId` | `R2RG0Q50IBXD57` |
| `rating` | `5` |
| `title` | `Solid pair of earphones for daily use` |
| `text` | `Very solid pair of headphones with Apple quality. The material is…` |
| `date` / `dateRaw` | `2026-07-29` / `Reviewed in the United States on July 29, 2026` |
| `country` | `United States` |
| `author` | `BalkShiba` |
| `verifiedPurchase` | `true` |
| `helpfulVotes` | `3` |
| `variant` | `Size: One Size Style: USB-C` |
| `complete` / `billable` | `true` / `true` |
| `validationErrors` | `[]` |

**`product-summary`** — one per product, always free: product title, `averageRating`,
`totalRatings`, `reviewsExtracted`, `reviewsComplete`, `reviewsCharged`,
`verifiedPurchaseShare`, `extractedRatingCounts` and a `coverageNote`.

### Use cases

1. **Product research & sourcing** — pull real review text for candidate products before you
   commit inventory; the free summary row shows the rating distribution at a glance.
2. **Review intelligence & sentiment analysis** — feed complete, validated review bodies into
   an LLM or sentiment model without cleaning accessibility teasers and empty shells first.
3. **Brand & listing monitoring** — schedule runs on your own ASINs and watch new reviews,
   ratings and verified-purchase share over time.
4. **Competitor analysis** — point a run at a Best Sellers or category page and get structured
   review data for every product on it in one pass.

### How to scrape Amazon reviews

1. Paste one or more ASINs or product URLs (any mix — the ASIN is parsed out of URLs for you),
   or a Best Sellers / category / search URL in `discoveryUrl`.
2. Optionally pick the marketplace (`domain`), cap the products (`maxProducts`) and set a hard
   cost ceiling (`maxCostUsd`).
3. Run it. Export the dataset as JSON, CSV or Excel, or read it via the API / MCP.

```json
{
  "asins": ["B0DCH8VDXF", "B0GJTFXNRX"],
  "domain": "amazon.com",
  "maxProducts": 20,
  "maxCostUsd": 5
}
```

```json
{
  "discoveryUrl": "https://www.amazon.com/Best-Sellers/zgbs/electronics",
  "maxProducts": 50
}
```

### Input parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `asins` | array | one of the three | ASINs or full product URLs; ASINs are extracted automatically |
| `productUrls` | array | one of the three | Product URLs (`/dp/`, `/gp/product/`, `/product-reviews/`) |
| `discoveryUrl` | string | one of the three | Best Sellers, category or search page; every product found is queued |
| `domain` | string | no | Marketplace: `amazon.com` (default), `.co.uk`, `.de`, `.fr`, `.es`, `.it`, `.ca`, `.com.au`, `.co.jp`, `.in` |
| `maxProducts` | integer | no | Cap on products processed (default 20, max 500) — the main cost driver |
| `maxCostUsd` | integer | no | Hard cap; if the estimate exceeds it the run stops immediately and free (default 5) |
| `proxyConfiguration` | object | no | Apify datacenter proxy by default — measured as reliable as residential here |
| `debug` | boolean | no | Verbose logging |

### Output example

```json
{
  "recordType": "review",
  "billable": true,
  "complete": true,
  "asin": "B0DCH8VDXF",
  "reviewId": "R2RG0Q50IBXD57",
  "rating": 5,
  "title": "Solid pair of earphones for daily use",
  "text": "Very solid pair of headphones with Apple quality. The material is premium and the fit is comfortable for long sessions…",
  "date": "2026-07-29",
  "country": "United States",
  "author": "BalkShiba",
  "verifiedPurchase": true,
  "helpfulVotes": 3,
  "variant": "Size: One Size Style: USB-C",
  "validationErrors": []
}
```

### How many reviews per product?

**Amazon publishes roughly 8–13 full review texts per product to logged-out clients.** That is
Amazon's limit, not this actor's, and it applies to every scraper on the market:

- `?filterByStar=` and `?sortBy=` are ignored on the product page — all six variants return the
  identical set (measured 2026-08-04)
- the `reviews-render` pagination endpoint returns `403`
- `/product-reviews/…?pageNumber=2` redirects to Amazon Sign-In

Every product-summary row states this explicitly, alongside the product's true total rating
count, so you always know what you have and what you don't. If a tool promises you "all
reviews" without an account, check what it actually delivers.

### Pricing

Pay per event — you pay for what you get, not for compute time:

| Event | Price |
|---|---|
| Actor start | $0.025 per GB of run memory (2 GB default = **$0.05 per run**) |
| Complete review | **$0.002** |

A review is complete when it has a body, a 1–5 star rating, a review id and a date. Records
missing any required field are delivered free with a `validationErrors` array naming the field,
the rule and the evidence.

One failure mode is worth calling out: Amazon renders an accessibility hint (`"Brief content
visible, double tap to read full content."`) next to every review body. Read the wrong node and
that string lands in your dataset instead of the review. This actor treats such a record as a
defect, not a review — never billed.

`maxCostUsd` caps the run before it starts; if the estimate exceeds it the run exits
immediately, uncharged beyond the start fee.

### FAQ

**How many reviews can I get per product?**
Roughly 8–13 full texts — Amazon's logged-out limit, stated honestly in every summary row. See
the section above.

**Do I pay for incomplete reviews, blocked pages or delisted products?**
No. All of those produce free rows that say exactly what happened. You pay the start fee and
$0.002 per complete review, nothing else.

**Which Amazon marketplaces are supported?**
Ten: US, UK, Germany, France, Spain, Italy, Canada, Australia, Japan and India, via the
`domain` input.

**Do I need Amazon cookies or an account?**
No. The actor reads what Amazon publishes to logged-out visitors, through a real browser and
Apify proxy.

**Can I use it from ChatGPT, Claude or another AI agent?**
Yes. Output is a flat, typed dataset with an output schema, so it drops straight into MCP tools
and agent pipelines without post-processing.

**Is scraping Amazon reviews legal?**
The actor collects only publicly available data. Reviews include author display names, which
can be personal data — make sure you have a lawful basis for how you use them (GDPR etc.).
This is not legal advice.

### Support

Found a bug, a marketplace that misbehaves, or a field you need that isn't here? Open an issue
on the actor's **Issues** tab — reports get fixed, not ignored. More tools:
[george.the.developer](https://apify.com/george.the.developer) on Apify.

# Actor input Schema

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

Amazon ASINs to collect reviews for, e.g. B0DCH8VDXF. You can paste full product URLs here too — the ASIN is extracted automatically.

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

Amazon product URLs (/dp/, /gp/product/ or /product-reviews/). Merged with the ASIN list above.

## `discoveryUrl` (type: `string`):

An Amazon Best Sellers, category or search page. Every product found on it is added to the queue, up to Max products. Example: https://www.amazon.com/Best-Sellers/zgbs/electronics

## `domain` (type: `string`):

Marketplace to read. Review availability and language follow the marketplace.

## `maxProducts` (type: `integer`):

Upper bound on products processed this run. Amazon publishes roughly 8-13 full review texts per product to logged-out clients, so this is also the main driver of run cost.

## `maxCostUsd` (type: `integer`):

Safety cap. If the estimated charge for this run exceeds it, the run stops immediately and costs you nothing.

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

Amazon blocks unproxied traffic. Apify datacenter proxy is the default and is measurably as reliable here as residential, at a fraction of the cost. Switch to residential only if you see blocks.

## `debug` (type: `boolean`):

Verbose logs for troubleshooting.

## Actor input object example

```json
{
  "asins": [
    "B0DCH8VDXF",
    "B0GJTFXNRX"
  ],
  "discoveryUrl": "https://www.amazon.com/Best-Sellers/zgbs/electronics",
  "domain": "amazon.com",
  "maxProducts": 20,
  "maxCostUsd": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debug": false
}
```

# Actor output Schema

## `reviews` (type: `string`):

One row per Amazon review with body text, rating, date, country, verified-purchase flag, helpful votes and per-record validation errors, plus one free product-summary row per product carrying the rating distribution and coverage note. recordType discriminates the row kind.

# 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": [
        "B0DCH8VDXF"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("george.the.developer/amazon-review-intelligence").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": ["B0DCH8VDXF"] }

# Run the Actor and wait for it to finish
run = client.actor("george.the.developer/amazon-review-intelligence").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": [
    "B0DCH8VDXF"
  ]
}' |
apify call george.the.developer/amazon-review-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,george.the.developer/amazon-review-intelligence"
        }
    }
}

```

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/MygWsoNWkoZ35cbmz/builds/iq6TwQcV3kfwpccoA/openapi.json