# Amazon Review Monitoring API - Track New Reviews (`vonsensey/amazon-review-monitoring-scraper-api`) Actor

Monitor Amazon reviews on any ASIN and catch new ones every day. Charged once per review ever, so a daily schedule never re-bills you for reviews you already have. Star histogram, verified badge, images and 24 marketplaces included. No start fee, and failures are free.

- **URL**: https://apify.com/vonsensey/amazon-review-monitoring-scraper-api.md
- **Developed by:** [Blackcube Agency AB](https://apify.com/vonsensey) (community)
- **Categories:** E-commerce, Marketing, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 Review Monitoring API — track new reviews on any ASIN

**Built for repeat runs. You are charged once per review, ever — not once per run.** Poll your products every day and you pay for each review the first time you see it and never again.

Watch your own listings or a competitor's. Every run returns the current published reviews for each ASIN, and flags which ones you have already been billed for, so "what changed since yesterday" is a single filter.

Unofficial tool. Not affiliated with, endorsed by, or connected to Amazon.com, Inc.

***

### Why monitoring is priced differently here

Most review scrapers charge you the full price again on every run. If you check 50 products daily, you re-buy the same reviews 30 times a month.

This one remembers. **Charge once per review, ever** is on by default:

- Run 1 on a product: returns its reviews, charges for them.
- Run 2, 3, 4…: returns the **same complete review set** so your data is never partial, but the reviews you already paid for come back **free**, flagged `alreadyPaidForInPreviousRun: true`.
- You are only ever billed for reviews that are new to you.

Verified on the platform, not just claimed: two identical back-to-back runs on one ASIN charged **8** and then **0**, with all 8 rows delivered both times.

That means a daily schedule over 50 products costs roughly one full pull, plus whatever genuinely new reviews arrive.

### How to monitor Amazon reviews for your own ASINs

Paste your ASINs and run it on a schedule:

```json
{
  "products": ["B07PXGQC1Q", "B09B8V1LZ3", "B0CWXNS552"]
}
```

Then in Apify: **Schedules → Create schedule → daily**. Nothing else to configure — repeat-run billing is already on.

To get only what arrived since yesterday, filter the output on `alreadyPaidForInPreviousRun == false`.

### How to get alerted about new negative Amazon reviews

Pull only the ratings you care about. Filters run on our side and are **free** — you are never billed for a review a filter removes:

```json
{
  "products": ["B07PXGQC1Q"],
  "filterByStars": ["1", "2"],
  "reviewsNewerThan": "7 days"
}
```

Pair it with an Apify **monitoring alert** on *Number of results is greater than 0* and you get an email the moment a new 1- or 2-star review appears on a product you watch.

### How to track a competitor's Amazon reviews

Exactly the same — competitors' ASINs are public. Paste theirs instead of yours:

```json
{
  "products": ["https://www.amazon.com/dp/B0BDHWDR12"],
  "reviewsNewerThan": "30 days"
}
```

The free product row that comes with each run also carries their **full star histogram**, average rating and total rating count, so you can watch a competitor's rating distribution move over time, not just read their latest reviews.

### How to monitor an Amazon product across several countries

Amazon publishes a **different set of reviews on each marketplace**. Add the ones your product sells in and you catch problems that never surface on `amazon.com`:

```json
{
  "products": ["B07PXGQC1Q"],
  "marketplaces": ["amazon.com", "amazon.co.uk", "amazon.de", "amazon.ca"]
}
```

Measured across 44 marketplace pairs on 11 products: **zero overlap in any pair** — every marketplace you add is genuinely new reviews, never repeats. Duplicates are removed by review ID and never charged twice.

### What you get for every review

| Field | Coverage (244-review benchmark) |
|---|---|
| `reviewId`, `rating`, `title`, `body` | 100% |
| `reviewedAt` (ISO date) + `reviewedAtRaw` | 100% |
| `marketplace`, `countryCode`, `reviewUrl` | 100% |
| `verifiedPurchase` | 98.0% |
| `helpfulVotes` | 53.7% |
| `variant` (which colour/size was reviewed) | 47.1% |
| `images` (full resolution) | 20.1% |
| `alreadyPaidForInPreviousRun` | every row — your "have I seen this?" flag |

Dates are real ISO dates on every marketplace, including the ones Amazon writes in German, Italian, Spanish, French and Portuguese. A date that genuinely cannot be read comes back `null` with the original text kept — a guessed date would quietly corrupt a date filter, so this Actor never guesses one.

### How many reviews exist to monitor

Be realistic about the ceiling: Amazon publishes roughly **8–13 reviews per product per marketplace** on its public pages, and every review-specific page now requires a login. No public tool exceeds that, and any listing promising "all 2,000 reviews" is describing something that no longer exists.

For monitoring this matters far less than it sounds — the published set is the **most recent** activity, which is exactly what a monitoring job needs. And adding marketplaces multiplies it: mean **22.2 unique reviews per product** across 8 marketplaces.

### What it costs

Charged **per review returned**, and nothing else.

- **No start fee.**
- **Failures are free** — blocked pages, products not listed in a marketplace, products with no reviews, and invalid inputs all return an explanatory row and cost nothing.
- **Filtered-out reviews are free.**
- **Duplicates are free.**
- **Previously-paid reviews are free, forever.**

Set **Maximum reviews** for a hard cap on any run's bill. It is exact.

### Every input either returns reviews or tells you why not

No silent gaps. Anything that produces no reviews produces a row with a stable `reason` you can filter on: `not-listed-in-marketplace`, `no-reviews-published`, `blocked-by-amazon`, `reviews-section-missing`, `invalid-input`, `fetch-failed`, `skipped-run-limit-reached`.

`reviews-section-missing` is worth knowing about: Amazon occasionally serves a product page with its reviews section absent entirely. This Actor retries from a different route and, if it still cannot see the section, says so — rather than reporting "no reviews" for a product that has thousands. For a monitoring feed that distinction is the difference between a real signal and a false alarm. Each run also writes a `RUN_REPORT` with the counts.

This matters most for monitoring: a product that quietly stops returning data is a signal in itself, and you will see it as a row rather than as an unexplained gap in your dashboard.

### Personal data and GDPR

Reviewer names, profile IDs and profile URLs are personal data and are **off by default**. Everything else — rating, text, dates, badges, votes, images — is returned either way. Only enable them if you have a lawful basis. This Actor reads only what Amazon publishes publicly; it never logs in and never touches anything behind a sign-in wall.

### Proxy

Required and on by default — Amazon serves a CAPTCHA to unproxied cloud IPs. The default works and you do not need to buy a residential proxy add-on.

### Related

Need the full picture rather than a monitoring feed? Use **Amazon Product Reviews Scraper API** for one-off pulls, or **Amazon Ratings Scraper API** for star ratings and histograms in bulk.

***

*Unofficial tool. Not affiliated with, endorsed by, or connected to Amazon.com, Inc. "Amazon" is a trademark of Amazon.com, Inc., used here only to describe what this tool reads. Publicly available data only.*

# Actor input Schema

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

One per line. Accepts a bare ASIN (B07PXGQC1Q) or any Amazon product URL pasted from your browser. If you paste a marketplace URL such as amazon.co.uk, that marketplace is used — your link is never silently redirected to amazon.com.

## `marketplaces` (type: `array`):

Amazon publishes a DIFFERENT set of reviews on each marketplace, so adding marketplaces adds genuinely new reviews rather than repeats. Measured on a test ASIN: 8 reviews on amazon.com alone, 36 unique across five marketplaces. Leave as 'Same marketplace as the product' to fetch only one page per product. Duplicates are removed automatically and you are never charged twice for the same review.

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

Hard cap on billable reviews for the entire run. 0 means no cap. Amazon publishes roughly 8 reviews per product per marketplace, so a run is naturally small: 20 products on one marketplace is about 160 reviews.

## `filterByStars` (type: `array`):

Leave empty for all ratings. Amazon no longer honours star filters on the public product page, so this is applied to the reviews after we fetch them — which means you are only ever charged for the reviews you actually keep.

## `onlyVerifiedPurchases` (type: `boolean`):

Return only reviews carrying Amazon's Verified Purchase badge.

## `reviewsNewerThan` (type: `string`):

A date (2026-01-15) or a relative period (30 days, 6 months, 1 year). Left empty, all dates are returned. Reviews whose date could not be read in the marketplace's language are excluded when you set this, rather than being guessed at.

## `includeProductSummary` (type: `boolean`):

Adds one free row per product per marketplace with the average rating, the total number of ratings, and the full 1-5 star histogram. The histogram covers EVERY rating on the listing, not just the reviews returned, which is what makes sentiment work on products with hundreds of thousands of ratings. Always free.

## `onlyChargeNewReviews` (type: `boolean`):

On by default, because this Actor is built for repeat runs. Reviews you were already charged for in an earlier run are still returned in full, but free, and flagged alreadyPaidForInPreviousRun. Filter on that flag to get only what is new since your last run. Turn it off if you want every run billed independently.

## `includePersonalData` (type: `boolean`):

Reviewer name, profile ID and profile URL are personal data under GDPR and similar laws. Off by default. Only turn this on if you have a lawful basis for processing it.

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

Required. Amazon serves a CAPTCHA to unproxied cloud IP addresses, so a run without a proxy returns no reviews. The default works and no residential proxy is needed.

## Actor input object example

```json
{
  "products": [
    "B07PXGQC1Q"
  ],
  "marketplaces": [
    "auto"
  ],
  "maxReviews": 200,
  "filterByStars": [],
  "onlyVerifiedPurchases": false,
  "reviewsNewerThan": "",
  "includeProductSummary": true,
  "onlyChargeNewReviews": true,
  "includePersonalData": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `csv` (type: `string`):

No description

## `runReport` (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": [
        "B07PXGQC1Q"
    ],
    "marketplaces": [
        "auto"
    ],
    "maxReviews": 200,
    "onlyChargeNewReviews": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("vonsensey/amazon-review-monitoring-scraper-api").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": ["B07PXGQC1Q"],
    "marketplaces": ["auto"],
    "maxReviews": 200,
    "onlyChargeNewReviews": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("vonsensey/amazon-review-monitoring-scraper-api").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": [
    "B07PXGQC1Q"
  ],
  "marketplaces": [
    "auto"
  ],
  "maxReviews": 200,
  "onlyChargeNewReviews": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call vonsensey/amazon-review-monitoring-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

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/4fqzf9nb6ZCgB8ybP/builds/XV7uzJQZEmrUXiGYV/openapi.json