# Amazon Product Feedback Analyzer (`zapticx/amazon-product-feedback-analyzer`) Actor

Analyze Amazon product feedback from what Amazon shows logged-out visitors: up to 13 top reviews per product per store, the star histogram, Amazon's 'Customers say' aspects when Amazon shows them, and themes from the collected English reviews with their sample size. 23 marketplaces.

- **URL**: https://apify.com/zapticx/amazon-product-feedback-analyzer.md
- **Developed by:** [Zapticx](https://apify.com/zapticx) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 review delivereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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 Product Feedback Analyzer

Paste Amazon product links and get a structured feedback report for each product:

- the top reviews Amazon shows on the product page, as one row per review,
- Amazon's own rating data for the product (average, "global ratings" count, % per star),
- Amazon's **"Customers say"** summary and aspects, **when Amazon shows them**,
- feedback themes computed from the collected English reviews, each with its sample size
  (for example "Texture & feel: 5 of 12 English reviews").

Works on **23 Amazon stores**: US, UK, Germany, Canada, India, Australia, Japan, France, Italy, Spain,
Mexico, Brazil, Netherlands, Sweden, Poland, Turkey, United Arab Emirates, Saudi Arabia, Singapore,
Belgium, Egypt, Ireland and South Africa.

### Read this first: how many reviews you get

This Actor reads what Amazon shows **logged-out visitors on the product page**. It never signs in,
never uses customer accounts or cookies, and never tries to get around Amazon's sign-in prompts.

- **One store gives at most 13 reviews per product.** The product page shows up to 8 top reviews from
  that store plus up to 5 from other countries. Amazon's full review pages (all reviews, star filters,
  sorting, more pages) require sign-in on all 23 stores, so this Actor cannot read them.
- **More stores can give more distinct reviews.** Each store shows its own top reviews, so checking
  the same product on other stores adds reviews that one store does not show. A product sold and
  reviewed in many countries can return 100 or more distinct reviews with every store checked; a
  product sold in a few stores returns far fewer.
- **It never collects every review of a product, or more than 13 from any one store.** If you need
  that, this is not the right tool.
- **The reviews are Amazon's choice, not a random sample.** In our tests the collected reviews often
  averaged a higher star rating than the product's overall rating. For the product-wide picture use
  Amazon's rating data and, when shown, "Customers say", which cover all of the product's ratings.

### Quick start: what to enter

| You want to… | Enter | Typical result |
|---|---|---|
| Read one product's feedback | A product link, e.g. `https://www.amazon.co.uk/dp/B001ETUD5I` | 1 product report + up to 13 reviews |
| Compare several products | Several links, one per line | 1 report + up to 13 reviews per product |
| Compare one product across chosen countries | A link, plus **Also check these marketplaces** (e.g. DE, CA, AU) | Up to 13 reviews per store, duplicates removed |
| Collect as many reviews as Amazon shows logged-out visitors | A link, plus **Check every supported Amazon store** | In our tests, from about 30 to about 200 distinct reviews, depending on where it's sold |

- A link's own domain decides its store: `amazon.co.uk` is UK, `amazon.de` is Germany, and so on. You can
  also enter a bare 10-character ASIN such as `B001ETUD5I`; it then uses the **Marketplace** field.
- **Max reviews per product** (default 300) caps review records per product across all stores
  checked. The default is above the most that 23 stores can show (23 × 13 = 299), so nothing is cut.
  If you set a lower limit and check several stores, the Actor stops checking further stores once the
  limit is reached: those stores are listed as `NOT_CHECKED` ("review limit reached") and are not
  charged. For example, every store with a limit of 13 fetches only the product's own store when it
  shows 13 reviews. Set it to 0 for Amazon's rating data only; every store you choose is then still
  checked and charged as a store page.
- A run can fetch up to **200 product pages** (products × stores checked). With every store checked,
  that is 8 products per run; split larger lists across runs.

Example input (one product in one store, plus one on every store):

```json
{
  "products": ["https://www.amazon.co.uk/dp/B001ETUD5I"],
  "includeFeedbackAnalysis": true
}
```

```json
{
  "products": ["https://www.amazon.com.au/dp/B0014BYHGC"],
  "allMarketplaces": true
}
```

### What you receive

Two tables, both in the run's **Output** tab:

**1. Product reports** – one row per product you entered, including products that failed, so every
input is accounted for. The overview columns are:

| Column | Example (Nizoral, amazon.co.uk) | Where it comes from |
|---|---|---|
| `outcome` | `OK` | This Actor (see **Outcomes** below) |
| `averageRating`, `ratingsCount` | 4.6, 31817 | Amazon, for all the product's "global ratings" |
| `reviewsDelivered` | 13 | Reviews in the Reviews table for this product |
| `amazonSummary`, `amazonAspects` | "Customers find this anti-dandruff shampoo effective…"; "Effectiveness \[positive]: 1680 positive, 260 negative; …" | Amazon's AI-generated "Customers say", reproduced as shown; empty when Amazon doesn't show it |
| `themeSampleSize` | 12 | English reviews our theme analysis used (1 of the 13 was Swedish) |
| `samplePositiveThemes`, `sampleComplaintThemes` | "Performance & effectiveness: 5 of 12 English reviews; Texture & feel: 5 of 12 English reviews; …" | This Actor, rule-based, no AI |

The **Full details** view of the same table adds the star histogram, "Customers say" aspects with
quoted snippets, each theme's review IDs and quotes, requested improvements, and `marketplaceCoverage`:
one entry per store checked, with its outcome, rating data, reviews visible / delivered / skipped as
duplicates, and `storePageCharged`.

**2. Reviews** – one row per review: review ID, star rating, title, full text, date, reviewer's
country, Verified Purchase flag, helpful votes, the variant bought, reviewer display name, photo URLs,
language, the store it was collected from, and the source URL. Rating, title, text, date, country and
reviewer name were present on every review in our tests; the rest appear when Amazon shows them.

#### Downloading results

- **Product reports (overview)** and **Reviews**: CSV, Excel or JSON all work.
- **Full details: download JSON.** Apify's CSV and Excel exports hold at most 2,000 columns. The
  details are nested, and a product checked on many stores needs more than that, so CSV and Excel
  files silently leave out the deepest fields (for example each store's "Customers say" aspects and
  some theme quotes). JSON preserves all fields delivered in the run's output. No export can include
  reviews Amazon did not show: the output holds only the top reviews visible on the pages checked.

Through the API, the Reviews table is the dataset listed as `reviews` in the run's storages.

### When to use "Check every supported Amazon store"

Turn it on when you want as many distinct reviews as Amazon shows logged-out visitors, or when the
product's own store gives few or none (for example when amazon.com asks visitors to sign in).
Results from our tests:

| Product (its own store) | Stores that sell it | Distinct reviews | Store pages charged | Price |
|---|---|---|---|---|
| Crocs kids' clog (AU) | 23 | 199 | 22 | $0.474 |
| celimax serum (UK) | 22 | 163 | 21 | $0.399 |
| eos body lotion (US, sign-in prompt on amazon.com) | 19 | 120 | 18 | $0.304 |
| Batana hair oil (AU) | 11 | 40 | 10 | $0.120 |
| Sea to Summit towel (UK), few reviews per store | 22 | 39 | 21 | $0.151 |
| New listing with no ratings (US) | – | 0 | 0 (22 stores `NOT_CHECKED`) | $0.010 |

Review counts vary a little from run to run, because Amazon's top-review selection changes.

How it works:

- The product's own store is checked first. If it shows no ratings, the other 22 stores are skipped,
  listed as `NOT_CHECKED` and not charged. Stores are also skipped this way once your **Max reviews per
  product** limit is reached. `NOT_CHECKED` means "not looked at", never "no reviews there", and
  `marketplacesSkippedReason` says why.
- Reviews are deduplicated by Amazon review ID, and each review keeps the store it came from. Stores
  often repeat the same "other countries" reviews, so some stores add few or no new reviews.
  `marketplaceCoverage` shows what each store added.
- Non-English stores mostly show reviews in their own language, so with many stores a large share of
  the reviews is not English (for example, 67 of the celimax serum's 163 were English). Themes use only
  the English ones; `themeSampleSize` tells you how many.
- Stores that don't sell the product (`NOT_FOUND`) cost nothing. A store that does show the product is
  charged as an additional store page, whether or not it adds new reviews (see **Pricing**).

For a product sold in only a few countries, choose those stores in **Also check these marketplaces**
instead: stores that don't sell it are free either way, but choosing them yourself keeps the run
focused on the countries you care about.

The Actor only fetches the ASIN you give it, and never merges different products or other variant
ASINs. Amazon itself shows reviews from a product's whole variation family on each product page; the
`variant` field on each review shows which variation the reviewer bought.

### Pricing

Pay per event; you pay only for what is delivered.

| Event | Price | When it's charged |
|---|---|---|
| Product report | $0.010 | Once per product whose page Amazon showed (`OK`, `GATED_SIGNIN` or `NO_REVIEWS`) |
| Review | $0.002 | Per review row delivered ($2.00 per 1,000) |
| Additional store page | $0.003 | Per extra store (beyond the product's own) whose page shows the product, when you use **Also check these marketplaces** or **Check every supported Amazon store** |

An additional store page is charged when that store shows the product, **even if it adds no new
reviews**: for example when the page asks visitors to sign in instead of showing reviews, when the
product has no written reviews there, or when all of that store's reviews were already collected from
another store. Stores often repeat each other's reviews, so with many stores checked, several charged
pages may add no new reviews. Each charged page's rating data and outcome appear in
`marketplaceCoverage` with `storePageCharged: true`.

Never charged: products or stores that end `NOT_FOUND`, `UNSUPPORTED_PAGE`, `BLOCKED`,
`INCOMPLETE_PAGE` or `NETWORK_ERROR`, invalid inputs, and `NOT_CHECKED` stores. Our feedback analysis
is included at no extra cost.

Worked examples from test runs:

- **One product, one store:** 13 reviews → $0.010 + 13 × $0.002 = **$0.036**.
- **A product on amazon.com that asks visitors to sign in:** rating data, no reviews → **$0.010**.
- **One product on 4 chosen stores** (UK + DE, CA, AU): 39 reviews, 3 additional store pages →
  $0.010 + $0.078 + $0.009 = **$0.097**.
- **One product on 6 chosen stores, 2 of which don't sell it** (AU + US, UK, DE, JP, IN): 31 reviews,
  3 store pages charged, JP and IN free → **$0.081**.
- **Every store, sold in all 23:** 199 reviews, 22 store pages → $0.010 + $0.398 + $0.066 = **$0.474**.

Apify's spending limit on a run caps the total; the Actor stops before exceeding it.

### Outcomes

Each product report, and each store in `marketplaceCoverage`, has one of these outcomes:

| Outcome | Meaning | As the product's own store | As an additional store |
|---|---|---|---|
| `OK` | Page loaded; its visible reviews were collected | Product report + reviews | Store page + new reviews |
| `GATED_SIGNIN` | Amazon showed "Sign in to see customer reviews" instead of reviews; rating data is still included | Product report only | Store page only |
| `NO_REVIEWS` | Page loaded but showed no written reviews | Product report only | Store page only |
| `NOT_FOUND` | Amazon has no page for this ASIN in that store | Free | Free |
| `UNSUPPORTED_PAGE` | The ASIN opens a page that isn't a product page (for example a subscription plan) | Free | Free |
| `BLOCKED` | Amazon answered with a robot check on every attempt | Free | Free |
| `INCOMPLETE_PAGE` / `NETWORK_ERROR` | The page never loaded fully after retries | Free | Free |
| `NOT_CHECKED` | Store not fetched: the product's own store shows no ratings (every-store mode), or your review limit was already reached ("review limit reached") | – | Free |
| `INVALID_INPUT` | Not a supported Amazon product link or ASIN | Free | – |

**About `GATED_SIGNIN`:** Amazon sometimes shows logged-out amazon.com visitors "Sign in to see
customer reviews" instead of reviews. In our tests this happened only on amazon.com. How often it
happens is Amazon's decision and changes between runs. The Actor does not sign in and does not
re-request the page to avoid the prompt. To get reviews for such a product, add other stores.

Temporary problems (timeouts, server errors, robot checks, half-loaded pages) are retried with a new
connection, up to 3 attempts per page.

### Where "Customers say" appears

In our tests Amazon showed "Customers say" for products with enough reviews on the **US, UK, Germany,
Canada, India, Australia, Mexico, United Arab Emirates, Singapore, Ireland and South Africa** stores,
and not on the other 12 stores. It is also missing for products with few reviews. When Amazon doesn't
show it, the fields are empty.

### How the feedback analysis works

The analysis uses no AI and costs nothing extra. It covers only the English reviews this run
collected, and every result states that sample size:

1. Each review is split into sentences, and sentences are split at "but", "however" and "although".
2. Each part is matched against a fixed list of themes (price & value, quality & durability, size &
   fit, scent, ease of use, packaging & delivery, performance, texture & feel, and more).
3. Positive or negative is decided from wording ("love", "broke", "disappointed", "no irritation"),
   falling back to the review's star rating when the wording is neutral.
4. A theme is listed only when at least 2 different reviews mention it, with the review IDs and
   verbatim quotes it came from, so you can check every finding.
5. Requested improvements are sentences with explicit wishes ("I wish…", "would be better if…").

Because the sample is small and chosen by Amazon, treat themes as leads to read, not as statistics.

### Scheduled monitoring

If you run this Actor on a schedule, set **Fail the run if more than this % of products can't be
read** (for example 20). The run is then marked FAILED when too many products end `BLOCKED`,
`INCOMPLETE_PAGE` or `NETWORK_ERROR`, or show 100+ ratings but no written reviews, which usually means
Amazon changed its pages. Pair it with an Apify run-status alert (Actor → Monitoring) to be notified.
Records delivered before the check are kept and charged.

### Speed and resources

One product on one store takes a few seconds. One product on every store took about 30 seconds in our
tests, and 8 products on every store (the maximum of 200 pages) under 3 minutes. Runs use 1 GB of
memory by default. Residential proxies matched to each store's country are the default; if Amazon
starts answering with robot checks, affected products end `BLOCKED` and are not charged.

### Use cases

- Compare how customers talk about competing products
- Track a product's rating, star histogram and (where shown) "Customers say" over time on a schedule
- Find complaints and improvement requests to read before changing a product or listing
- See how the same product is received in different countries

### Limitations

- At most 13 reviews per product from any one store, chosen by Amazon. More stores can add more
  distinct reviews, but the Actor never collects all of a product's reviews.
- On amazon.com, Amazon may withhold reviews from logged-out visitors (`GATED_SIGNIN`).
- Duplicates are removed by Amazon review ID. Rarely, Amazon shows the same review under two IDs on
  different stores (1 of about 900 reviews in our checks); both are then delivered.
- Themes are English-only, keyword-based, and describe only the collected reviews.
- "Customers say" is available only when Amazon shows it for that product and store.
- Amazon's pages can change. When a page doesn't match what the Actor expects, it reports an outcome
  such as `INCOMPLETE_PAGE` rather than guessing.
- Reviewer names are public display names shown by Amazon; handle them according to the data
  protection rules that apply to you.

# Actor input Schema

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

Amazon product page URLs (e.g. https://www.amazon.com/dp/B08KT2Z93D) or bare 10-character ASINs. A URL's own domain decides its marketplace; bare ASINs use the Marketplace field. Up to 200 product pages per run (products x marketplaces checked); with every store checked that is 8 products.

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

Which Amazon store to use for inputs given as bare ASINs.

## `additionalMarketplaces` (type: `array`):

Fetch the same ASIN's product page on more Amazon stores to see more distinct reviews. Each store shows its own top reviews; duplicates are removed by review ID and every record keeps its marketplace. Each additional store whose page shows the product is charged as a store page ($0.003), even when it adds no new reviews (a sign-in prompt, no written reviews, or only reviews already collected from another store). Stores not checked because 'Max reviews per product' was reached are not charged. Different products are never merged. Counts towards the page limit per run. Ignored when 'Check every supported Amazon store' is on.

## `allMarketplaces` (type: `boolean`):

Fetch the product page on all 23 supported Amazon stores. Each store shows its own top reviews (up to 13), so products sold in many countries return many more distinct reviews; products sold in few stores gain little. Duplicates are removed and every review keeps its marketplace. The primary store is checked first and the others are skipped if it shows no ratings; if 'Max reviews per product' is reached, the remaining stores are skipped too. Skipped stores are listed as NOT\_CHECKED and not charged. Each additional store whose page shows the product is charged as a store page ($0.003), even when it adds no new reviews (a sign-in prompt, no written reviews, or only reviews already collected from another store); stores that don't sell it are free. Uses up to 23 page requests per product.

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

Upper limit on review records per product across all marketplaces checked. The default (300) is above the most that 23 stores can show (23 x 13 = 299), so nothing is cut. Amazon shows logged-out visitors at most 13 reviews per store, so one store never returns more than 13. With several stores, a lower limit also stops the run checking further stores once it is reached: those stores are listed as NOT\_CHECKED ('review limit reached') and not charged. Set 0 for product-level data only (every requested store is still checked and charged as a store page).

## `includeFeedbackAnalysis` (type: `boolean`):

Add recurring positives, complaints and requested improvements, computed with transparent keyword rules from the collected English-language reviews only. Each theme shows how many of those reviews mention it. Themes describe this small sample, not all of the product's ratings. No AI is used and there is no extra charge.

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

Residential proxies matched to each marketplace's country are the tested default. Amazon's bot defences change over time, so some products can still end as BLOCKED (not charged). Other proxy settings were not tested enough to recommend.

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

How many product pages are fetched at once (1-5).

## `failRunIfUnhealthyPercentAbove` (type: `integer`):

Optional. Marks the run as FAILED when more than this percentage of products end BLOCKED, INCOMPLETE\_PAGE or NETWORK\_ERROR, or show 100+ ratings but return no written reviews. Use it with scheduled runs and Apify's run-status alerts to learn when Amazon's pages change. Records delivered before the check are kept and charged. Leave empty to turn off.

## Actor input object example

```json
{
  "products": [
    "https://www.amazon.co.uk/dp/B001ETUD5I",
    "https://www.amazon.com/dp/B08KT2Z93D"
  ],
  "marketplace": "US",
  "additionalMarketplaces": [],
  "allMarketplaces": false,
  "maxReviewsPerProduct": 300,
  "includeFeedbackAnalysis": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 5
}
```

# Actor output Schema

## `productReports` (type: `string`):

One row per input product: outcome, Amazon's rating data, Amazon's 'Customers say' summary and aspects when Amazon shows them, reviews delivered, and feedback themes from the collected English-language reviews with their sample size.

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

One row per review Amazon showed on the product page(s), with marketplace, rating, text, date, verified flag, helpful votes and variant.

## `productDetails` (type: `string`):

Nested details: per-marketplace coverage, Amazon's 'Customers say' aspects with snippets (when shown), and each theme's review IDs and quotes.

## `runSummary` (type: `string`):

Counts of outcomes per product and marketplace, page requests, retries and charged events.

# 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.co.uk/dp/B001ETUD5I",
        "https://www.amazon.com/dp/B08KT2Z93D"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zapticx/amazon-product-feedback-analyzer").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.co.uk/dp/B001ETUD5I",
        "https://www.amazon.com/dp/B08KT2Z93D",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("zapticx/amazon-product-feedback-analyzer").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.co.uk/dp/B001ETUD5I",
    "https://www.amazon.com/dp/B08KT2Z93D"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call zapticx/amazon-product-feedback-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zapticx/amazon-product-feedback-analyzer"
        }
    }
}
```

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/5T7Kax8fEICmKy2cv/builds/5HNYORpGGR4t5PBuq/openapi.json