# Amazon Reviews Scraper — Ratings & Sentiment (`khadinakbar/amazon-reviews-scraper`) Actor

Extract Amazon product reviews with star rating, review text, verified-purchase status, helpful votes, reviewer info, images and variant. Works with Apify MCP and the API.

- **URL**: https://apify.com/khadinakbar/amazon-reviews-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Marketing, MCP servers
- **Features:** Limited permissions
- **Stats:** 36 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 review scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Amazon Reviews Scraper is an Apify Actor for extracting Amazon product reviews from a product URL or ASIN. Each dataset item represents one review and includes the ASIN, product title, product URL, review ID, reviewer name and profile URL, star rating, review title, review body, verified purchase status, helpful votes, images, variant, country, top-review flag, and scrape timestamp. The Actor is usable through Apify MCP and through the Apify API, and it returns one record per review for analysis, monitoring, enrichment, and AI workflows.

### Important: what amazon.com shows right now

This Actor reads the public **amazon.com** product page for each ASIN you give it (a link from another Amazon country is converted to its amazon.com ASIN page). Since October 2026 amazon.com shows only a limited set of reviews to visitors who are not signed in, so you may get fewer reviews than you ask for, or none. If a run finds no reviews it ends as **Failed** with a clear message and you are not charged for any review, only the small start fee. Other Amazon country sites are not supported yet.

### Best fit and connected workflows

This Actor fits workflows where the review text on an Amazon product page is the source record.

Use it when you want to:

- collect the top customer reviews shown on an Amazon product page,
- combine verified purchase status with star ratings and review text,
- analyze review body text for sentiment, themes, or product feedback,
- start from Amazon product discovery and move into review-level analysis,
- connect product lookup or price tracking with downstream review monitoring.

Related workflows that connect naturally:

- Use Amazon Product Search Scraper when you first need to discover Amazon records, then pass a verified public product URL or ID into this Actor for review extraction.
- Use Amazon Search Scraper when search results are the entry point and you want to continue into review data collection.
- Use Amazon Competitor Price Tracker when you begin with the parent Amazon product record and then collect related engagement data here.

### Practical scenario

Maya is a product manager reviewing a new headset listing. She already has the Amazon product URL and sends it to this Actor with a review count limit. The dataset returns the ASIN, product title, review title, review body, rating, verified purchase flag, helpful votes, review date, country, variant, images, and source URL. Maya uses the review body and helpful votes to spot repeated feedback, then checks the verified purchase status and review date to decide which comments go into her weekly product report.

### Input fields

| Field | Type | Description |
|---|---|---|
| `productUrls` | array | One or more Amazon product page URLs. `/dp/ASIN` and `/gp/product/ASIN` forms are accepted. The ASIN is extracted from the URL. |
| `asins` | array | One or more 10-character Amazon product IDs when you already have the ASINs. |
| `maxReviews` | integer | Maximum reviews to collect per product. The schema range is 1 to 10. |
| `reviewsCutoffDate` | string | Date cutoff in `YYYY-MM-DD` format. Reviews older than this date are filtered after scraping. |
| `proxyConfiguration` | object | Proxy settings. The default uses Apify Residential proxies. |

#### Input example

```json
{
  "productUrls": [
    {
      "url": "https://www.amazon.com/dp/B0CWXNS552"
    }
  ],
  "maxReviews": 10,
  "reviewsCutoffDate": "2024-01-01",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

### Output fields

| Field | Type | Description |
|---|---|---|
| `asin` | string | Amazon Standard Identification Number. |
| `product_title` | string | null | Product title shown on the Amazon page. |
| `product_url` | string | Direct Amazon product URL. |
| `review_id` | string | Amazon review identifier used for deduplication. |
| `reviewer_name` | string | null | Reviewer display name. |
| `reviewer_profile_url` | string | null | Reviewer public profile URL. |
| `is_verified_purchase` | boolean | Verified purchase status. |
| `rating` | number | null | Star rating from 1.0 to 5.0. |
| `review_title` | string | null | Review headline. |
| `review_body` | string | null | Full review text. |
| `review_date` | string | null | Raw Amazon date string. |
| `review_date_iso` | string | null | ISO 8601 parsed date for filtering and sorting. |
| `helpful_votes` | number | Helpful vote count. |
| `images` | array | Image URLs attached to the review. |
| `variant` | string | null | Product variant reviewed, such as color or size. |
| `country` | string | null | Country extracted from the review date string. |
| `is_top_review` | boolean | Amazon top-review flag. |
| `scraped_at` | string | ISO 8601 scrape timestamp. |
| `source_url` | string | Amazon product page URL used as the source. |

#### Output example

```json
{
  "asin": "B0CWXNS552",
  "product_title": "Apple AirTag (1st Generation)",
  "product_url": "https://www.amazon.com/dp/B0CWXNS552",
  "review_id": "R2STPNKIY4BPVY",
  "reviewer_name": "John D.",
  "reviewer_profile_url": "https://www.amazon.com/gp/profile/amzn1.account.XXXX",
  "is_verified_purchase": true,
  "rating": 4,
  "review_title": "Great product, fast shipping",
  "review_body": "I've had this for 3 months. Setup was instant and tracking is accurate...",
  "review_date": "Reviewed in the United States on January 5, 2024",
  "review_date_iso": "2024-01-05T00:00:00.000Z",
  "helpful_votes": 42,
  "images": [
    "https://m.media-amazon.com/images/I/XXX._SL1500_.jpg"
  ],
  "variant": "Color: Black | Size: 256GB",
  "country": "the United States",
  "is_top_review": false,
  "scraped_at": "2026-04-09T14:30:00.000Z",
  "source_url": "https://www.amazon.com/dp/B0CWXNS552"
}
```

### How it works

The Actor accepts Amazon product URLs or ASINs and resolves them to product-page review scraping. The input schema supports collecting up to 10 inline reviews per product, which matches the top customer reviews shown on the product page. Reviews can be filtered after scraping by `reviewsCutoffDate`. The default proxy configuration uses Apify Residential proxies, which are selected in the input schema. The dataset view surfaces rating, verification status, dates, helpful votes, images, and product links for review workflows.

### Pricing

#### Startup billing and empty runs

The `apify-actor-start` event costs **$0.00005 per startup unit**. Apify charges one startup unit per GB of allocated memory, with a minimum of one unit, so a 2 GB run incurs two units. This startup charge still applies when input is invalid, no results are found, or an upstream request fails. Statements about free, unbilled, or skipped results refer only to the corresponding result event; they do not waive the startup charge. Apify platform usage is charged separately according to the run resources and your plan. Check the live [Pricing tab](https://apify.com/khadinakbar/amazon-reviews-scraper/pricing) for current events, tiers, and rates. Result limits cap result events, not the entire run cost.

This Actor uses Pay per event pricing. The primary charged event is `Review scraped`, and each event is charged once for each Amazon product review successfully extracted and saved to the dataset. Apify platform usage is charged separately, so your total run cost includes both event charges and platform usage.

For the current pricing details, open the live Pricing tab on the Actor page.

Price: **$0.004 per saved review**, plus a start fee of $0.00005 per GB of memory (about $0.0002 at the default 4 GB). Example costs in events only, start fee included:

| Reviews saved | Review events | Start fee | Total in events |
|---|---|---|---|
| 10 | $0.04 | $0.0002 | $0.0402 |
| 100 | $0.40 | $0.0002 | $0.4002 |
| 1,000 | $4.00 | $0.0002 | $4.0002 |

Each product page shows at most about 10 reviews, so 100 reviews means roughly 10 products and 1,000 reviews roughly 100 products. A run that saves no reviews costs only the start fee. Apify platform usage is billed to you on top of these amounts.

### Use with AI agents (MCP)

This Actor is usable through Apify MCP and exposes a review extraction tool for Amazon product pages and ASIN-based inputs. The exact Actor identity is `khadinakbar/amazon-reviews-scraper`.

> Extract Amazon product reviews for this ASIN and return review text, rating, verified purchase status, helpful votes, reviewer info, images, and variant.

Output interpretation:

- `review_body` is the primary text field for sentiment analysis, theme extraction, and summarization.
- `rating` and `is_verified_purchase` support separating review sentiment from purchase signals.
- `helpful_votes`, `is_top_review`, and `review_date_iso` support prioritization and time-based analysis.
- `source_url` and `product_url` provide provenance for each record.
- `results` points to the dataset items endpoint, while `runOutput` and `runSummary` support automation and agent-side status checks.

Scope, pagination, and cost guidance:

- The input schema is designed for Amazon product-page reviews and accepts product URLs or ASINs.
- `maxReviews` controls how many inline reviews are collected per product, within the schema range from 1 to 10.
- `reviewsCutoffDate` applies after scraping, which makes it useful for recent-review workflows.
- Each saved review triggers the `Review scraped` charged event, and Apify platform usage applies in addition to the event charges.
- Check the live Pricing tab for the current pricing view.

### Apify API example

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/amazon-reviews-scraper').call({
  productUrls: [
    { url: 'https://www.amazon.com/dp/B0CWXNS552' }
  ],
  maxReviews: 10,
  reviewsCutoffDate: '2024-01-01',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Fetched ${items.length} review records`);
console.log(items[0]);
```

### Best results and outcome guidance

Use a product URL or ASIN that points to the exact Amazon product page you want reviewed. If you already have the product ID, `asins` is a direct path into the same review dataset. Set `maxReviews` to the number of inline reviews you want to collect for that product, within the schema range. When you are tracking newer customer feedback, pair the product input with `reviewsCutoffDate` so the returned dataset reflects the date window you need. The returned `review_body`, `rating`, `is_verified_purchase`, `helpful_votes`, and `review_date_iso` fields form the most useful baseline for review analysis.

### Continue the workflow

- Then use [Amazon Search Scraper](https://apify.com/khadinakbar/amazon-search-scraper) to extend 🛒 Amazon Reviews Scraper — Ratings & Sentiment research with a complementary discovery contract.
- Then use [Amazon Seller Email Scraper](https://apify.com/khadinakbar/amazon-seller-email-scraper) to extend 🛒 Amazon Reviews Scraper — Ratings & Sentiment research with a complementary enrichment contract.

### Design note

I found that the dataset contract marks `asin`, `product_url`, `review_id`, `is_verified_purchase`, `helpful_votes`, `images`, `is_top_review`, `scraped_at`, and `source_url` as required, which keeps provenance and review identity present on every saved item.

### FAQ

#### How should I choose between product URLs and ASINs?

Use product URLs when you are starting from a product page, and use ASINs when you already have the Amazon product ID. Both paths lead to the same review dataset.

#### When does Amazon Product Search Scraper fit into the workflow?

Use Amazon Product Search Scraper when you need to discover Amazon products first, then pass the verified public URL or ID into this Actor for review extraction.

#### When does Amazon Search Scraper fit into the workflow?

Use Amazon Search Scraper when search results are the starting point and you want to continue into review data collection.

#### When does Amazon Competitor Price Tracker fit into the workflow?

Use Amazon Competitor Price Tracker when you want to begin with a product record and then collect related review data from that product page.

#### Which fields are most useful for sentiment analysis?

`review_body`, `rating`, `is_verified_purchase`, `helpful_votes`, `review_title`, and `review_date_iso` are the core fields for review analytics and downstream AI workflows.

#### Where is the resulting data stored?

Review records are written to the default dataset, and the output contract also exposes run summary and run output records in the key-value store for automation workflows.

### Responsible use

Use this Actor in line with applicable laws, Amazon's terms, and your internal data handling practices. Review records may include reviewer names, profile links, and other public review metadata, so handle the data with appropriate privacy and governance controls.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/amazon-reviews-scraper/changelog.md

# Actor input Schema

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

One or more Amazon product page URLs (e.g. https://www.amazon.com/dp/B0CWXNS552). Click '+ Add' to add multiple products. The ASIN is automatically extracted from the URL. You can also use /gp/product/ASIN URLs. Note: only amazon.com is read. A link from another Amazon country is converted to its amazon.com ASIN page, and since October 2026 amazon.com may show only a limited set of reviews to signed-out visitors.

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

Amazon Standard Identification Numbers (ASINs) — 10-character codes like B0CWXNS552. Enter one ASIN per line. Use this instead of product URLs when you already have the ASIN. ASINs are looked up on amazon.com only.

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

Maximum number of reviews to collect per product. Amazon displays its top 5–10 customer reviews on each product page — this actor collects those inline reviews. Set to 5 for a quick test or up to 10 for the full set Amazon shows. If amazon.com shows fewer reviews to signed-out visitors, you get fewer; a run with none ends as Failed and no review is charged.

## `reviewsCutoffDate` (type: `string`):

Skip reviews older than this date. Accepts YYYY-MM-DD format (e.g. 2024-01-01). Reviews are filtered after scraping — useful for tracking recent customer sentiment.

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

Amazon requires residential proxies to avoid bot detection. Apify Residential proxies are selected by default. If you have your own proxies, enter them here. Do not use datacenter proxies — Amazon blocks them aggressively.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://www.amazon.com/dp/B0CWXNS552"
    }
  ],
  "asins": [],
  "maxReviews": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of Amazon product reviews. Each item is one review with full rating, text, reviewer, and metadata fields.

## `runOutput` (type: `string`):

Machine-readable terminal outcome, useful result count, failure details, and PPE charge counts.

## `runSummary` (type: `string`):

Detailed terminal status for automation, monitoring, and AI-agent workflows.

# 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 = {
    "productUrls": [
        {
            "url": "https://www.amazon.com/dp/B0CWXNS552"
        }
    ],
    "asins": [],
    "maxReviews": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "productUrls": [{ "url": "https://www.amazon.com/dp/B0CWXNS552" }],
    "asins": [],
    "maxReviews": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/amazon-reviews-scraper").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 '{
  "productUrls": [
    {
      "url": "https://www.amazon.com/dp/B0CWXNS552"
    }
  ],
  "asins": [],
  "maxReviews": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

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/qvkDQ16s8dEjXitqK/builds/n7yjiDqjR3K7xZPbz/openapi.json