# Amazon Reviews Scraper (US): Export & Monitor Reviews (`stanvanrooy6/amazon-review-scraper-us`) Actor

Scrape Amazon.com reviews with no login. Filter by star rating, date and verified purchase, get up to about 1,000 reviews per product including photo and video reviews, and export CSV, JSON or Excel. Schedule it to get only new reviews.

- **URL**: https://apify.com/stanvanrooy6/amazon-review-scraper-us.md
- **Developed by:** [Stan Van Rooy](https://apify.com/stanvanrooy6) (community)
- **Categories:** E-commerce, Marketing, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 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.
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 (US): Export & Monitor Reviews ⭐

**Free-plan sample:** Apify Free accounts can collect up to **100 result rows total per run**, shared across all inputs. Upgrade your [Apify plan](https://console.apify.com/billing/subscription) for larger runs. Normal Actor charges apply. The sample resets each run; it is not a daily or monthly quota.

The Amazon Reviews Scraper exports **Amazon.com product reviews to CSV, JSON or Excel** with **no Amazon login, no cookies and no API key**. Extract clean, structured review rows with 1 to 5 star ratings, review headlines, full text, dates, verified purchase status, helpful votes, and reviewer photo and video URLs.

Built with an automated **incremental review monitor**: schedule runs on Apify using a `collectionId` to track customer sentiment over time. The engine automatically deduplicates against past runs and only delivers newly posted reviews. Easily monitor negative reviews (1 and 2 stars) on your own products or competing brands to spot product defects, quality issues, and customer complaints as soon as they appear.

Built for brand protection, Amazon FBA sellers, product engineering teams, market research, and LLM sentiment analysis.

### 💎 Scraper Capabilities and Features

| Feature | Verified Capability | Technical Notes |
|---|---|---|
| **Extraction Depth** | **Up to ~1,000 reviews per product** | Combines public Woot review feed (up to 100/star) with product-page media reviews |
| **Media Extraction** | **Customer photos and video URLs** | Full resolution images and video streams attached to customer reviews |
| **Precision Filtering** | **Keywords, media, helpful votes, Vine exclusion** | Filter by required/excluded words, media presence, helpfulness, and Vine status |
| **Automated Monitoring** | **Stateful deduplication via `collectionId`** | Remembers delivered reviews across runs; schedule to collect only new reviews |
| **Authentication & Safety** | **100% Anonymous** | No customer Amazon login, cookies, or external API keys required |
| **Strict Data Schema** | **Standardized JSON, CSV, and Excel** | Validated star ratings (1-5), ISO dates, review country, verified purchase flag |
| **Run Diagnostics** | **Detailed `SUMMARY` and `OUTCOMES` records** | Explicit accounting of fetched counts, deduplication, and stoppage reasons |
| **Transparent Billing** | **Pay only for delivered reviews** | Pay-per-result model; runs with zero new reviews charge zero review events |

### 🚀 How to scrape Amazon reviews

1. Paste one or more Amazon.com product URLs or ASINs (up to 50 per run).
2. Choose how many reviews you want per product and, if you like, which star ratings (for example `[1, 2]` for negative reviews).
3. Click **Start**, then download the results as CSV, JSON or Excel.

Try it with 10 reviews on one product first to see what the data looks like.

### 📏 How many reviews do you get?

Amazon hides most reviews from visitors who are not logged in, so no login free scraper can promise every review on a product. This scraper combines two public sources and removes duplicates between them:

- The Amazon.com review feed that Amazon publishes on Woot (an Amazon company). It shows up to 100 reviews per list, with one list for each star rating and sort order.
- The photo and video reviews on the Amazon product page: every review where the customer added a photo or video. On popular products that is often several hundred reviews.

| Setting | Reviews per product |
|---|---|
| **Newest reviews** (default) | Up to 100 of the newest reviews |
| **Newest reviews** with star ratings, for example `[1, 2]` | Up to 100 of the newest reviews for each star you pick, so up to 200 for 1 and 2 stars |
| **Maximum coverage** | The newest and the most helpful reviews for every star, plus all photo and video reviews, duplicates removed: often 500 to 1,000 |

In September 2026 tests on Apify, Maximum coverage returned **1,036, 999 and 749 unique reviews** for three popular products, with the oldest going back to 2023. Before photo and video reviews were added, the same products gave about 650, 650 and 595. Products with fewer reviews return fewer.

Amazon shows the photo and video reviews on most products (9 of 10 in our test batch). When it does not, the product still returns its regular reviews and the run report says so.

Maximum coverage reads every star rating separately, so 1 star reviews can make up as much of the result as 5 star reviews. That is great for reading complaints and praise side by side, but it is not a random sample, so do not use it to calculate a product's average rating.

### 🔔 Monitor new Amazon reviews

Add a `collectionId` to your input and schedule the run (daily, weekly, whatever you need) in Apify. The scraper remembers every review it has delivered for that collection and skips them next time. You are only charged for new reviews, so a run with nothing new costs nothing for reviews.

Example: watch two products for new verified 1 and 2 star reviews.

```json
{
  "products": [
    "https://www.amazon.com/dp/B0BN7M8CH4",
    "B0CP9YB3Q4"
  ],
  "ratings": [1, 2],
  "verifiedOnly": true,
  "mode": "expanded",
  "maxReviewsPerProduct": 200,
  "collectionId": "my-negative-reviews"
}
```

Good to know:

- Use one collection ID per watch list. A new collection ID starts with a clean history.
- Let each run finish before the next one starts. If two runs use the same collection at the same time, the second one stops with a clear message.
- A collection remembers up to 200,000 reviews.
- Want alerts? Connect the run to Apify integrations (Slack, email, Zapier, Make or a webhook) so new reviews reach you as soon as the run finishes.
- Already have results from earlier runs? Pass their `review_id` values in `knownReviewIds` to skip them without a collection.

### 📊 What data can you scrape from Amazon reviews?

- Star rating (1 to 5), review title and full review text
- Review date, plus the country the review was written in
- Verified purchase and Vine review flags
- Helpful vote count (Woot feed reviews)
- Photo and video URLs attached to the review
- Reviewer name (optional, off by default)
- ASIN, Amazon product URL and a stable `review_id` for each review, plus Amazon's own review ID for photo and video reviews

### 📥 Input

| Field | Type | Notes |
|---|---|---|
| `products` | array | Amazon.com product URLs or 10 character ASINs, 1 to 50 per run. **Required.** |
| `maxReviewsPerProduct` | integer | Most new reviews to collect per product, 1 to 3,000. Default `100`. |
| `mode` | string | `recent` for the newest reviews, `expanded` for Maximum coverage. Default `recent`. |
| `includePhotoVideoReviews` | boolean | In Maximum coverage, also read the photo and video reviews from the product page. Default `true`. |
| `ratings` | array | Star ratings to keep, for example `[1, 2]`. Empty means all stars. |
| `verifiedOnly` | boolean | Only verified purchase reviews. Default `false`. |
| `excludeVine` | boolean | Exclude Amazon Vine Voice incentivized reviews. Default `false`. |
| `keywords` | array | Literal words or phrases that must appear in the review text or title. |
| `excludeKeywords` | array | Literal words or phrases to exclude from results. |
| `keywordMatch` | string | Require `any` (default) or `all` inclusion keywords to match. |
| `mediaType` | string | Filter reviews by media: `all` (default), `any`, `images`, `videos`, or `none`. |
| `minHelpfulVotes` | integer | Minimum helpful votes a review must have received. Default `0`. |
| `dateFrom`, `dateTo` | string | Keep reviews from this date range (`YYYY-MM-DD`, both days included). |
| `collectionId` | string | Name of a watch list for monitoring. Each run skips reviews already delivered to it. |
| `knownReviewIds` | array | `review_id` values from earlier results to skip, up to 10,000. |
| `includeAuthor` | boolean | Add the reviewer's public name. Default `false`. |
| `failOnPartial` | boolean | Mark the run as failed when a product could not be read correctly. Collected reviews are always kept. Default `true`. |

The input form also has advanced settings for speed, time limits and proxy use. The defaults work for most runs.

**Basic input:**

```json
{
  "products": ["B0BN7M8CH4"],
  "maxReviewsPerProduct": 100
}
```

**Advanced keyword and media filtering:**

```json
{
  "products": ["B0BN7M8CH4"],
  "mode": "expanded",
  "keywords": ["battery", "charging"],
  "excludeKeywords": ["gift"],
  "mediaType": "any",
  "minHelpfulVotes": 2,
  "excludeVine": true,
  "maxReviewsPerProduct": 100
}
```

### 📤 Output

One row per review. A real row from a September 2026 run:

```json
{
  "review_id": "amz-us-0e7f7b5f02f489828a5439089bc2ffb428a968e0cb4cafae470b593a3be48692",
  "asin": "B0BN7M8CH4",
  "marketplace": "amazon.com",
  "rating": 1,
  "title": "FIRE HAZARD!",
  "body": "DO NOT BUY UNLESS YOU WANT TO BURN YOUR PLACE DOWN!!! We bought these and liked how powerful they are to froth our milk. We've had it less than a month and the charging port melted while charging...",
  "published_date": "2026-09-11",
  "published_date_raw": "Reviewed in the United States on September 11, 2026",
  "review_origin_country": "the United States",
  "verified_purchase": true,
  "vine_review": false,
  "helpful_votes": 2,
  "images": ["https://m.media-amazon.com/images/I/615vz1la93L.jpg"],
  "videos": [],
  "author": null,
  "product_url": "https://www.amazon.com/dp/B0BN7M8CH4",
  "source": "woot_amazon_us_reviews",
  "source_url": "https://www.woot.com/review/Reviews/B0BN7M8CH4?filter=0&sort=1&isVerified=false&page=1",
  "scraped_at": "2026-09-26T20:29:19.966377+00:00"
}
```

#### Field descriptions

- `review_id`: Stable ID for the review. See below.
- `asin`, `product_url`: The product you asked for.
- `rating`: Star rating from 1 to 5.
- `title`, `body`: Review headline and full review text.
- `published_date`: Review date as `YYYY-MM-DD`.
- `published_date_raw`, `review_origin_country`: The date line exactly as Amazon shows it, and the country it names.
- `verified_purchase`, `vine_review`: Amazon's Verified Purchase and Vine flags.
- `helpful_votes`: How many people found the review helpful.
- `images`, `videos`: Media the reviewer attached.
- `author`: Reviewer's public name when `includeAuthor` is on, otherwise `null`.
- `source`, `source_url`: Where the review was read from.
- `scraped_at`: When the review was collected (UTC).

Reviews from the product page's photo and video list have `source` set to `amazon_product_page_media`, Amazon's own review ID in `amazon_review_id`, and no helpful vote count. Rows also include `id_type`, `date_status` and `schema_version` for pipelines that need them.

**About `review_id`:** the Woot feed does not include Amazon's own review IDs, so the scraper builds a stable ID from the review's content for every row. The same review always gets the same ID, which is what makes deduplication and monitoring work. Use it as the key when you load reviews into your own database. If a reviewer edits their review, it gets a new ID.

#### Run report

Every run also saves a report in the **Output** tab: `SUMMARY` for the whole run and `OUTCOMES` for each product. For every product you see how many reviews were delivered, the date range they cover, and why collection stopped:

| `coverage_status` | Meaning |
|---|---|
| `limit_reached` | You got the number of reviews you asked for. |
| `source_limited` | The feed had nothing more to give. This is the normal end for products with many reviews. |
| `available_feed_exhausted` | Every review in the feed for this product was read. |
| `page_budget_reached` | The page limit in the advanced settings stopped collection. |
| `budget_reached` | The run hit the maximum charge you set. |
| `incomplete` | Stopped early because the source slowed the scraper down or a time limit was reached. Run again later or resurrect the run to continue. |
| `unavailable` | The source did not answer for this product, so nothing was collected. |
| `partial_error` | Some reviews were collected, but part of the product could not be read correctly. |
| `extraction_failed` | The product could not be read correctly at all. |

Each product also has a `media` section showing whether its photo and video reviews were collected, and why not if they were not.

### ✨ Why this Amazon review scraper

- **No login, no cookies, no API key.** You never hand over an Amazon account.
- **Up to about 1,000 reviews per product.** Maximum coverage combines the newest and most helpful reviews for every star with every photo and video review, well beyond the handful of reviews on a product page.
- **Built in monitoring.** Reuse a collection ID and each run returns only new reviews.
- **Pay only for new reviews.** Duplicates across lists, reviews from earlier runs and IDs you already have are skipped for free.
- **Filters that matter.** Star ratings, verified purchases and date range.
- **Checked data.** Every row has a valid 1 to 5 star rating and a real review date. Reviews that cannot be read cleanly are left out and counted in the run report instead.
- **Clear reports.** Each product tells you how many reviews it delivered and why it stopped, so an empty result is never a mystery.
- **Safe to resume.** If a run is interrupted, resurrect it in Apify and it continues where it left off without delivering or charging for the same review twice.
- **Fast where it counts.** The newest 100 reviews of a product arrive in under 10 seconds.

### 💡 Use cases

- **Brand and seller monitoring:** Catch new negative reviews on your listings and respond quickly.
- **Competitor research:** See what buyers praise and complain about in competing products.
- **Product development:** Mine complaints and feature requests before your next version.
- **Review analysis and AI:** Feed clean, labelled reviews into sentiment analysis, topic models or an LLM summary.
- **Marketing copy:** Borrow the words real customers use in ads and product pages.

### 🔌 Amazon reviews API: run it from code

Every Apify Actor is also an API. Call the scraper from Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("stanvanrooy6/amazon-review-scraper-us").call(run_input={
    "products": ["B0BN7M8CH4"],
    "mode": "expanded",
    "maxReviewsPerProduct": 500,
})
for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["rating"], review["published_date"], review["title"])
```

Or with cURL, getting the reviews back in one request:

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/stanvanrooy6~amazon-review-scraper-us/run-sync-get-dataset-items?format=json' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"products": ["B0BN7M8CH4"], "maxReviewsPerProduct": 10}'
```

See the **API** tab above for JavaScript and more ready made snippets. This is the Apify API, not an official Amazon API.

### ⚠️ Limits and good to know

- **Amazon.com (US) only.** Links from amazon.co.uk, amazon.de and other marketplaces are rejected with a clear message. Some Amazon.com reviews were written in other countries; `review_origin_country` tells you which.
- **Not every review on big products.** See **How many reviews do you get?** above.
- **Variants share reviews.** Amazon groups reviews across colors and sizes, so you cannot filter by one exact variant.
- **Date filters do not reach further back.** They filter the reviews the feed returns. They do not unlock older ones.
- **Maximum coverage takes time.** The scraper paces its requests so the sources keep answering, which works out to about 40 seconds per product. In our tests 10 products took about 5.5 minutes and 43 products about 29 minutes; the default run time limit (60 minutes) fits a full batch of 50.
- **Output is not sorted.** Reviews arrive as they are collected. Sort by `published_date` in your export.
- **An empty result is not proof of zero reviews.** A product can have reviews on Amazon that the feed does not show. The run report tells you what happened.
- **Slowdowns do not fail the run.** If the source slows the scraper down, the affected products are reported as `incomplete` and the run still succeeds with everything collected. A product that cannot be read correctly (for example after a format change) marks the run as failed by default, and every review already collected is kept. Set `failOnPartial` to `false` to let it succeed anyway.

### 💰 Pricing

This Actor uses **pay per event**: no subscription, you pay for the reviews you get.

- **Reviews:** $2.00 per 1,000 new reviews ($0.002 each). $1.80 per 1,000 on the Apify Silver plan and $1.60 on Gold and higher.

Skipped duplicates, reviews from earlier runs in a collection and the run report are free, so a scheduled run that finds no new reviews is not charged for any. Collecting 500 reviews costs $1. Set a maximum charge per run in Apify and the scraper stops cleanly when it reaches it. New Apify accounts include monthly free usage credit, which is enough to try the scraper at no cost.

### ❓ FAQ

#### Can I scrape all reviews of an Amazon product?

Not on products with thousands of reviews. Amazon only shows its full review history to logged in shoppers. Without a login this scraper gets up to about 1,000 reviews per product with Maximum coverage, and the run report tells you exactly how many it found.

#### Is there a free Amazon review scraper?

You can run this one for free within the monthly free usage credit that comes with every Apify account. After that it is $2.00 per 1,000 reviews with no subscription.

#### Do I need an Amazon account or login?

No. The scraper runs without any Amazon account, cookies or API key.

#### How do I export Amazon reviews to CSV or Excel?

Run the scraper, open the **Output** tab and download the dataset as CSV, Excel, JSON or XML. You can also read it straight from the Apify API.

#### Can I get only negative reviews?

Yes. Set `ratings` to `[1, 2]`. Add `verifiedOnly: true` to keep only verified purchases.

#### How do I get alerts for new Amazon reviews?

Create a task with a `collectionId`, schedule it in Apify, and connect it to an integration such as Slack, email, Zapier, Make or a webhook. Each run delivers only the reviews you have not seen yet.

#### Does it work for Amazon UK, Germany or other countries?

No, only Amazon.com (US) products are supported for now.

#### Why did my run return zero reviews?

The feed may have no reviews for that product, your star or date filters may have excluded all of them, or every review was already in your collection. The run report (`SUMMARY`) tells you which one it was.

#### Are these Amazon's own review IDs?

`review_id` is a stable ID built from the review's content, the same across runs and sources, so use it to deduplicate. Reviews from the photo and video list also carry Amazon's own review ID in `amazon_review_id`; the Woot feed does not include it.

#### Is it legal to scrape Amazon reviews?

The scraper only collects publicly visible reviews, without logging in or bypassing access controls. Reviewer names are off by default. Reviews can still contain personal data, so handle them in line with GDPR, CCPA and your own use case. If you are unsure, consult a lawyer.

#### Is this Actor made by Amazon?

No. It is an independent tool and is not affiliated with Amazon or Woot.

### 🤝 Feedback and feature requests

I actively maintain this Actor. Found a bug or need a field? Open an issue on the Issues tab with the run ID and the ASIN.

### 🔗 Related review scrapers

- **[TikTok Shop Scraper](https://apify.com/stanvanrooy6/tiktok-shop-scraper)**: TikTok Shop reviews, star ratings and product data from any product URL, up to 25,000 reviews per product.
- **[Universal Shopify Review Scraper](https://apify.com/stanvanrooy6/shopify-review-scraper)**: detects the review app (Judge.me, Loox, Yotpo, Okendo, Stamped and more) on any Shopify store and extracts all reviews.

***

Built with ❤️ for the Apify community

### Select reviews by content and media

Use `keywords` to keep reviews whose title or body contains any supplied word or phrase. Set `keywordMatch` to `all` to require every phrase. `excludeKeywords` removes reviews containing any excluded phrase. Matching is case-insensitive and supports Unicode text; phrases are literal substrings, not regular expressions.

`mediaType` accepts `all`, `any` (photos or videos), `images`, `videos`, or `none`. For broader media coverage, use `mode: "expanded"` with `includePhotoVideoReviews: true`. `minHelpfulVotes` keeps reviews at or above a helpful-vote threshold; zero disables it. When positive, reviews without a helpful-vote count are excluded, including the Amazon product-page media source. `excludeVine` excludes reviews explicitly marked as Vine reviews.

All filters combine with ratings, verified purchase and date controls. Only matching new reviews are delivered and charged. The scraper continues through available pages after excluded reviews, subject to source, page and time limits. Keywords filter the retrieved sample; they do not search Amazon's entire review history or add other marketplaces. A filtered run can correctly return no reviews. The coverage report includes `filtered_observations`, which counts observations across overlapping source lists, not distinct reviews.

```json
{
  "products": ["B0BN7M8CH4"],
  "mode": "expanded",
  "maxReviewsPerProduct": 50,
  "keywords": ["battery", "sound"],
  "keywordMatch": "any",
  "excludeKeywords": ["replacement"],
  "mediaType": "any",
  "excludeVine": true
}
```

# Actor input Schema

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

Amazon.com product URLs or 10 character ASINs, 1 to 50 per run. Other Amazon marketplaces are not supported.

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

Most new reviews to collect for each product (up to 3,000). You only pay for reviews delivered. Small products may have fewer.

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

Newest reviews: up to 100 of the latest reviews, or up to 100 per star if you pick star ratings. Maximum coverage: the newest and most helpful reviews for every star plus the photo and video reviews from the product page, duplicates removed, often 500 to 1,000 per product.

## `includePhotoVideoReviews` (type: `boolean`):

Maximum coverage mode only. Also reads the reviews with customer photos and videos from the Amazon product page, which adds hundreds of reviews on many products. When Amazon does not show them for a product, you still get its regular reviews.

## `ratings` (type: `array`):

Only keep these star ratings, for example \[1, 2] for negative reviews. Leave empty for all stars.

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

Only keep reviews with Amazon's Verified Purchase badge.

## `dateFrom` (type: `string`):

Only keep reviews on or after this date (YYYY-MM-DD).

## `dateTo` (type: `string`):

Only keep reviews on or before this date (YYYY-MM-DD).

## `collectionId` (type: `string`):

Name for a watch list, for example my-products. Every run with the same name skips reviews it already delivered, so scheduled runs return only new reviews. Leave empty for a one off scrape.

## `knownReviewIds` (type: `array`):

review\_id values from earlier results to leave out of this run (up to 10,000).

## `includeAuthor` (type: `boolean`):

Add the reviewer's public name to each review. Off by default.

## `failOnPartial` (type: `boolean`):

When a product cannot be read correctly (for example the source changed its format), mark the run as failed. Collected reviews are always kept. Products that stopped early because the source slowed down are reported as incomplete and do not fail the run.

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

How many pages to load at the same time. The default works for most runs.

## `maxPagesPerPartition` (type: `integer`):

Each star and sort list has up to 10 pages of 10 reviews. Lower this to read fewer pages.

## `productTimeoutSeconds` (type: `integer`):

Stop collecting a product after it has been running this long. Reviews already collected are kept.

## `maxRuntimeSeconds` (type: `integer`):

Stop collecting after this long. Reviews already collected are kept. Keep the run timeout in Run options longer than this.

## `proxyMode` (type: `string`):

Auto connects directly and switches to an Apify US residential proxy if a request fails. Direct never uses a proxy. Residential always uses one and needs residential proxy access.

## `keywords` (type: `array`):

Keep retrieved content containing these literal words or phrases, case-insensitive. This filters retrieved content; it does not extend source coverage.

## `excludeKeywords` (type: `array`):

Exclude content containing any of these literal words or phrases, case-insensitive.

## `keywordMatch` (type: `string`):

Require any or all inclusion keywords. Exclusions always take precedence.

## `mediaType` (type: `string`):

Keep all reviews, reviews with any media, images, videos, or no media. Applies to the retrieved sample before charging. Use Maximum coverage with photo and video reviews enabled for broader media coverage.

## `minHelpfulVotes` (type: `integer`):

Keep reviews with at least this many helpful votes. Zero disables this filter. Reviews without a vote count, including product-page media reviews, are excluded when this is positive.

## `excludeVine` (type: `boolean`):

Exclude reviews marked as Vine reviews by the source.

## Actor input object example

```json
{
  "products": [
    "B0BN7M8CH4"
  ],
  "maxReviewsPerProduct": 100,
  "mode": "recent",
  "includePhotoVideoReviews": true,
  "ratings": [],
  "verifiedOnly": false,
  "includeAuthor": false,
  "failOnPartial": true,
  "maxConcurrency": 4,
  "maxPagesPerPartition": 10,
  "productTimeoutSeconds": 900,
  "maxRuntimeSeconds": 3600,
  "proxyMode": "auto",
  "keywordMatch": "any",
  "mediaType": "all",
  "minHelpfulVotes": 0,
  "excludeVine": false
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

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

No description

## `outcomes` (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": [
        "B0BN7M8CH4"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("stanvanrooy6/amazon-review-scraper-us").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": ["B0BN7M8CH4"] }

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

```

## MCP server setup

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

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/2ab9KOvkT31fdeDza/builds/nqajCuOQbcn6QQo3g/openapi.json