# Amazon Review Analyzer & Product Opportunity Finder (`catandgoose/amazon-review-intelligence`) Actor

Scrape Amazon reviews into a product-opportunity verdict: complaint clusters, unmet needs & a go/no-go score. Pay-per-use, never billed for empty runs.

- **URL**: https://apify.com/catandgoose/amazon-review-intelligence.md
- **Developed by:** [Cat & Goose](https://apify.com/catandgoose) (community)
- **Categories:** AI, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% 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.

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 Reviews Scraper + AI Product Research & Opportunity Finder

**Scrape Amazon reviews and turn them into a seller-facing product-opportunity verdict** — complaint clusters, unmet-need gaps, differentiation angles, and a go / no-go score — plus a shareable HTML report for every product. This Amazon review scraper does the analysis most tools leave to you: it reads the review corpus, finds the recurring pain points, and tells you whether there's room to build a better product. And it **never charges you for an empty run** — the number-one complaint about every other Amazon review scraper on the market.

Where a SaaS suite like SmartScout ($29–187/mo), Helium 10 ($39–279/mo), or SellerSprite ($70/mo) locks review analysis behind a monthly subscription, this actor runs pay-per-use: analyze one product for a few cents, or a hundred on a schedule, and pay only for verdicts that actually land.

### How does the Amazon Review Analyzer work?

The actor collects Amazon review signals and distills them into a structured product-opportunity report:

- **Complaint clusters** — the recurring problems buyers report, each with a severity rating and rough mention share (frequency × severity is exactly how experienced sellers prioritize).
- **Unmet needs & gaps** — features and fixes customers keep asking for, i.e. demand you could capture.
- **Differentiation angles** — concrete ways a new entrant could beat the incumbent, grounded in the review evidence.
- **What the incumbent owns** — the praise pillars you'd have to match to compete.
- **Opportunity verdict** — a 0–100 score, a demand-vs-saturation read, and a plain-English go / conditional-go / no-go recommendation.
- **Shareable HTML report** — a clean, self-contained report page per product (public URL), ready to send to a client or partner.

### Three ways to get the reviews (pick your depth)

Amazon gates its full review list behind a login, so this actor gives you three input modes instead of one brittle scraper that breaks on it:

1. **Snapshot mode (anonymous, zero setup — recommended default).** Scrapes the public product page: top reviews, the full star-rating histogram, and **Amazon's own "Customers say" aspect sentiment analysis** (per-aspect summaries with representative quotes). Rich, instant, no login, no cookies.
2. **Cookies mode (full depth).** Paginates the complete review list using *your own* Amazon session cookies — for when you need every review, not just the product-page sample.
3. **Dataset mode (analyze what you already have).** Point the actor at any existing Apify dataset of reviews — from *any* review scraper — and get the opportunity verdict on data you've already collected.

### Amazon Review Analyzer vs. other tools

| | This actor | junglee/amazon-reviews-scraper | SmartScout / Helium 10 / SellerSprite |
|---|---|---|---|
| Pricing model | Pay-per-use (from ~$0.02/product) | Pay-per-use | $29–279 / month subscription |
| Charges on empty runs | **Never** | Yes (top complaint) | N/A |
| Multi-product batch | **Yes, reliable** | Frequently broken | Yes |
| Product-opportunity verdict | **Built in** | No (raw reviews only) | Partial / add-on |
| Shareable HTML report | **Yes** | No | No |
| Analysis included, no key setup | **Yes** | N/A | N/A |
| Analyze an existing dataset | **Yes** | No | No |

The incumbent Amazon review scraper on the Apify Store has over 10,000 users but a 2.34★ rating — because it charges for empty runs, caps reviews, and breaks on multi-product input. This actor is built to fix exactly those failures and add the analysis layer on top.

### What data can you extract from Amazon reviews?

Every run outputs one structured row per product, containing:

- Product title, brand, ASIN, average rating, and total rating count
- The full star-rating histogram (percentage at each of the 5 star levels)
- Amazon's "Customers say" summary and per-aspect sentiment chips (with representative snippets)
- The scraped review corpus (in cookies mode) or product-page reviews (in snapshot mode)
- The complete insight object: complaint clusters, unmet needs, differentiation angles, praise pillars, and the opportunity verdict
- A public URL to the rendered HTML opportunity report

### How to use the Amazon Review Analyzer

1. Choose a **mode** (start with `snapshot` — no setup).
2. Paste one or more **ASINs or Amazon product URLs** (multi-product batches work reliably).
3. Leave **Generate verdict** on to get the full opportunity report.
4. (Optional) Add **competitor ASINs** for side-by-side context, or switch to cookies/dataset mode for full-corpus depth.
5. Run it — each product returns a data row plus a shareable report link. Schedule it to track how a niche's complaints and ratings shift over time.

### Pricing

Pay-per-event — you pay for results, never for empty runs.

| Event | Price | When it fires |
|---|---|---|
| Product snapshot scraped | ~$0.02 / product | Snapshot mode, per product with real data |
| Review scraped | $0.0025 / review | Cookies mode, per review collected |
| Product opportunity verdict | $0.40 / product | Per opportunity report generated |
| Analysis overflow | $0.20 / 1,000 reviews | Only above your analysis cap |

**Example:** a snapshot + opportunity verdict on one product costs about **$0.42** — versus a $29–$70/month subscription you'd pay whether you analyze one product or none. Research ten products for roughly the price of a coffee, with no monthly commitment.

#### Example input

```json
{
  "mode": "snapshot",
  "asins": ["B09B8V1LZ3", "B0BSHF7WHW"],
  "marketplace": "com",
  "maxReviewsAnalyzed": 1000
}
```

#### Example output (abridged)

```json
{
  "asin": "B09B8V1LZ3",
  "title": "Amazon Echo Dot (newest model)",
  "avgRating": 4.7,
  "totalRatings": 195514,
  "histogram": { "5star": 82, "4star": 11, "3star": 3, "2star": 1, "1star": 3 },
  "insight": {
    "complaintClusters": [
      { "label": "Connectivity drops", "severity": "high", "mentionShare": "~18%", "summary": "Repeated Wi-Fi disconnects requiring re-setup." }
    ],
    "unmetNeeds": ["Reliable multi-room sync", "Privacy-first mode with a hardware mic cut"],
    "differentiationAngles": ["Position on rock-solid connectivity vs. the incumbent's drop complaints"],
    "verdict": {
      "opportunityScore": 62,
      "recommendation": "conditional-go",
      "oneLine": "Enter only with a defensible wedge on connectivity or privacy."
    }
  },
  "reportUrl": "https://api.apify.com/v2/key-value-stores/.../records/report-B09B8V1LZ3"
}
```

### Who uses this Amazon review scraper?

- **Amazon FBA sellers doing product research** — decide whether a niche is worth entering before you source inventory.
- **Private-label brand builders** — turn a competitor's 1- and 3-star reviews into your product roadmap.
- **Product researchers & sourcing agents** — screen dozens of ASINs a day for solvable, high-frequency complaints.
- **Agencies & consultants** — hand clients a branded, shareable opportunity report instead of a spreadsheet.
- **Market analysts** — track how sentiment and complaint themes shift across a category over time with scheduled runs.
- **Existing scraper users** — already have review data in Apify? Run dataset mode and get the verdict without re-scraping.

### Frequently asked questions

**How many Amazon reviews should I analyze for product research?** Around 100 reviews is enough for a single product read, and 500+ across competitors reveals category-level patterns. 3-star reviews carry the most balanced signal. The actor's analysis cap defaults to 1,000 — plenty for theme convergence — and you're only billed for overflow beyond it.

**Can it analyze all of a product's reviews?** Amazon requires a login to page through the full review list. Snapshot mode returns the product-page reviews plus Amazon's own aspect-level analysis (rich, and enough for a solid verdict); cookies mode, using your own Amazon session, unlocks full review-list pagination.

**Does it charge me if a product has no reviews or the run fails?** No. Charging is guarded — an empty result produces no billable event. This is the single biggest fix versus the incumbent Amazon review scraper.

**Do I need my own API key or a separate subscription?** No. Everything is bundled — no bring-your-own-key setup and no extra accounts to manage. It works out of the box.

**Can I compare two products side by side?** Yes. Add competitor ASINs and each is scraped and analyzed alongside your primary product for a direct comparison.

**Which Amazon marketplaces are supported?** US (.com) is the primary target, with .co.uk, .de, .ca, .com.au, .fr, .es, and .it selectable.

**Is this cheaper than Helium 10 or SmartScout for review analysis?** For occasional or batch product research, yes — you pay a few cents per product instead of $29–$279 every month, with no subscription.

**Can I analyze reviews I already scraped with another tool?** Yes — dataset mode reads any Apify dataset of reviews and runs the opportunity verdict on it, no re-scraping needed.

### Limitations (the honest version)

- **Full review pagination requires login.** Snapshot mode is anonymous and returns the product-page reviews plus Amazon's aspect analysis — genuinely rich, but not the entire review corpus. Use cookies mode with your own session for full depth. High-volume pagination on a personal account carries the usual Amazon account-activity risk; use an account you're comfortable with.
- **Turning the verdict off gives you scrape-only output.** With **Generate verdict** unchecked, the actor still scrapes and outputs the full review data — just without the opportunity report.
- **Amazon changes its page structure frequently.** The parser is built with fallbacks and degrades gracefully, but layout drift can occasionally reduce what's captured on a given day.
- **Residential proxies are strongly recommended** for Amazon and are used by default.

# Actor input Schema

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

How to get the reviews. 'snapshot' = anonymous product-page scrape (top reviews + rating histogram + Amazon's 'Customers say' summary), zero setup. 'cookies' = full review pagination using your own Amazon session cookies. 'dataset' = analyze reviews already collected in an Apify dataset (from any scraper).

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

Amazon ASINs (e.g. B09B8V1LZ3) or full product URLs. Used by snapshot and cookies modes.

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

Amazon marketplace domain to scrape.

## `runAiAnalysis` (type: `boolean`):

Turn the review corpus into complaint clusters, unmet-need gaps, and a go/no-go opportunity verdict. Turn off for scrape-only runs.

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

Upper bound on reviews collected per product in cookies mode. Snapshot mode returns whatever the product page exposes (typically 8-100).

## `maxReviewsAnalyzed` (type: `integer`):

Caps analysis cost. Complaint themes converge fast, so 300-1000 high-signal reviews usually capture every theme. Reviews above this cap are billed per 1,000 via the analysis-overflow event.

## `maxAiSpendUsd` (type: `integer`):

Safety ceiling on this run's estimated analysis cost. Once hit, remaining products in a batch are scraped without an opportunity verdict rather than continuing to spend. Raise this for large multi-ASIN batches.

## `competitorAsins` (type: `array`):

Optional competitor products for a side-by-side verdict. Each competitor is scraped and analyzed like a primary ASIN.

## `datasetId` (type: `string`):

Apify dataset containing review rows to analyze. Used only when mode = 'dataset'. Pick one of your datasets, or paste a dataset ID.

## `datasetReviewField` (type: `string`):

The field in each dataset row that holds the review text (e.g. 'reviewText', 'body', 'text').

## `datasetRatingField` (type: `string`):

Optional field holding the star rating (e.g. 'rating', 'stars').

## `sessionCookies` (type: `string`):

Your own Amazon session cookies, used only in cookies mode to paginate the full review list. Paste the raw Cookie header string or JSON array of {name,value} pairs exported from your browser. WARNING: these come from your logged-in Amazon account — high-volume pagination may trigger Amazon account checks. Use an account you're comfortable with, and never share this value.

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

Residential proxies strongly recommended for Amazon. Defaults to Apify residential.

## Actor input object example

```json
{
  "mode": "snapshot",
  "asins": [
    "B09B8V1LZ3"
  ],
  "marketplace": "com",
  "runAiAnalysis": true,
  "maxReviews": 500,
  "maxReviewsAnalyzed": 1000,
  "maxAiSpendUsd": 5,
  "datasetReviewField": "reviewText",
  "datasetRatingField": "rating",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": [
        "B09B8V1LZ3"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("catandgoose/amazon-review-intelligence").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "B09B8V1LZ3"
  ]
}' |
apify call catandgoose/amazon-review-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=catandgoose/amazon-review-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/xqQzllrRUF2ju4heG/builds/vjt58QgfMZKOh3crF/openapi.json