# Amazon Reviews Scraper | $3/1K | Real-Time, No Login (`apivault_labs/amazon-reviews-scraper`) Actor

Scrape Amazon product reviews in real-time — rating, title, text, reviewer, verified purchase, helpful count. Works with ASINs or URLs.

- **URL**: https://apify.com/apivault\_labs/amazon-reviews-scraper.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 19 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 review extracteds

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 | $3/1K | Real-Time, No Login

> ### ⚡ Use this Actor in n8n — no code
>
> Building no-code workflows in **[n8n](https://n8n.io)**? Install our official community node and drop this Actor straight onto your canvas:
>
> **📦 [`n8n-nodes-apivault-amazon-reviews`](https://www.npmjs.com/package/n8n-nodes-apivault-amazon-reviews)**
>
> **Setup (30 seconds):** in n8n go to **Settings → Community Nodes → Install**, paste `n8n-nodes-apivault-amazon-reviews` and confirm → add the new node to your workflow → paste your **Apify API token** → fill in the input and run.

![Amazon Reviews Scraper — real-time reviews, ratings, verified-buyer & sentiment](https://api.apify.com/v2/key-value-stores/E76hLVOROveornuAY/records/amazon-reviews-hero.jpg)

Scrape Amazon product reviews in real-time. Give it an ASIN (or full product URL) and get reviews with rating, title, text, reviewer, verified-purchase flag, helpful count, country, and product variant. Works across **all 12 Amazon marketplaces**.

### ✨ Key Features

- 🔄 Real-time scraping — always fresh reviews
- 📝 Accepts ASINs (`B09B8V1LZ3`), product URLs, or review URLs
- 🌍 Works on Amazon US, UK, DE, FR, IT, ES, CA, AU, JP, IN, MX, BR
- ⭐ Full rating, title, body, and verified-purchase flag
- 🔢 Helpful count, review date, reviewer country, product variant
- 🎯 Filter by star rating (1-5 stars, critical, positive)
- ↕️ Sort by **most recent** or **most helpful**
- 🧲 Auto-deduplication across pages and sort orders
- 🔒 No login, no cookies, no Amazon API key

### Input

#### Simple — just an ASIN

```json
{
  "asins": ["B09B8V1LZ3"]
}
```

#### Multiple products across marketplaces

```json
{
  "asins": [
    "B09B8V1LZ3",
    "https://www.amazon.co.uk/dp/B08L5WHFHY",
    "https://www.amazon.de/product-reviews/B07PGL2ZSL"
  ],
  "maxPages": 5,
  "sortBy": "recent"
}
```

#### Only critical (1-2 star) reviews

```json
{
  "asins": ["B09B8V1LZ3"],
  "maxPages": 5,
  "filterByStar": "critical"
}
```

#### Input Parameters

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `asins` | string\[] | ✅ | ASINs or Amazon URLs. Mix freely. |
| `domain` | string | ❌ | Default marketplace when only ASIN is provided (default: `amazon.com`) |
| `maxPages` | int | ❌ | Pages per product, 1-10 (default: 3). Amazon caps at ~10 pages for anonymous access. |
| `sortBy` | string | ❌ | `recent` or `helpful` (default: `recent`) |
| `filterByStar` | string | ❌ | `all_stars`, `five_star` ... `one_star`, `critical`, `positive` (default: `all_stars`) |
| `extractReviewer` | bool | ❌ | Reviewer name (default: true) |
| `extractRating` | bool | ❌ | 1-5 star rating (default: true) |
| `extractTitle` | bool | ❌ | Review title (default: true) |
| `extractDate` | bool | ❌ | Review date (default: true) |
| `extractText` | bool | ❌ | Review body (default: true) |
| `extractVerified` | bool | ❌ | Verified Purchase flag (default: true) |
| `extractHelpfulCount` | bool | ❌ | Helpful votes (default: true) |
| `extractCountry` | bool | ❌ | Country / source marketplace (default: true) |
| `extractVariant` | bool | ❌ | Product variant (color/size) bought (default: true) |
| `extractAsinField` | bool | ❌ | Include ASIN + domain on each row (default: true) |
| `maxConcurrency` | int | ❌ | Parallel page scrapes (default: 2) |
| `timeout` | int | ❌ | Timeout per page in seconds (default: 180) |

### Output

One dataset row per review:

```json
{
  "success": true,
  "productUrl": "https://www.amazon.com/dp/B09B8V1LZ3",
  "asin": "B09B8V1LZ3",
  "domain": "amazon.com",
  "reviewerName": "John K.",
  "rating": 5,
  "title": "Best smart speaker I've owned",
  "date": "Reviewed in the United States on March 15, 2026",
  "text": "The sound quality is surprisingly good for the size. Setup took 5 minutes...",
  "verifiedPurchase": "Verified Purchase",
  "helpfulCount": "23",
  "country": "United States",
  "productVariant": "Color: Charcoal, Size: Dot (5th Gen)"
}
```

### Use Cases

- Product research for e-commerce / dropshipping
- Competitive analysis — mine a competitor's reviews
- Voice-of-customer: feed reviews into sentiment analysis
- Build AI training datasets
- Identify product defects / recurring complaints
- Track review velocity after a launch
- Amazon FBA / arbitrage research

### Pricing

- **$0.003 per review** ($3 per 1,000 reviews)
- Pay only for unique reviews actually extracted
- Duplicates across pages are deduplicated and charged once

### How it works

The actor extracts the ASIN from each input, and for page 1 scrapes the public **product page** (`/dp/ASIN`) which reliably shows ~8-10 top reviews. For deeper pages it tries the dedicated `/product-reviews/` endpoint, which Amazon now often gates behind login for anonymous traffic.

Typical coverage per product:

- Page 1 alone → ~8-10 reviews (stable)
- Adding pages 2-5 → **best effort**, may add 10-20 more or may return 0

To maximize coverage, run the actor **twice** with different inputs:

- First run: `sortBy: recent` + `filterByStar: critical` (1-2 star reviews)
- Second run: `sortBy: recent` + `filterByStar: positive` (4-5 star reviews)

### Notes

- Amazon gates deeper review pagination behind login for anonymous users (this is an Amazon-side change, not an actor limitation)
- Page 1 results are always reliable and fresh
- The reviewer name is whatever Amazon shows publicly (often initials)
- Verified Purchase flag is only set for Amazon-verified orders
- No Amazon account or Product Advertising API key needed

### Tips

- **Competitor research:** pull 10 pages sorted by `recent` + 10 pages sorted by `helpful` → full picture
- **Defect hunting:** `filterByStar: one_star` + `sortBy: recent` to see the freshest complaints
- **Launch tracking:** `sortBy: recent` on a new product every day, compare row counts
- Combine with our **Amazon Product Scraper** to enrich the product side (title, price, rating count, images)

# Actor input Schema

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

List of 10-character ASINs (e.g. B09B8V1LZ3), product URLs (https://www.amazon.com/dp/B09B8V1LZ3) or review URLs (https://www.amazon.com/product-reviews/B09B8V1LZ3). You can mix them freely.

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

Which Amazon marketplace to scrape (ignored if full URL provided)

## `maxPages` (type: `integer`):

How many review pages to scrape per product. Page 1 reliably returns ~8-10 reviews from the product page. Pages 2+ are attempted via the dedicated reviews page but may return 0 (Amazon now requires login for deeper pagination).

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

Which order to request

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

Only fetch reviews with specific star rating

## `extractReviewer` (type: `boolean`):

Extract reviewer display name

## `extractRating` (type: `boolean`):

Extract 1-5 star rating

## `extractTitle` (type: `boolean`):

Extract review headline

## `extractDate` (type: `boolean`):

Extract review date

## `extractText` (type: `boolean`):

Extract full review body text

## `extractVerified` (type: `boolean`):

Whether Amazon marked this as a verified purchase

## `extractHelpfulCount` (type: `boolean`):

How many users found the review helpful

## `extractCountry` (type: `boolean`):

Which Amazon store the review came from (for global reviews)

## `extractVariant` (type: `boolean`):

Which color / size / style the reviewer bought

## `extractAsinField` (type: `boolean`):

Include ASIN on every review row

## `maxConcurrency` (type: `integer`):

Parallel page scrapes (recommended: 2-3)

## `timeout` (type: `integer`):

Max wait per Amazon page

## Actor input object example

```json
{
  "asins": [
    "B09B8V1LZ3"
  ],
  "domain": "amazon.com",
  "maxPages": 1,
  "sortBy": "recent",
  "filterByStar": "all_stars",
  "extractReviewer": true,
  "extractRating": true,
  "extractTitle": true,
  "extractDate": true,
  "extractText": true,
  "extractVerified": true,
  "extractHelpfulCount": true,
  "extractCountry": true,
  "extractVariant": true,
  "extractAsinField": true,
  "maxConcurrency": 2,
  "timeout": 120
}
```

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/KXlDi1LT7eCGlCmRs/builds/Q45yeu5LiAzIIAzN7/openapi.json