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

Scrape Amazon product reviews as clean JSON — review title, body, star rating, author, date, verified-purchase flag, helpful votes and variant, for any ASIN across 19 Amazon marketplaces, plus an AI 'customers say' summary of what buyers praise and complain about. No proxies, no CAPTCHAs, no login.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 — Extract Product Reviews & AI Summary as JSON

> 📮 **Need help, hit a problem, want a new feature, or a field that's missing from the output?** Email **support@reefapi.com** or open an issue on the **Issues** tab of this Actor — we reply fast and take feature requests seriously.

Scrape **Amazon product reviews** as clean, structured JSON. Pass an **ASIN** and get reviews with **title, body, star rating, author, date, verified-purchase flag, variant, helpful votes and images** — across **19 Amazon marketplaces** — plus an AI **"customers say"** summary of the aspects buyers praise and complain about. **No proxies, no CAPTCHAs, no login** — just send an ASIN and get the data.

### What is the Amazon Reviews Scraper?

The Amazon Reviews Scraper is an **Amazon reviews data API** that turns a product's review section into a structured dataset. Send an ASIN (and optionally a marketplace and sort order) and it returns the review list — each review's star rating, title, full body text, author, date, location, verified-purchase flag and the variant reviewed. On top of the raw reviews it returns Amazon's AI **"customers say"** insight: a plain-language summary of the themes buyers agree and disagree on (sound quality, fit, battery life, value). It's the tool you use to **scrape Amazon reviews** for sentiment analysis, product research and reputation monitoring — across all 19 marketplaces.

### What you get per review

- ⭐ **Star rating** (1–5) and **review title**.
- 📝 **Full review body text**.
- 👤 **Author** name (and profile id).
- 🗓️ **Date** and reviewer **location**.
- ✅ **Verified-purchase** flag.
- 🧩 **Variant** reviewed (`format` — e.g. size / color / style).
- 👍 **Helpful votes** (when present) and 🖼️ **review images** (when present).
- 🧠 **AI "customers say" summary** — top praised and criticized aspects across all reviews.

### What data can I extract?

Each review is one record. Key fields (from real output):

| Field | What it is |
|---|---|
| `review_id` | Stable id for the review |
| `author` | Reviewer's display name |
| `profile_id` | Reviewer's Amazon profile id |
| `rating` | Star rating (1–5) |
| `title` | Review headline |
| `body` | Full review text |
| `date` | Date the review was posted |
| `location` | Reviewer's country/marketplace |
| `verified` | Verified-purchase flag |
| `format` | Variant reviewed (style/size/color) |
| `helpful_count` | "X people found this helpful" (when present) |
| `images` | Image URLs attached to the review |
| `marketplace` | Which Amazon site the review is from |

The response also includes `review_insights` (the AI "customers say" summary), plus `total_review_count` and `average_rating` for the product.

> Field availability can vary — not every review has images, helpful votes or a variant, and Amazon can change its layout. Some products expose only a limited public review set. Core fields (rating, title, body, author, date, verified) are present for real reviews.

### How do I scrape Amazon reviews?

1. Open the Actor and go to the **Input** tab.
2. Enter an **ASIN** (the `…/dp/<ASIN>/` segment of a product URL) and pick a **Marketplace**.
3. Choose a **Sort** — Most recent or Most helpful.
4. Click **Start**, then download the reviews as **JSON, CSV or Excel** from the **Dataset** tab.

### Input

```json
{ "asin": "B09B8V1LZ3", "marketplace": "com", "sort": "recent" }
````

- `asin` — the Amazon product id (from a `/dp/<ASIN>/` URL).
- `marketplace` — `com`, `co.uk`, `de`, `fr`, `it`, `es`, `co.jp`, `in`, `ca`, `com.au`, `com.mx`, `com.br`, `com.tr`, `ae`, `nl`, `se`, `pl`, `sg`, `sa`.
- `sort` — `recent` or `helpful`.
- `params` — advanced JSON (star filter, verified-only, paging/cursor).

### Output

Real response (trimmed — one representative review + the AI summary):

```json
{
  "reviews": [
    {
      "review_id": "R149GR14HAGW5J",
      "author": "VOICECRACKCENTRAL",
      "profile_id": "amzn1.account.AGM7O4OPCBIBTVPHSRNJ4DDYQIMQ",
      "rating": 5.0,
      "title": "Absolutely amazing",
      "date": "June 7, 2026",
      "location": "the United States",
      "verified": true,
      "format": "Style: Pro Gen 2",
      "helpful_count": null,
      "body": "The sound quality is clear, the bass is nice, and the noise cancellation works better than I expected. They connect fast and feel comfortable…",
      "images": [],
      "marketplace": "com"
    }
  ],
  "review_insights": {
    "summary": "Customers praise the sound quality, noting they are loud and clear, and appreciate the noise cancellation. However, customers disagree on the fit, with some reporting they fall out. Battery life and connectivity are mixed…"
  },
  "total_review_count": 42718,
  "average_rating": 4.5
}
```

### Use cases

- **Sentiment analysis** — feed review text into NLP/AI for themes, complaints and praise.
- **Product research** — read what real buyers say (and the AI "customers say" summary) before sourcing.
- **Reputation & QA** — monitor ratings, verified-purchase share and recurring issues over time.
- **Review aggregation** — build cross-marketplace review datasets for a product or brand.
- **Competitor benchmarking** — compare review sentiment and rating distribution against rivals.

### FAQ

**Is there an official Amazon reviews API?**
No public API returns product review text. Amazon's official programs don't expose reviews for arbitrary ASINs, so scraping the public review pages is the practical way to get this data as JSON.

**Why scrape Amazon reviews?**
Reviews are the richest public signal of what buyers actually think. Pulled at scale, they power sentiment models, product-improvement research, QA monitoring and competitor benchmarking.

**How much does it cost?**
Billed on Apify's pay-per-result model, benchmarked to be competitive with other Amazon review scrapers. See the **Pricing** section on this Actor's page for the current rate.

**Can I integrate it?**
Yes — run it from the Apify **API** or the **Python / Node.js clients**, and connect the output to **Make, Zapier, n8n, Google Sheets, webhooks** or your database via Apify integrations.

**Is it legal to scrape Amazon reviews?**
This Actor reads publicly visible reviews (no login, no accounts). Reviews contain personal data (author names), so handle the output responsibly and per GDPR/CCPA — anonymize where appropriate. Not legal advice.

***

Unofficial — not affiliated with Amazon. Public data only.

# Actor input Schema

## `asin` (type: `string`):

The Amazon product id whose reviews you want. e.g. B09B8V1LZ3. (From a product URL: the …/dp/<ASIN>/ segment.)

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

Which Amazon site the product is on. One of: com, co.uk, de, fr, it, es, co.jp, in, ca, com.au, com.mx, com.br, com.tr, ae, nl, se, pl, sg, sa.

## `sort` (type: `string`):

Review ordering.

## `params` (type: `object`):

Any extra parameters as key/value JSON (star filter, verified-only, page/cursor, …). Merged into the request.

## `action` (type: `string`):

Fixed to product reviews.

## Actor input object example

```json
{
  "asin": "B09B8V1LZ3",
  "marketplace": "com",
  "sort": "recent",
  "action": "product/reviews"
}
```

# Actor output Schema

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

The Amazon product reviews scraped (one item per review).

# 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 = {
    "asin": "B09B8V1LZ3"
};

// Run the Actor and wait for it to finish
const run = await client.actor("reefapi/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 = { "asin": "B09B8V1LZ3" }

# Run the Actor and wait for it to finish
run = client.actor("reefapi/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 '{
  "asin": "B09B8V1LZ3"
}' |
apify call reefapi/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Reviews Scraper",
        "description": "Scrape Amazon product reviews as clean JSON — review title, body, star rating, author, date, verified-purchase flag, helpful votes and variant, for any ASIN across 19 Amazon marketplaces, plus an AI 'customers say' summary of what buyers praise and complain about. No proxies, no CAPTCHAs, no login.",
        "version": "0.1",
        "x-build-id": "gcnkYckKE2vDOEVg4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reefapi~amazon-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reefapi-amazon-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/reefapi~amazon-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reefapi-amazon-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/reefapi~amazon-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reefapi-amazon-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "asin": {
                        "title": "ASIN",
                        "type": "string",
                        "description": "The Amazon product id whose reviews you want. e.g. B09B8V1LZ3. (From a product URL: the …/dp/<ASIN>/ segment.)"
                    },
                    "marketplace": {
                        "title": "Marketplace",
                        "enum": [
                            "com",
                            "co.uk",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "co.jp",
                            "in",
                            "ca",
                            "com.au",
                            "com.mx",
                            "com.br",
                            "com.tr",
                            "ae",
                            "nl",
                            "se",
                            "pl",
                            "sg",
                            "sa"
                        ],
                        "type": "string",
                        "description": "Which Amazon site the product is on. One of: com, co.uk, de, fr, it, es, co.jp, in, ca, com.au, com.mx, com.br, com.tr, ae, nl, se, pl, sg, sa.",
                        "default": "com"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "recent",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Review ordering.",
                        "default": "recent"
                    },
                    "params": {
                        "title": "Advanced parameters",
                        "type": "object",
                        "description": "Any extra parameters as key/value JSON (star filter, verified-only, page/cursor, …). Merged into the request."
                    },
                    "action": {
                        "title": "Action (fixed)",
                        "type": "string",
                        "description": "Fixed to product reviews.",
                        "default": "product/reviews"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```