# Amazon Reviews Scraper – Ratings, Photos & Monitoring (`k-data-lab/amazon-reviews-scraper`) Actor

Scrape Amazon reviews for any ASIN or URL on 20 Amazon sites: rating, title, text, date, country, variant, verified badge, helpful votes and photos. Sign in once in Live View for full lists with star, keyword and media filters. First 100 reviews every month free.

- **URL**: https://apify.com/k-data-lab/amazon-reviews-scraper.md
- **Developed by:** [K-Data Lab](https://apify.com/k-data-lab) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 review scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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, Photos & Review Monitoring for 20 Amazon Sites

**Export Amazon customer reviews for any ASIN or product link into a clean table**: star rating, title, full text, date, country, variant, Verified Purchase badge, helpful votes, reviewer and review photos. Works on **amazon.com, .co.uk, .de, .fr, .it, .es, .co.jp, .in, .ca** and 11 more Amazon sites.

🎁 **Your first 100 reviews every month are free.** After that it's **from $1.00 per 1,000 reviews**, and you're charged only for reviews delivered.

***

#### 🔍 What does Amazon Reviews Scraper do?

Give it products, and it returns **one row per review**:

- ⭐ **Rating** (1–5), **title** and **full review text** in the original language
- 📅 **Review date** (yyyy-mm-dd) and the **country** it was written in
- 🏷️ **Variant** reviewed (size, colour…) and its **variant ASIN**
- ✅ **Verified Purchase** and **Vine** badges, 👍 **helpful votes**
- 🖼️ **Review photo URLs** (full size) and a video flag
- 👤 **Reviewer name** and public profile link, 🔗 **review link** and **review ID**
- 📦 **Product title, average rating and total ratings** on every row

It accepts bare ASINs (`B0G7RYP439`), product links from any Amazon site (`https://www.amazon.de/dp/B0GDHRZFWH`), review page links, or a mixed list pasted from a spreadsheet.

***

#### 🔐 Why sign in once? (important)

Since late 2024 **Amazon shows full review lists only to signed-in shoppers**. On amazon.com even the product page now says *"Sign in to see customer reviews"*. Every reviews scraper hits this wall. This one handles it honestly and safely:

| | Signed in (Login mode, once) | Not signed in |
|---|---|---|
| amazon.com | ✅ Full review lists | ❌ Amazon hides reviews |
| Most other Amazon sites | ✅ Full review lists | ✅ The ~8–13 "Top reviews" on the product page |
| Reviews per product | up to ~1,000 (see below) | ~8–13 |
| Star / keyword / verified / media / variant filters | ✅ | — |

**How Login mode works (1 minute, once per marketplace):**

1. Set **Mode → Login**, pick the marketplaces (e.g. amazon.com) and click **Start**.
2. Open the run's **Live View** tab. You'll see a real browser on Amazon's sign-in page.
3. Click a field in the picture, type in the box under it and press **Type**. Sign in with **your own Amazon shopper account** (email, password, code if asked).
4. As soon as you're signed in, the session is saved **privately in your own Apify account** and the run finishes.
5. Switch **Mode → Scrape** and run as often as you like. The actor reuses the session and keeps it fresh until Amazon expires it, usually weeks.

> 🔒 Your password is typed by you into Amazon's own page and goes nowhere else. It's never in the input, the log or the output. Only the resulting session cookies are stored, in a key-value store in **your** account that no one else can read.

**Tip:** use a normal shopper account, not your seller account. Signed-in runs use one steady residential IP in the marketplace's country, at a calm, human pace.

***

#### 📊 How many reviews per product?

Amazon stops every review list at **100 reviews (10 pages)**. When you ask for more than 100, the actor automatically walks **each star rating (5★ → 1★)** and **both sort orders** and de-duplicates them by review ID. For most products that reaches **all or nearly all written reviews, up to ~1,000**. Set **Max reviews per product = 0** to take everything reachable.

***

#### 🔁 Review monitoring (daily alerts)

Turn on **Only new reviews (monitoring)** and **schedule the actor daily**. It remembers which review IDs it already delivered (in your own account) and returns **only reviews you haven't received before**, so each review is delivered and billed **once**. With *Most recent* sort it also stops paging as soon as it reaches reviews it already knows, which keeps daily runs fast and cheap.

Combine it with Apify integrations (Slack, email, Google Sheets, Zapier, Make, webhooks) to get **a message for every new 1–2★ review** of your products or your competitors'.

***

#### 📥 Input example

```json
{
  "products": ["B0G7RYP439", "https://www.amazon.de/dp/B0GDHRZFWH"],
  "marketplace": "com",
  "maxReviewsPerProduct": 300,
  "sort": "recent",
  "filterByStar": "critical",
  "verifiedOnly": true,
  "reviewsFromDaysAgo": 30,
  "onlyNewReviews": true
}
```

#### 📤 Output example

```json
{
  "reviewId": "R1Z2MOPDAH1TG6",
  "asin": "B0G7RYP439",
  "variantAsin": "B0CWMDV9CH",
  "marketplace": "amazon.com",
  "rating": 1,
  "title": "Defectuoso",
  "text": "Lo he comprado dos veces y nada que se adhiere adecuadamente…",
  "date": "2026-10-13",
  "reviewedIn": "United States",
  "variant": "Size: Galaxy S24 Ultra",
  "verifiedPurchase": true,
  "vineReview": false,
  "helpfulVotes": 0,
  "reviewer": "Eluchija18",
  "images": ["https://m.media-amazon.com/images/I/81Kd-sAiTrL.jpg"],
  "hasVideo": false,
  "language": "es",
  "reviewUrl": "https://www.amazon.com/gp/customer-reviews/R1Z2MOPDAH1TG6",
  "source": "review-page",
  "productTitle": "Spigen GlasTR EZ Fit Privacy Tempered Glass Screen Protector for Galaxy S26 …",
  "productRating": 4.2,
  "productRatingsCount": 2968,
  "scrapedAt": "2026-10-18T12:00:00+00:00"
}
```

The **Output** tab shows a ready-made *Reviews* table. Export to Excel, CSV, JSON, XML or HTML, or read it via API. Each run also writes a `RUN_SUMMARY` record with per-marketplace status (`OK`, `NEEDS_LOGIN`, `SESSION_EXPIRED`, `PARTIAL`).

***

#### 💰 How much does it cost to scrape Amazon reviews?

**🎁 Your first 100 reviews every month are free.** After that:

| Your Apify plan | Per review | Per 1,000 reviews |
|---|---|---|
| Free | $0.0008 | **$0.80** |
| Starter | $0.0012 | $1.20 |
| Scale | $0.0011 | $1.10 |
| Business and higher | $0.0010 | **$1.00** |

Plus **$0.005 per run**. It's pay-per-event, so platform usage and proxies are **not** billed on top, and you pay only for review rows delivered. Login runs and products with no reviews cost only the run start.

| You collect (Starter plan) | Cost |
|---|---|
| 100 reviews once | **$0.005** (all free) |
| 1,000 reviews | ≈ $1.09 |
| 10 products × 300 reviews | ≈ $3.49 |
| Daily monitoring of 50 products (~20 new reviews/day) | ≈ $0.75 / month |

Set **Maximum cost per run** in the run options to cap any run. The actor stops cleanly there.

***

#### 🚀 How to scrape Amazon reviews (step by step)

1. Click **Try for free** and create a free Apify account, no card needed.
2. If you need amazon.com or full review lists, run **Login mode** once (see above).
3. Paste ASINs or product links into **Products**, set **Max reviews per product** and any filters.
4. Click **Start**, then download the results from the **Output** tab.
5. Optional: **Schedule** it daily with *Only new reviews* for monitoring.

#### 📊 Popular use cases

- **Product quality monitoring**: catch every new 1–2★ review and the defect it mentions, per variant
- **Competitor research**: what buyers love and hate about competing products
- **Voice of customer & AI analysis**: feed review text into ChatGPT, Claude or your BI tool for themes and sentiment
- **Listing optimization**: find the words buyers use, then answer objections in your bullets and images
- **Review photo collection**: gather customer photos per variant for QA

#### 🔌 Integrations & API

Run it from **Python, JavaScript, cURL, Make, Zapier, n8n, Google Sheets** or any HTTP client:

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("k-data-lab/amazon-reviews-scraper").call(run_input={
    "products": ["B0G7RYP439"], "maxReviewsPerProduct": 200, "filterByStar": "critical"})
for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["date"], review["rating"], review["title"])
```

#### 💡 Tips

- **Monitoring many products?** Use *Most recent* sort + *Only reviews from the last N days* to keep runs short.
- **Several Amazon accounts or brands?** Give each its own **Session store name**.
- **`SESSION_EXPIRED`** in the run summary means Amazon signed the session out. Run Login mode for that marketplace again.
- Review text is kept in the **original language**. Amazon's machine translations aren't mixed in.

#### ❓ FAQ

**Do I need an Amazon account?** Only for amazon.com and for full review lists. Without one you get each product page's top reviews on most non-US Amazon sites.

**Is my account safe?** The actor reads review pages the way you would in a browser: one session, one steady home-country IP, human-like pauses, and no buying, posting or account changes. It never sees your password.

**Why not more than ~1,000 reviews per product?** Amazon itself limits how far any review list can be paged. Splitting by star rating and sort order is how the actor goes beyond the 100-review limit.

**Can I get reviews from all countries for one product?** Add the product once per Amazon site (e.g. `amazon.de/dp/…`, `amazon.fr/dp/…`). Each site's list also includes "reviews from other countries" that Amazon shows there.

**Is scraping Amazon reviews legal?** The actor collects publicly visible review data. Make sure your use complies with Amazon's terms and with data-protection rules (e.g. GDPR) for any personal data such as reviewer names.

#### 💬 Feedback

Missing a field, a filter or a marketplace? Open an issue on the **Issues** tab. We usually ship requests within days.

🔖 **Tags:** amazon reviews scraper · amazon review export · amazon review monitoring · amazon customer reviews api · amazon review photos · amazon review analysis · amazon competitor reviews · amazon reviews to excel

# Actor input Schema

## `mode` (type: `string`):

<b>Scrape</b> collects reviews. <b>Login</b> opens a real browser in the run's <b>Live View</b> tab where you sign in to your own Amazon shopper account; the session is saved privately in your Apify account and later Scrape runs reuse it. Never needs your password in the input.

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

One per line: an ASIN (uses the marketplace below) or a product / review page URL from any Amazon site (uses that site).

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

Used for lines that are only an ASIN.

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

Amazon lists at most 100 reviews per sort/filter, so above 100 the actor also walks each star rating and the other sort order (de-duplicated). 0 = everything reachable (usually up to ~1,000).

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

Order of the review list.

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

Only reviews with this rating.

## `verifiedOnly` (type: `boolean`):

Only reviews with the Verified Purchase badge.

## `withMediaOnly` (type: `boolean`):

Only reviews that include images or video.

## `currentVariantOnly` (type: `boolean`):

Only reviews of the exact variant (size/colour) in the link, not the whole product family.

## `keyword` (type: `string`):

Only reviews containing this word or phrase (Amazon's own review search).

## `reviewsFromDaysAgo` (type: `integer`):

Skip older reviews. With 'Most recent' sort the actor also stops paging early, so runs are faster and cheaper.

## `minReviewDate` (type: `string`):

Absolute date alternative to the field above (yyyy-mm-dd).

## `onlyNewReviews` (type: `boolean`):

Remember delivered review IDs (in your own Apify account) and return only reviews you haven't received before. Perfect for a daily schedule: each review is delivered and billed once.

## `loginMarketplaces` (type: `array`):

Login mode only. Defaults to the marketplaces of your products (or the marketplace above).

## `loginTimeoutMinutes` (type: `integer`):

How long Login mode waits for you to finish signing in on each marketplace.

## `useSavedSessions` (type: `boolean`):

Use the sessions saved by Login mode (stored privately in your own Apify account).

## `saveSessions` (type: `boolean`):

Save the cookies Amazon refreshes during a run, so the session lasts longer.

## `sessionStoreName` (type: `string`):

Named key-value store in your account that holds your sessions, monitoring history and free-quota counter. Use different names to keep several Amazon accounts apart.

## `sessionCookie` (type: `string`):

Advanced: instead of Login mode, paste a Cookie-Editor JSON export or the Cookie header from your signed-in amazon.<site> tab. Applies to the marketplace above (single-marketplace runs).

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

Signed-in runs use one sticky residential IP in the marketplace's country by default; signed-out runs use datacenter IPs.

## Actor input object example

```json
{
  "mode": "scrape",
  "products": [
    "https://www.amazon.de/dp/B0GDHRZFWH",
    "https://www.amazon.fr/dp/B0GDHRZFWH"
  ],
  "marketplace": "com",
  "maxReviewsPerProduct": 100,
  "sort": "recent",
  "filterByStar": "all_stars",
  "verifiedOnly": false,
  "withMediaOnly": false,
  "currentVariantOnly": false,
  "onlyNewReviews": false,
  "loginTimeoutMinutes": 10,
  "useSavedSessions": true,
  "saveSessions": true,
  "sessionStoreName": "amazon-review-sessions",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

# 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": [
        "https://www.amazon.de/dp/B0GDHRZFWH",
        "https://www.amazon.fr/dp/B0GDHRZFWH"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("k-data-lab/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": [
        "https://www.amazon.de/dp/B0GDHRZFWH",
        "https://www.amazon.fr/dp/B0GDHRZFWH",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("k-data-lab/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": [
    "https://www.amazon.de/dp/B0GDHRZFWH",
    "https://www.amazon.fr/dp/B0GDHRZFWH"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call k-data-lab/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

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