# Amazon Review Analysis Scraper (`automation-lab/amazon-review-demand-signals`) Actor

Analyze public Amazon reviews into complaint clusters, feature requests, unmet needs, evidence quotes, severity, and recommended product and marketing actions.

- **URL**: https://apify.com/automation-lab/amazon-review-demand-signals.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 1 total users, 1 monthly users, 94.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Analysis Scraper

Turn public Amazon reviews into product decisions instead of another raw review export.

Amazon Review Analysis Scraper performs **amazon review analysis** for one or more Amazon.com products. It finds recurring complaints, feature requests, unmet needs, and praise; assigns rule-based severity; preserves representative quotes and review URLs; and recommends conservative product and marketing actions.

The default analysis is deterministic and does not require an AI key. You may provide your own OpenAI key to improve cluster labels, but model output cannot create clusters, severity, quotes, or actions.

### What does this Actor do?

For each supplied ASIN or Amazon product/review URL, the Actor:

1. opens a coherent Amazon session through a cost-conscious proxy route;
2. collects the public review cards Amazon exposes to anonymous visitors;
3. rejects CAPTCHA, sign-in, invalid, and zero-review shells;
4. classifies review sentences into stable product themes;
5. separates complaints, feature requests, unmet needs, and praise;
6. ranks clusters using prevalence and contributing ratings;
7. includes up to three source-attributed quotes per cluster;
8. emits one product-level analysis summary.

It does not access orders, accounts, private reviews, or seller-only data.

### Who is Amazon review analysis for?

- **Amazon sellers** prioritizing listing, packaging, quality, or roadmap changes.
- **Product managers** looking for repeated customer friction and requested capabilities.
- **Ecommerce brands** comparing public feedback across their own and competing products.
- **Agencies** preparing evidence-backed voice-of-customer research.
- **Marketing teams** identifying customer language they can support with public quotes.
- **Data teams** feeding typed product summaries into dashboards, Sheets, n8n, Make, or Zapier.

Choose [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) when you need review-level exports rather than analyzed product summaries.

### Why use this Actor?

#### Deterministic by default

Theme assignment, severity, actions, and quote selection are rule-based and reproducible. No model key is required.

#### Traceable evidence

Every cluster includes review IDs, bounded excerpts, ratings, and source review URLs. You can inspect the evidence behind a conclusion.

#### Demand-signal output

The primary result is a product summary, not a pile of ungrouped review rows. This makes the dataset easier to use in product planning and recurring research.

#### Fail-loud source handling

Amazon sometimes returns metadata-only pages, sign-in interstitials, synthetic 404s, or CAPTCHA shells. The Actor does not report these as a successful empty analysis.

### What data is returned?

| Field | Description |
| --- | --- |
| `asin` | Amazon Standard Identification Number analyzed |
| `productName` | Product title shown on the source page |
| `productUrl` | Canonical Amazon.com product URL |
| `reviewsAnalyzed` | Number of public review records analyzed |
| `sourceReviewCount` | Aggregate rating/review count shown by Amazon, when available |
| `averageRating` | Aggregate product rating shown by Amazon, when available |
| `ratingDistribution` | Counts of analyzed reviews from one to five stars |
| `demandSignals` | Ranked complaint, request, unmet-need, and praise clusters |
| `topComplaints` | Highest-priority complaint and unmet-need labels |
| `topFeatureRequests` | Highest-priority requested-capability labels |
| `topPraises` | Most frequent supported praise labels |
| `recommendedProductActions` | Rule-based actions tied to negative signals and requests |
| `recommendedMarketingActions` | Conservative actions tied to supported praise evidence |
| `analysisMethod` | `rules` or `rules+openai-labels` |
| `acquisitionRoute` | Successful `SHADER`, `RESIDENTIAL`, or local `DIRECT` route |
| `analyzedAt` | ISO 8601 analysis timestamp |

Each `demandSignals` entry contains:

- stable cluster ID and label;
- signal type;
- distinct review mention count;
- share of analyzed reviews;
- severity and average contributing rating;
- matched keywords;
- representative source quotes;
- a recommended action.

### Getting started

1. Open the Actor in Apify Console.
2. Enter one or more ASINs or Amazon.com URLs.
3. Keep `maxReviewsPerProduct` small for an initial run.
4. Leave the OpenAI key blank for deterministic analysis.
5. Click **Start**.
6. Open **Product demand signals** in the run dataset.
7. Review quotes before using an action in a roadmap or campaign.

A working input:

```json
{
  "asins": ["0321965515"],
  "maxReviewsPerProduct": 5,
  "includePositiveSignals": true
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `asins` | string array | required | One to 20 ASINs or Amazon.com `/dp/`, `/gp/product/`, or `/product-reviews/` URLs |
| `maxReviewsPerProduct` | integer | `12` | Maximum public reviews analyzed per product, from 1 to 20 |
| `includePositiveSignals` | boolean | `true` | Include supported praise clusters |
| `openAiApiKey` | string | none | Optional user-provided key used only for cluster label rewriting |
| `openAiModel` | string | `gpt-4o-mini` | Model used when a key is supplied |

The Actor currently supports Amazon.com and US English analysis. Inputs from other Amazon marketplace domains are rejected rather than silently mapped to a different locale.

### Example output

This shortened example reflects current rule-based output:

```json
{
  "asin": "0321965515",
  "productName": "Don't Make Me Think, Revisited",
  "productUrl": "https://www.amazon.com/dp/0321965515",
  "reviewsAnalyzed": 5,
  "sourceReviewCount": 4658,
  "averageRating": 4.6,
  "ratingDistribution": {
    "1": 0,
    "2": 0,
    "3": 0,
    "4": 1,
    "5": 4,
    "unknown": 0
  },
  "demandSignals": [
    {
      "id": "usability:praise",
      "label": "Ease of use — praise",
      "signalType": "praise",
      "mentions": 3,
      "shareOfReviews": 0.6,
      "severity": "low",
      "averageRating": 5,
      "keywords": ["easy", "use"],
      "representativeQuotes": [
        {
          "reviewId": "R3JKCJ0MMZNC6G",
          "quote": "Not only it is easy to read and very clear...",
          "rating": 5,
          "reviewUrl": "https://www.amazon.com/review/R3JKCJ0MMZNC6G"
        }
      ],
      "recommendedAction": "Simplify setup and revise instructions around the quoted friction points."
    }
  ],
  "topComplaints": [],
  "topFeatureRequests": [],
  "topPraises": ["Ease of use — praise"],
  "analysisMethod": "rules",
  "acquisitionRoute": "RESIDENTIAL",
  "analyzedAt": "2026-08-03T05:39:00.000Z"
}
```

The complete record also includes product and marketing action arrays.

### How much does it cost to analyze Amazon product reviews?

The Actor uses pay-per-event pricing:

- a one-time run-start event;
- one product-analysis event for each summary added to the dataset.

The source may require residential proxy traffic, but there is no separately billed proxy event. Infrastructure cost is included in Actor operation.

The run start costs **$0.005**. Product-analysis prices decrease across Apify plan tiers:

| Tier | Price per product summary |
| --- | ---: |
| Free | $0.3772 |
| Bronze | $0.328 |
| Silver | $0.25584 |
| Gold | $0.1968 |
| Platinum | $0.1312 |
| Diamond | $0.09184 |

At the Bronze tier, representative totals are:

| Example | Product summaries | Total |
| --- | ---: | ---: |
| One-product research | 1 | $0.333 |
| Small comparison | 5 | $1.645 |
| Portfolio batch | 25 | $8.205 |

Apify applies the tier associated with your plan. Set a maximum run charge in Console when you need a hard spending limit.

### Product research workflows

#### One-time product diagnosis

Analyze one ASIN, inspect the top negative clusters, and verify the representative quotes before prioritizing a change.

#### Competitor comparison

Supply several ASINs in one run. Each dataset row remains product-scoped, so downstream tools can compare prevalence, severity, and actions without mixing evidence.

#### Recurring voice-of-customer snapshots

Schedule the same Task and save dataset results to your warehouse or Sheet. Compare snapshots downstream; the Actor does not claim built-in historical diffing or alerts.

#### Marketing message validation

Use `topPraises` and their quotes as research evidence. Do not convert them into performance claims without independent substantiation.

### Integrations

#### Google Sheets

Use Apify's dataset export or Make/Zapier integration to append one product summary per row. Expand nested signal arrays in your automation when you need one row per cluster.

#### n8n, Make, and Zapier

Start a Task on a schedule, wait for success, and route dataset items to Slack, Notion, a product database, or a review workflow.

#### BI and warehouses

Fetch JSON dataset items through the API. Keep `asin` and `analyzedAt` as snapshot keys and preserve the full `demandSignals` object for auditability.

### Run with the Apify API

Replace `YOUR_TOKEN` with your Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~amazon-review-demand-signals/runs?token=YOUR_TOKEN&waitForFinish=300" \
  -H "Content-Type: application/json" \
  -d '{"asins":["0321965515"],"maxReviewsPerProduct":5,"includePositiveSignals":true}'
```

Fetch the resulting dataset with the `defaultDatasetId` returned by the run.

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/amazon-review-demand-signals').call({
  asins: ['0321965515'],
  maxReviewsPerProduct: 5,
  includePositiveSignals: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].demandSignals);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/amazon-review-demand-signals').call(run_input={
    'asins': ['0321965515'],
    'maxReviewsPerProduct': 5,
    'includePositiveSignals': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0]['demandSignals'])
```

### Use with Apify MCP

#### Claude Code

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/amazon-review-demand-signals"
```

#### Claude Desktop, Cursor, and VS Code

Add this MCP JSON configuration in the client's MCP settings:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/amazon-review-demand-signals"
    }
  }
}
```

Example prompts:

- “Run Amazon Review Analysis Scraper for ASIN 0321965515 and summarize the highest-severity signals with their evidence URLs.”
- “Compare the complaint and feature-request clusters for ASINs 0321965515 and 0134685997.”
- “Save the Amazon review demand-signal output for this product as JSON and list the recommended product actions.”

### Optional OpenAI label enrichment

When `openAiApiKey` is present, the Actor sends only cluster IDs, signal types, and matched keywords to OpenAI. It does not send review text or representative quotes.

The model may rewrite labels only. Deterministic code still controls:

- which evidence belongs to a cluster;
- mention counts and prevalence;
- severity;
- quotes and source URLs;
- product and marketing actions.

If the model request fails, the run continues with deterministic labels.

### Source access and proxy behavior

Amazon frequently varies anonymous page behavior by network identity. The Actor:

1. warms a US SHADER session;
2. reuses cookies and proxy identity across desktop, mobile, and review surfaces;
3. retries a bounded second SHADER identity;
4. escalates to bounded US residential sessions only when necessary;
5. fails if every route returns no public reviews.

There is no login, CAPTCHA solver, private API, browser profile, or customer account dependency.

### Limits and expected behavior

- Amazon.com and US English only.
- Maximum 20 products per run.
- Maximum 20 analyzed public reviews per product.
- Amazon often exposes only a small representative review set anonymously.
- The Actor does not promise all historical reviews or arbitrary pagination depth.
- Product variants may share reviews; review IDs are deduplicated within each analysis.
- Rules recognize common English ecommerce themes and may miss domain-specific terminology.
- Recommended actions are research prompts, not guaranteed business outcomes.
- A product with no public anonymous review records fails instead of creating an empty summary.

### Troubleshooting

#### The run says Amazon exposed no public reviews

Confirm the ASIN exists on Amazon.com and has visible public reviews. Amazon may temporarily return sign-in, CAPTCHA, metadata-only, or unavailable pages. Retry later rather than repeatedly launching identical runs.

#### My URL is rejected

Use a 10-character ASIN or an `amazon.com` URL containing `/dp/`, `/gp/product/`, or `/product-reviews/`. Other marketplaces and shortened redirect URLs are not currently supported.

#### Why are only a few reviews analyzed?

Amazon commonly embeds a bounded public set on product pages and may restrict dedicated review pages. The Actor reports the useful records actually exposed; it does not fabricate complete coverage.

#### Why is a cluster absent?

A signal must match a deterministic theme and contain enough recognizable language. Inspect the available source quotes and consider exporting raw reviews with the related scraper when you need custom NLP.

#### OpenAI labeling failed

Verify the key, model access, and account quota. The dataset remains valid because rule-based labels are retained automatically.

### Responsible use and legality

Use this Actor only for lawful analysis of public data you are authorized to process. Follow Amazon's applicable terms, Apify's platform policies, and privacy and database laws in your jurisdiction.

Do not use review excerpts to identify, profile, harass, or contact reviewers. Avoid publishing personal information. Retain only the evidence needed for a legitimate research purpose and set an appropriate deletion policy.

Review-derived patterns are directional evidence. Verify important decisions independently and do not present generated recommendations as medical, legal, safety, or financial advice.

### Related Automation Lab Actors

- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — export public review-level records.
- [Amazon Product Search Results Scraper](https://apify.com/automation-lab/amazon-product-search-results-scraper) — discover and export ranked product cards by keyword.
- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) — broader Amazon product extraction workflows.

### FAQ

#### Does the Actor require an Amazon account?

No. It accesses only reviews Amazon exposes to anonymous public sessions.

#### Does it require OpenAI?

No. Deterministic extraction and analysis are the default. OpenAI is optional and limited to cluster label rewriting.

#### Are private or order-linked reviews included?

No. The Actor does not log in or access private/order-linked data.

#### Can I analyze other Amazon marketplaces?

Not in this release. Only Amazon.com US English inputs are supported and accepted.

#### Does it perform sentiment analysis?

It classifies evidence into complaint, feature-request, unmet-need, and praise signals using transparent rules and ratings. It does not claim opaque full-text sentiment scoring.

#### Can I compare products?

Yes. Supply multiple ASINs and compare their independent product-level rows downstream. The Actor does not merge products or invent a winner.

#### Can I schedule it?

Yes. Save the input as an Apify Task and schedule runs. Store snapshots downstream if you need historical comparisons or notifications.

#### What is charged?

One run-start event and one product-analysis event per successfully emitted product summary. Failed or rejected product shells do not create product-analysis items.

# Actor input Schema

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

Up to 20 Amazon.com ASINs or URLs. Each product produces one analysis summary.

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

Analyze up to this many public reviews exposed by Amazon. Amazon commonly exposes only a small representative set to anonymous sessions.

## `includePositiveSignals` (type: `boolean`):

Include recurring positive themes alongside complaints, feature requests, and unmet needs.

## `openAiApiKey` (type: `string`):

Optional user-provided key used only to rewrite deterministic cluster labels. Review quotes are not sent; extraction and analysis work without this key.

## `openAiModel` (type: `string`):

Model used only when an OpenAI API key is provided.

## Actor input object example

```json
{
  "asins": [
    "0321965515"
  ],
  "maxReviewsPerProduct": 12,
  "includePositiveSignals": true,
  "openAiModel": "gpt-4o-mini"
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset containing one typed demand-signal analysis summary per Amazon product.

# 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": [
        "0321965515"
    ],
    "maxReviewsPerProduct": 12,
    "openAiModel": "gpt-4o-mini"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/amazon-review-demand-signals").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": ["0321965515"],
    "maxReviewsPerProduct": 12,
    "openAiModel": "gpt-4o-mini",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/amazon-review-demand-signals").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": [
    "0321965515"
  ],
  "maxReviewsPerProduct": 12,
  "openAiModel": "gpt-4o-mini"
}' |
apify call automation-lab/amazon-review-demand-signals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/amazon-review-demand-signals"
        }
    }
}

```

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/U7ofKL1wWNtw5Qgf9/builds/rixnrqHWTfJauOm62/openapi.json