# Amazon Reviews Scraper — Review Text, Ratings & ASIN Data (`jaybird/amazon-reviews-scraper`) Actor

Scrape Amazon reviews by ASIN, URL, or keyword into JSON (text, stars, verified flags, helpful votes, histogram, Customers say). Note: since Oct 2026 amazon.com returns summary/excerpts only (no login); Top reviews still on .co.uk/.de/.ca. Pay per result.

- **URL**: https://apify.com/jaybird/amazon-reviews-scraper.md
- **Developed by:** [Jaybird Technologies](https://apify.com/jaybird) (community)
- **Categories:** E-commerce, AI, Agents
- **Features:** Limited permissions
- **Stats:** 659 total users, 174 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 results

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

Scrape **Amazon product reviews** into clean, structured JSON — **review text, title, star rating, date, verified-purchase & Vine flags, helpful votes, purchased variant, author, and customer photos/videos** — plus a **per-ASIN ratings histogram**, rating totals, and Amazon's **"Customers say" AI summary with aspect-sentiment breakdown**. Look products up by **ASIN**, **product URL**, or **keyword search**. A fast, reliable **Amazon review API** alternative for product research, sentiment analysis, and AI/RAG pipelines.

**Highlights:** 📸 image & video reviews · 🧠 "Customers say" AI sentiment · ⭐ filter by star / verified / media + sort · 🔎 look up by ASIN, URL **or keyword search** · 🛡️ 100% success, 0 blocked in testing · 🌍 9 marketplaces · 💵 from **$0.85 / 1,000 results**

> **amazon.com notice (October 27, 2026):** since October 25, amazon.com shows product reviews only to signed-in visitors. This Actor never logs in, so amazon.com products currently return their summary row (ratings histogram, totals, "Customers say" AI summary) but no full reviews or photo/video reviews. The summary row does include the review excerpts Amazon still shows logged-out visitors under "Customers say": about 30 per product, each with its review ID, in `customersSay.aspects[].snippets`. Other marketplaces still return their Top reviews (checked October 27 on `.co.uk`, `.de` and `.ca`). You're billed only for rows returned, so an amazon.com product costs one result.

### What you get

One dataset record per review. The product page's **"Top reviews"** come with author, verified-purchase flag, and helpful votes:

```json
{
    "recordType": "review",
    "asin": "B00P8XQPY4",
    "productTitle": "SANDISK 128GB Ultra USB 3.0 Flash Drive - SDCZ48-128G-U46, Black",
    "reviewId": "R2RLBBVMWSN16G",
    "title": "Great buy!",
    "text": "This is for recording off of the tv. Easy hookup to the firestick so I can record programs for later viewing. Data integrity is excellent, size is perfect. Works well.",
    "rating": 5,
    "date": "April 26, 2026",
    "country": "United States",
    "verifiedPurchase": true,
    "vineReview": false,
    "helpfulVotes": 2,
    "variant": "Style: Old Generation, Size: 64GB",
    "variantAsin": "B00P8XQPY4",
    "authorName": "Jim F",
    "authorProfileUrl": "https://www.amazon.com/gp/profile/amzn1.account.AGHBTTDMZVKKQICPPHE7V6PHZSYQ",
    "reviewerId": "amzn1.account.AGHBTTDMZVKKQICPPHE7V6PHZSYQ",
    "url": "https://www.amazon.com/dp/B00P8XQPY4",
    "scrapedAt": "2026-06-07T21:43:00.672Z"
}
```

…and **customer image & video reviews** from the product's media gallery come with the full review text plus links to the photos/videos:

```json
{
    "recordType": "review",
    "asin": "B07CMS5Q6P",
    "productTitle": "Logitech G305 Lightspeed Wireless Gaming Mouse",
    "reviewId": "R13QTYS7W4GQM5",
    "title": "Great mouse for a great price",
    "text": "Mouse works great. I used the logitech g pro (wired) for years…",
    "rating": 5,
    "date": "June 4, 2026",
    "country": "United States",
    "language": "en-US",
    "verifiedPurchase": true,
    "vineReview": false,
    "variantAsin": "B07CMS5Q6P",
    "authorName": "Petre I.",
    "reviewerId": "amzn1.account.AHYIRSGWL76KCXLNY52XP5JISWAQ",
    "mediaType": "IMAGE",
    "images": [
        "https://m.media-amazon.com/images/I/41W75UraVHL.jpg",
        "https://m.media-amazon.com/images/I/41Ko2z26ZSL.jpg"
    ],
    "url": "https://www.amazon.com/dp/B07CMS5Q6P",
    "scrapedAt": "2026-06-09T18:20:00.000Z"
}
```

Plus **one summary record per ASIN** with the full ratings breakdown **and Amazon's "Customers say" AI summary** (the overall paragraph plus the aspect-sentiment chips, each linked back to the reviews it was distilled from) — captured for every product, even ones whose individual reviews are sparse:

```json
{
    "recordType": "summary",
    "asin": "B092XZH6CB",
    "productTitle": "Retrospec Solana Yoga Mat 1\" Thick w/Nylon Strap",
    "averageRating": 4.5,
    "totalRatingCount": 14426,
    "ratingsHistogram": { "fiveStar": 77, "fourStar": 12, "threeStar": 5, "twoStar": 2, "oneStar": 4 },
    "customersSay": {
        "summary": "Customers find the yoga mat to be of good quality, with thick…",
        "aspects": [
            { "aspect": "thickness", "sentiment": "positive", "mentions": 1102, "positivePercentage": 84, "summary": "Customers like the yoga mat's thickness…", "reviewIds": ["RX3B4OFBLRSD", "R1D55FQFLOCNVM"],
              "snippets": [{ "reviewId": "RX3B4OFBLRSD", "text": "Nice, thick, comfortable yoga mat. Has no smell whatsoever, came in good condition…" }] },
            { "aspect": "quality", "sentiment": "positive", "mentions": 826, "positivePercentage": 91, "summary": "Customers find the yoga mat to be well-made…", "reviewIds": ["RX3B4OFBLRSD", "R2MV83T8FA58ER"] }
        ]
    },
    "url": "https://www.amazon.com/dp/B092XZH6CB",
    "scrapedAt": "2026-06-09T18:20:00.000Z"
}
```

### Why this scraper

Amazon review scrapers are a graveyard of broken tools — the second most-popular Amazon-reviews Actor on the market runs at **~66% success**, so users routinely get partial dumps and silent failures. This Actor is built around the two things that actually matter: **getting real review volume anonymously**, and **coping with Amazon's anti-bot stack** — while being honest about what anonymous scraping can and can't reach.

- 📸 **Image & video reviews, in full.** On `amazon.com`, the Actor pulls every customer photo/video review from the product's media gallery — **dozens to hundreds for popular products** — each with its complete review text, rating, and media links. This is the real volume, and it needs no login.
- 🛡️ **Battle-tested anti-blocking.** Datacenter→residential proxy escalation (country-pinned to the marketplace), a session pool with per-session browser fingerprints, and retire-on-captcha — the same stack behind our Amazon Product Scraper. In a 20-product test it ran at **100% success, 0 blocked**.
- 📊 **Always get the histogram.** Every ASIN yields its full ratings distribution (5★→1★), average, and total rating count — even when review text is thin.
- 🧠 **"Customers say" AI summary, structured.** Every ASIN with enough reviews returns Amazon's own AI review summary plus an aspect-by-aspect sentiment breakdown — *build quality*, *value for money*, *battery life* — with mention counts, a positive-sentiment percentage, and links to the exact reviews behind each. Ready-made product insights, no LLM step on your side.
- 🔎 **Three ways in.** Look up by ASIN, paste product URLs, or run a keyword search and scrape the top results' reviews — keyword lookup that the major competitors don't offer.
- ⭐ **Filter and sort built in.** Keep only the star ratings you want, Verified-Purchase only, or photos/video only — and sort by most recent, most helpful, or rating. You're billed only for what's returned.
- ✅ **Honest, never login-based.** No fake "every review on a million-review product" promises, and no credential login that could get *your* account banned. See [what's reachable](#what-the-actor-can-reach-read-this).
- 🤖 **AI/agent ready.** Flat, predictable JSON drops straight into RAG pipelines, sentiment models, and agent tools.

### What the Actor can reach (read this)

Straight, no marketing:

- **"Top reviews"** Amazon renders on every product page — typically **~8–15 per ASIN**, a recent/most-helpful mix — with full text, rating, date, verified-purchase flag, helpful votes, variant, and author. Captured on **every marketplace**. Amazon shows logged-out visitors a "Sign in to see customer reviews" prompt in place of this list: on amazon.com every visitor since October 25, 2026, elsewhere only some. The Actor retries with a fresh session, which clears it when only some sessions get the prompt, and stops retrying once a marketplace shows it to every session in the run. If a product stays behind the prompt, Amazon hides its photo/video reviews too, so you get only its summary record (histogram, totals, "Customers say"); the run's status message says how many products were affected.
- **Customer image & video reviews** from the product's media gallery — **on `amazon.com`** (currently hidden behind the sign-in prompt; see the notice at the top). For products with lots of customer photos this is **dozens to hundreds** of additional reviews, each with its full text, rating, date, language, and photo/video links. Products without customer media return just the Top reviews. Turn this off with `includeMediaReviews: false` for a faster, cheaper Top-reviews-only run.
- **The ratings histogram and total rating count** — always, for every ASIN, regardless of how many individual reviews are reachable.
- **Amazon's "Customers say" AI summary and aspect-sentiment breakdown** — for ASINs with enough reviews for Amazon to generate one. Decoded straight from the product page (no extra request).

What it deliberately does **not** do:

- **It does not log in.** Amazon login-gates its dedicated `/product-reviews/` pages (deep text pagination with sort/star filters). Credential scraping violates Amazon's Terms of Service and risks getting *your* account banned — never worth it. So the **non-media** review text beyond the Top set isn't reachable anonymously, and on non-US marketplaces only the Top reviews are returned.

If a product has heavy customer-photo activity, expect a lot of reviews. If it has none, expect the Top set plus the histogram. Either way you get exactly what's there, reliably — and an honest picture of the rest.

### How to scrape Amazon reviews

1. Click **Try for free** / open the Actor.
2. Provide input one of three ways:
   - **ASINs** — paste 10-character product IDs (e.g. `B07DF46NW9`).
   - **Product URLs** — paste any `/dp/` or `/gp/product/` links.
   - **Keyword** — type a search term and set **Max products from search**.
3. Click **Start**, then **download** JSON, CSV, or Excel — or fetch via the API.

### Input examples

By ASIN:

```json
{ "asins": ["B07DF46NW9", "B00P8XQPY4"], "maxReviewsPerAsin": 100 }
```

By keyword search:

```json
{ "keyword": "wireless earbuds", "maxProducts": 5 }
```

By product URL on another marketplace:

```json
{ "productUrls": ["https://www.amazon.co.uk/dp/B07DF46NW9"], "domain": "amazon.co.uk" }
```

| Input | Description |
|---|---|
| `asins` | Array of ASINs (10-char product IDs). |
| `productUrls` | Array of Amazon `/dp/` or `/gp/product/` URLs (each keeps its own marketplace domain). |
| `keyword` + `maxProducts` | Search term and how many top results to scrape reviews for. |
| `maxReviewsPerAsin` | Cap on reviews per ASIN (default 100; `0` = no cap). Applied **after** filtering, so you get up to N matching reviews. |
| `includeMediaReviews` | Fetch customer image/video reviews from the media gallery (default `true`; `amazon.com` only). The main source of volume. |
| `reviewStars` | Only return reviews with these star ratings, e.g. `["5"]` or `["1","2"]`. Empty = all. |
| `verifiedOnly` | Only return Verified Purchase reviews (default `false`). |
| `mediaOnly` | Only return reviews with photos/video (default `false`). |
| `excludeReviewIds` | Review IDs to leave out, e.g. the `reviewId` values from an earlier run (review permalinks work too). Excluded reviews aren't saved or billed and don't count toward `maxReviewsPerAsin`. |
| `sortReviewsBy` | `default` (Amazon's order), `mostRecent`, `mostHelpful`, `highestRating`, or `lowestRating`. |
| `domain` | Marketplace for bare ASINs and keyword search (`amazon.com`, `.co.uk`, `.de`, `.ca`, `.com.au`, `.in`, `.fr`, `.it`, `.es`). |

> **Note on filters:** `reviewStars`, `verifiedOnly`, `mediaOnly`, `excludeReviewIds`, and `sortReviewsBy` operate on the reviews reachable anonymously (Top reviews + media gallery) — they slice and order what's available; they don't unlock Amazon's deeper login-gated review pages. Reviews you filter out are never saved, so you don't pay for them.

### What data can it extract?

| Field | Description |
|---|---|
| `asin`, `productTitle` | Product the review belongs to |
| `reviewId` | Amazon's stable review ID |
| `rating` | Star rating, 1–5 |
| `title`, `text` | Review headline and body |
| `date`, `country` | Review date and the country it was written in |
| `verifiedPurchase` | Whether Amazon marks it a Verified Purchase |
| `vineReview` | Whether it carries the "Vine Customer Review of Free Product" badge |
| `helpfulVotes` | "N people found this helpful" count (Top reviews) |
| `variant` | Purchased size/color/style, when shown |
| `variantAsin` | ASIN of the specific variant the review targets (can differ from the parent) |
| `authorName`, `authorProfileUrl` | Reviewer name and public profile link |
| `reviewerId` | Reviewer's stable Amazon account id (`amzn1.account.…`) |
| `images` | Customer photo/video URLs attached to the review (media-gallery reviews) |
| `mediaType` | `IMAGE` or `VIDEO` for media-gallery reviews |
| `language` | Review's source language, e.g. `en-US` (media-gallery reviews) |
| **Summary record** | `averageRating`, `totalRatingCount`, `ratingsHistogram` (5★→1★ percentages), and `customersSay` — one per ASIN |
| `customersSay` | Amazon's "Customers say" AI summary: `summary` is the full overall paragraph exactly as shown on the product page; `aspects` is the sentiment breakdown, with per aspect (e.g. *build quality*, *value for money*) a `sentiment`, `mentions` count, `positivePercentage`, one-line `summary`, the `reviewIds` it was distilled from, and `snippets`: the review excerpts Amazon shows for that aspect (`reviewId`, `text`; usually 4 per aspect, often cut off with an ellipsis) |

### How much will it cost?

Pay-per-event: **$0.00095 per result — $0.95 per 1,000 results** — plus a negligible Actor-start fee ($0.00005 per run). A result is **any row in the output dataset**: each review is one result, and so is each product's summary row (histogram, totals, "Customers say"). Products that can't be scraped also get one status row (`NOT_FOUND` or `BLOCKED`), billed the same way. Higher Apify subscription tiers get progressively lower prices (down to **$0.85 per 1,000**). Current prices are always on the **Pricing** tab.

Volume varies a lot by product — a popular item with hundreds of customer photos yields far more reviews (and costs more) than a niche one with none. Use `maxReviewsPerAsin` to bound spend precisely:

- **`maxReviewsPerAsin: 20`, 10 ASINs** ≈ up to 200 reviews + 10 summary rows = 210 results ≈ **$0.20**.
- **Top reviews only** (`includeMediaReviews: false`) ≈ ~13 reviews + 1 summary row per ASIN ≈ **$0.13 for 10 ASINs**.
- **Summaries only** (`maxReviewsPerAsin: 1`, `includeMediaReviews: false`) = 2 results per ASIN ≈ **$0.02 for 10 ASINs**.

### Tips

- **Want maximum review volume?** Leave `includeMediaReviews` on and set a generous `maxReviewsPerAsin` (or `0` for no cap) — popular `amazon.com` products return dozens to hundreds of image/video reviews.
- **Want it fast and cheap?** Set `includeMediaReviews: false` for just the Top reviews and histogram.
- **Want just the ratings distribution and "Customers say"?** Set `maxReviewsPerAsin: 1` and `includeMediaReviews: false`: each product returns its summary row plus one review (2 results). Don't use `0` for this — it means *no cap*. Then read only the `summary` records.
- **Re-running the same products?** Pass the `reviewId` values you already have in `excludeReviewIds`. Those reviews are skipped (and not billed), and `maxReviewsPerAsin` fills with ones you don't have yet, as far as the reachable pool allows.
- **Use `productUrls`** when you already have links; **use `keyword`** to discover products and pull their reviews in one run.

### Integrations

Export to **Google Sheets, Google Drive, S3**, or a database; automate with **Zapier, Make, and webhooks**; **schedule** recurring runs; or call it from anywhere via the **Apify API** and JS/Python SDKs.

### Related Actors

- [Amazon Product Scraper](https://apify.com/jaybird/amazon-product-data-scraper): price, availability, seller, specs and images for the same ASINs.
- [Amazon Bestsellers Rank Tracker](https://apify.com/jaybird/amazon-bestsellers-movers-shakers-tracker): the top 100 of any Best Sellers category on 11 marketplaces, with rank changes between runs, so you know which products' reviews to pull.
- [Amazon Seller Scraper](https://apify.com/jaybird/amazon-seller-info-scraper): the business behind a seller ID, with address, phone, VAT and EU contact emails.

### Feedback and reviews

Something not working, or a field you need? Open an issue on the [Issues tab](https://apify.com/jaybird/amazon-reviews-scraper/issues) and we'll take a look.

If this Actor saved you time, a short [review on Apify Store](https://apify.com/jaybird/amazon-reviews-scraper/reviews) helps other people decide whether it fits their needs.

### FAQ

**How many reviews can it get per product?** The product page's "Top reviews" (~8–15/ASIN, every marketplace) plus, on `amazon.com`, every customer image/video review from the media gallery — often dozens to hundreds for popular products, few or none for products without customer photos. Plus the full ratings histogram for every ASIN. See [what's reachable](#what-the-actor-can-reach-read-this).

**Can it get *every* review on a product?** No anonymous scraper can — Amazon login-gates deep text-review pagination. This Actor returns the Top reviews + all media-gallery reviews + the histogram, without logging in.

**Does it log into Amazon?** No. Credential login violates Amazon's ToS and risks an account ban. This Actor is anonymous-only by design.

**Which marketplaces work?** `amazon.com` and major locales (`.co.uk`, `.de`, `.ca`, `.com.au`, `.in`, `.fr`, `.it`, `.es`). Since October 25, 2026, `amazon.com` returns summary rows only, with about 30 review excerpts each in `customersSay` (see the notice at the top). Image/video media reviews are currently `amazon.com` only; other marketplaces return the Top reviews and histogram. Product URLs keep their own domain automatically.

**Can I scrape Amazon reviews by keyword?** Yes. Enter a search term and a `maxProducts` count, and the Actor finds the top matching products and pulls their reviews in one run — no ASINs needed. Most Amazon review scrapers only accept ASINs or URLs.

**Does it extract Amazon's "Customers say" AI summary?** Yes. Every product with enough reviews returns Amazon's own "Customers say" paragraph plus a structured aspect-sentiment breakdown (e.g. *build quality*, *value for money*) with mention counts, a positive-sentiment percentage, and the review IDs behind each — ready for sentiment analysis with no LLM step on your side.

**Can I filter reviews by star rating or verified purchase?** Yes. Use `reviewStars` (e.g. only 5-star or only 1–2-star), `verifiedOnly`, and `mediaOnly`, and order results with `sortReviewsBy` (most recent, most helpful, highest/lowest rating). Filtering happens before anything is saved, so you don't pay for reviews you filtered out.

**How do I export Amazon reviews to Excel or CSV?** Run the Actor, then download the dataset as **CSV, Excel, JSON, or XML** from the run's Storage tab — or pull it via the Apify API. You can also push results straight to Google Sheets, a database, or S3.

**Is it legal to scrape Amazon reviews?** This Actor extracts only publicly visible review data. Reviews can contain personal data (author names/profiles), which is protected by GDPR and similar laws — you're responsible for how you use the results; consult your lawyers if unsure.

### Changelog

**0.3 update (October 28, 2026)** — new input `excludeReviewIds`: review IDs to leave out, such as the ones you collected in an earlier run. Excluded reviews aren't saved or billed and don't count toward `maxReviewsPerAsin`, so the cap fills with other reviews from the same reachable pool. The run's status message says how many were skipped. Pricing is unchanged.

**0.3 update (October 27, 2026)** — amazon.com now shows reviews only to signed-in visitors. When a marketplace shows the sign-in prompt on every page in a run, the Actor now keeps each product's summary row on the first try instead of retrying it up to 8 times, and the status message names the marketplace. New field `customersSay.aspects[].snippets`: the review excerpts Amazon shows under each "Customers say" aspect, with the ID of the review each comes from. They're on the page Amazon shows logged-out visitors, so amazon.com products still return about 30 excerpts each while full reviews stay behind the prompt. No extra requests or rows, so pricing is unchanged.

**0.3 update (October 24, 2026)** — runs that save at least one review now end their status message with a link for leaving a review on Apify Store, and the README has a new Feedback and reviews section. Output and pricing are unchanged.

**0.3 update (October 2026)** — fix: `customersSay.summary` now returns Amazon's actual overall "Customers say" paragraph, verbatim. It previously joined the per-aspect summaries, which is not the text Amazon shows. Per-aspect summaries are unchanged in `customersSay.aspects`. Also fixed: products whose Top reviews Amazon hid behind a sign-in prompt silently returned none; the Actor now retries those with a fresh session. Photo and video reviews no longer go missing on product pages where Amazon loads the media gallery only on scroll. Binary error responses from Amazon are now retried instead of failing the product. Billing docs corrected: every output row (including the per-product summary row) is billed as one result; earlier versions of this README wrongly said summary rows were free.

**0.3 (June 2026)** — added Amazon's **"Customers say" AI summary + aspect-sentiment** breakdown (on the per-ASIN summary record), and review **filtering & sorting** (`reviewStars`, `verifiedOnly`, `mediaOnly`, `sortReviewsBy`). New review fields: `vineReview`, `variantAsin`, `reviewerId`, plus author/verified recovered on media reviews.

**0.2 (June 2026)** — added customer **image & video reviews** from the product media gallery (`amazon.com`), lifting per-product volume from ~13 to dozens/hundreds for popular items. New fields: `images`, `mediaType`, `language`. New input: `includeMediaReviews`.

**0.1 (June 2026)** — initial release: ASIN / product-URL / keyword lookup, product-page review extraction, per-ASIN ratings histogram + totals, residential-proxy escalation, and pay-per-event pricing.

# Actor input Schema

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

Amazon Standard Identification Numbers (10-character product IDs, e.g. B07DF46NW9). Reviews are scraped for each ASIN.

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

Amazon product page URLs (any /dp/ or /gp/product/ link). The ASIN is extracted from each URL.

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

A search term. The Actor finds the top products for this keyword and scrapes their reviews. Use with 'Max products from search'.

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

When using a search keyword, how many of the top search-result products to scrape reviews for.

## `maxReviewsPerAsin` (type: `integer`):

Cap on reviews collected per ASIN. The Actor returns the product page's "Top reviews" plus all customer image/video reviews from the media gallery (on amazon.com this is often dozens to hundreds for popular products; few or none for products without customer photos). The ratings histogram and totals are always captured. Set 0 for no cap.

## `includeMediaReviews` (type: `boolean`):

Fetch the customer image/video reviews from the product's media gallery (amazon.com only; other marketplaces return Top reviews only). This is the main source of review volume. Turn off to return just the page's Top reviews, which is faster and cheaper.

## `reviewStars` (type: `array`):

Only return reviews with these star ratings. Leave empty to return all ratings. (Filters the reviews collected anonymously; it does not unlock additional login-gated reviews.)

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

Return only reviews marked "Verified Purchase".

## `mediaOnly` (type: `boolean`):

Return only reviews that include customer photos or video.

## `excludeReviewIds` (type: `array`):

Amazon review IDs to leave out, e.g. the reviewId values you collected in an earlier run (like RAE27YGS1JXJX; review permalinks work too). Excluded reviews aren't saved or billed and don't count toward 'Max reviews per ASIN', so the cap fills with other reviews. This draws on the same reviews the Actor can reach; it doesn't unlock more.

## `sortReviewsBy` (type: `string`):

Order of the returned reviews. "Amazon default" keeps the page's Top-reviews order followed by media-gallery reviews.

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

The Amazon marketplace to scrape. Bare ASINs and keyword searches use this domain; full product URLs keep their own domain. More marketplaces can be added on request.

## Actor input object example

```json
{
  "asins": [
    "B07CMS5Q6P"
  ],
  "keyword": "wireless earbuds",
  "maxProducts": 5,
  "maxReviewsPerAsin": 100,
  "includeMediaReviews": true,
  "reviewStars": [],
  "verifiedOnly": false,
  "mediaOnly": false,
  "sortReviewsBy": "default",
  "domain": "amazon.com"
}
```

# Actor output Schema

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

No description

## `reviews` (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 = {
    "asins": [
        "B07CMS5Q6P"
    ]
};

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

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

```

## MCP server setup

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