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

Extract paginated public Amazon product reviews by ASIN or URL, with rating filters, review media and marketplace support. Direct HTTP is tried first and an optional residential retry is strictly bounded. Only complete review rows are billed.

- **URL**: https://apify.com/dami\_studio/amazon-reviews-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

Extract publicly visible Amazon customer reviews from product URLs or ASINs. Every live record is a single complete review with its rating, title, text, reviewer, review date, verified-purchase status, helpful votes, review-media URLs, and canonical review URL.

### Why this actor is separate

This actor returns one row per review, with the review text, rating, title, author, date, country, verified-purchase badge, variation and helpful-vote count, for as many products as you pass in one run.

**What you get, precisely.** Amazon closed its standalone `/product-reviews/` pages to signed-out visitors in May 2026 — they now answer with the sign-in form. What is still public to anyone is the block of reviews Amazon shows on the product page itself, which in practice is **about 8 per product**. That is what this actor reads, and it is a sample of the review history rather than all of it. If you need every review a product ever received, no signed-out scraper can give you that, and this one does not pretend otherwise.

### Input

- `products`: Amazon URLs or 10-character ASINs. Empty input returns one labeled, uncharged sample row.
- `marketplace`: Used for ASIN inputs. URLs select their own supported marketplace.
- `maxProducts`: 1-10, default 3.
- `maxReviewsPerProduct`: 1-100, default 20.
- `maxPagesPerProduct`, `sortBy`, `starFilter`: accepted but no longer do anything. They belonged to the paginated review pages Amazon closed. The product page serves one unsorted, unfiltered block, so there is nothing to page through or order. Filter and sort the dataset afterwards instead.
- `deadlineSecs`: 10-150 seconds, default 90.
- `enableProxyFallback`: Off by default. It permits **one** proxied retry for the whole run only after a direct block, rate limit, network error, or Amazon soft-404 response. (`enableResidentialFallback` is kept as a deprecated alias of this flag.)
- `proxyConfiguration`: Used only by that single retry. Proxy servers you supply in `proxyUrls` are used exactly as given. Apify proxy requests are served from rotating **datacenter** addresses; metered groups (`RESIDENTIAL`, `GOOGLE_SERP`) are not offered, and a request for one is replaced with datacenter and reported back as an uncharged notice row.

```json
{
  "products": ["B0CKN6SPRZ", "https://www.amazon.com/dp/B09B8V1LZ3"],
  "marketplace": "com",
  "maxProducts": 2,
  "maxReviewsPerProduct": 25,
  "enableProxyFallback": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Output

Successful rows have `ok: true` and contain:

| Field | Meaning |
|---|---|
| `reviewId`, `asin`, `marketplace` | Stable review/product identity and Amazon marketplace |
| `rating`, `title`, `reviewText` | Public review content |
| `author`, `authorProfileUrl`, `reviewedAt` | Public reviewer attribution and displayed review date |
| `verifiedPurchase`, `vineCustomer`, `helpfulVotes` | Public Amazon review signals |
| `reviewImages`, `hasVideo`, `reviewUrl` | Public review media and canonical review page |
| `transport` | `direct`, `proxy_fallback_*` (datacenter or your own proxy), or `direct_retry` |

Rows with `ok: false` are uncharged diagnostics. Empty input has `_sample: true` and is also uncharged.

### Billing and cost control

`$0.002` to start a run, then `$0.002` per review — `$2.00` per 1,000 reviews.

A review is charged only once it is stored with an ID, author, rating and text. Samples, invalid input, diagnostics, Robot Check pages, failed proxy retries and empty results are never charged, so a product that returns nothing costs you the start charge and nothing else.

Direct traffic is always tried first. The optional retry is opt-in and capped at a single request per run, and it never uses per-gigabyte proxy groups, so a run cannot quietly run up bandwidth.

### Limitations

**About eight reviews per product.** That is what Amazon shows a signed-out visitor on the product page, and it is the whole of what is public. This is a sample, not a review archive.

**amazon.com and amazon.ca only, in practice.** Those two answer reliably. The European marketplaces — `co.uk`, `de`, `fr`, `it`, `es` — return a block instead of reviews for this Actor's addresses, with or without the proxy retry, and there is nothing the Actor can do about that from its side. Try one product before planning a run against them.

**No sorting or star filtering.** Both belonged to the paginated review pages Amazon closed in May 2026. Sort and filter the dataset afterwards.

This actor does not log in, solve CAPTCHAs, bypass access controls or touch private data. When Amazon blocks a request or shows no public reviews, it writes an uncharged diagnostic row saying which of the two happened.

# Actor input Schema

## `products` (type: `array`):

Amazon product URLs or 10-character ASINs. This review-only actor does not scrape product catalog or search results.

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

Amazon marketplace for plain ASIN inputs. amazon.com and amazon.ca answer reliably. The European marketplaces (co.uk, de, fr, it, es) refuse this Actor's addresses and return a block instead of reviews - see the README before planning a run against them.

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

Hard limit on unique products per run. Keeping this small makes review costs predictable.

## `maxReviewsPerProduct` (type: `integer`):

Upper bound on reviews kept per product. Amazon shows roughly 8 reviews per product to signed-out visitors, so values above that simply keep whatever it served.

## `maxPagesPerProduct` (type: `integer`):

No longer has any effect. Amazon closed the paginated review pages to signed-out visitors, and the product page serves a single block with no next page.

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

No longer has any effect. Sorting belonged to the review pages Amazon closed; sort the dataset afterwards instead.

## `starFilter` (type: `string`):

No longer has any effect. Filtering belonged to the review pages Amazon closed; filter the dataset afterwards instead.

## `deadlineSecs` (type: `integer`):

Actor-side wall-clock deadline, independent of the Apify timeout. An uncharged diagnostic is returned when it is reached.

## `enableProxyFallback` (type: `boolean`):

When a direct request is blocked, rate-limited, fails, or receives Amazon's soft 404 response, make at most one proxied retry for the entire run. The retry uses rotating datacenter addresses, or your own proxy servers when you supply them below.

## `enableResidentialFallback` (type: `boolean`):

Deprecated alias of "Enable one proxy retry", kept so existing saved inputs keep working. This actor does not offer metered residential proxy groups; the retry always uses rotating datacenter addresses or your own proxy servers.

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

Used only for the single optional retry. Your own proxy servers (proxyUrls) are used exactly as given. Apify proxy requests are served from rotating datacenter addresses: metered groups such as RESIDENTIAL and GOOGLE\_SERP are not offered and are replaced with datacenter, with a notice in the dataset.

## Actor input object example

```json
{
  "products": [
    "B08N5WRWNW"
  ],
  "marketplace": "com",
  "maxProducts": 3,
  "maxReviewsPerProduct": 20,
  "maxPagesPerProduct": 2,
  "sortBy": "recent",
  "starFilter": "all_stars",
  "deadlineSecs": 90,
  "enableProxyFallback": false,
  "enableResidentialFallback": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Complete review rows and uncharged sample or diagnostic rows are written to the default dataset.

# 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 = {
    "products": [
        "B08N5WRWNW"
    ]
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/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/fVB1cpzod9NsJTxIP/builds/HGHdCjUw34FxFl1g8/openapi.json