# Amazon AI Review Summary (`cyprusapi/amazon-ai-summary`) Actor

Amazon's AI-generated 'Customers say' review summary per ASIN, with per-aspect sentiments and verbatim mention counters — 18 marketplaces, charged only when a summary is actually delivered.

- **URL**: https://apify.com/cyprusapi/amazon-ai-summary.md
- **Developed by:** [Torchtechnology LTD](https://apify.com/cyprusapi) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 ai review summaries

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

### What does Amazon AI Review Summary do?

Amazon AI Review Summary extracts **Amazon's own AI-generated review digest** — the **"Customers say"** box — from any product detail page, across **18 Amazon marketplaces**. For every ASIN you get the overall AI summary paragraph plus the **aspect-level sentiment breakdown** (e.g. "Scheibendicke", "battery life", "qualité sonore") with Amazon's verbatim mention counters (positive/negative) and per-aspect summary sentences — all in the marketplace's native language.

Feed it ASINs or product URLs and get clean, analysis-ready JSON back. The actor runs on the Apify platform, so you get **API access, scheduling, integrations, proxy rotation, and run monitoring** out of the box — no infrastructure to manage. Try it on the Apify free tier in a couple of clicks.

**Honest by design:** many products simply have no AI summary (Amazon only renders the widget above an undisclosed review threshold, and not on every marketplace). Those ASINs still return a clean item with `summaryStatus: "absent"` and a machine-readable `absentReason` — and they are **never charged**. You only pay for summaries actually delivered.

### Why use Amazon AI Review Summary?

Reading 500 reviews per product does not scale. Amazon's AI summary is the closest thing to a vetted consensus — and this actor is the fast lane to it:

- **Voice-of-customer analysis** — aspect-level sentiments ("battery life: 210 positive, 29 negative") beat star averages for product research.
- **Competitive intelligence** — compare what customers praise and criticize across competing ASINs, in bulk.
- **Listing QA for sellers** — monitor how Amazon's AI summarizes your own products over time; scheduled runs give you a drift history.
- **Review mining without the noise** — the summary and aspect counters are Amazon's own words, passed through verbatim, never recomputed or estimated.

Every item carries a **provenance capture block** (URL, HTTP status, SHA-256 of the parsed page), so you can prove where each value came from.

#### AI-shopping readiness: see your product the way Amazon's AI presents it

Amazon is steadily moving shopping toward AI — AI-generated review digests, AI-powered search, and conversational shopping assistants like Rufus. Sellers who want their listings to stay visible in that world first need to know what Amazon's AI actually says about their products. The **"Customers say" box is the most direct public source for exactly that**: it is Amazon's own AI characterizing a product to shoppers, in Amazon's own words — aspect by aspect, with sentiment counters.

- **Monitor your AI footprint** — scheduled runs build a history of how Amazon's AI summarizes each ASIN, so you spot narrative drift before it costs conversion.
- **Close the loop with listing optimization** — the aspect-level sentiment counters show which product attributes Amazon's AI amplifies; those are the attributes your title, bullets, images, and A+ content should reinforce — or the problems you need to fix.
- **Benchmark the competition** — compare the AI narrative of competing ASINs side by side, in bulk, across the 11 marketplaces where the widget renders.
- **Cross-marketplace monitoring in one run** — select several marketplaces via `marketplaces` and every ASIN is fetched on each of them in a single run: one dataset item per ASIN × marketplace, each with its own `marketplace` code, language cookie, and proxy/geo chain. No more one-run-per-marketplace orchestration; charging is unchanged (only delivered summaries are charged, per item).

### How to scrape Amazon's "Customers say" summaries

1. Open the actor in [Apify Store](https://apify.com/store) and click **Try for free**.
2. On the **Input** tab, paste your **ASINs** (e.g. `B0BLGJTJRD`) and/or **Amazon product URLs** (`/dp/...` or `/gp/product/...`).
3. Pick the **Marketplace** — or select several under **Marketplaces (multi)** to fetch every ASIN on each of them in the same run. The actor fetches each Amazon domain in its native language.
4. Click **Start**, then download your results from the **Output** or **Storage** tab — or pull them via the Apify API.

### Input

| Field | Type | Description |
|---|---|---|
| `asins` | array | Amazon ASINs (10 characters). One dataset item per ASIN × marketplace. |
| `startUrls` | array | Amazon product URLs; the ASIN is extracted from each URL. Provide `asins` and/or `startUrls`. |
| `marketplace` | string | One of 18 marketplaces: `com`, `de`, `co.uk`, `fr`, `it`, `es`, `ca`, `com.au`, `co.jp`, `in`, `nl`, `se`, `pl`, `be`, `mx`, `br`, `ae`, `sa`. Default `com`. Used only when `marketplaces` is empty. |
| `marketplaces` | array | Optional multi-select of the same 18 codes. When non-empty it **takes precedence** over `marketplace`: every ASIN is fetched on **each selected marketplace in one run** — one dataset item per ASIN × marketplace, each carrying its own `marketplace` code. |
| `maxItems` | integer | Upper bound of ASINs per run, counted across **all selected marketplaces combined**. Default `5`. |
| `language` | string | Optional Amazon language code (e.g. `en_US`, `de_DE`) appended to every fetched page. By default the marketplace's verified language cookie is used. |
| `proxyConfiguration` | object | Proxy settings. Residential proxies are strongly recommended and preselected. |
| `proxiesByMarketplace` | object | Optional geo-pinned custom proxies per marketplace — tried first, ahead of the bundled pool and the Apify proxy tiers. |

### Output

One dataset item per ASIN × marketplace. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "asin": "B079VP6DH5",
  "marketplace": "com",
  "url": "https://www.amazon.com/dp/B079VP6DH5",
  "title": "Bounty Paper Towels Quick Size, White, 16 Family Rolls = 40 Regular Rolls",
  "summaryStatus": "present",
  "absentReason": null,
  "summary": "Customers praise the absorbency, strength and value of these paper towels for everyday kitchen cleanup …",
  "aspects": [
    {
      "aspect": "Absorbency",
      "sentiment": "positive",
      "mentions": 1839,
      "positive": 1710,
      "negative": 129,
      "summary": "Customers are satisfied with the absorbency. They describe the towels as quick and thorough."
    }
  ],
  "ratingCount": 102341,
  "ratingAverage": 4.8,
  "scrapedAt": "2026-08-18T09:30:00.000000+00:00"
}
```

An ASIN without an AI summary (still delivered, never charged):

```json
{
  "asin": "B0EXAMPLE0",
  "marketplace": "com",
  "summaryStatus": "absent",
  "absentReason": "widget_absent",
  "summary": null,
  "aspects": [],
  "ratingCount": 7,
  "ratingAverage": 4.2
}
```

### Data fields

| Field | Description |
|---|---|
| `summaryStatus` | `present` (summary delivered, charged) or `absent` (free). |
| `absentReason` | `no_ratings` (the PDP shows zero ratings) or `widget_absent` (Amazon did not render the widget for this ASIN/marketplace). |
| `summary` | Amazon's AI-generated overall review summary, verbatim, in the marketplace's language. |
| `aspects[]` | `aspect`, `sentiment` (`positive`/`mixed`/`negative`), `mentions`, `positive`, `negative` (verbatim Amazon counters), `summary` (Amazon's per-aspect sentence). |
| `ratingCount` / `ratingAverage` | Rating context from the same page. |
| `capture` | Provenance: URL, HTTP status, user agent, SHA-256 of the parsed HTML. |

### How much does it cost to scrape Amazon AI summaries?

The actor uses **pay-per-event** pricing: you pay a small fixed price per **`summary`** event — and that event fires **only when an AI summary is actually delivered**. Absent summaries, invalid inputs, not-found ASINs, and blocked/transport failures are **always free**. Amazon's own infrastructure usage on Apify's free tier covers small test runs; batch your ASINs into one run for the best unit economics.

### Tips for best results

- **Batch your ASINs** into a single run instead of many one-ASIN runs.
- **Match the marketplace to the ASIN** — an ASIN that exists on amazon.de may not exist (or may have no reviews) on amazon.co.jp.
- Keep **residential proxies** enabled (preselected); Amazon aggressively gates datacenter IPs on product pages.
- If you need the summaries in a specific language regardless of marketplace, set the `language` override.

### FAQ, disclaimers, and support

**Why did my ASIN return `absent`?** Amazon only shows the "Customers say" widget for products with enough reviews, and does not offer it on every marketplace or category. `absentReason` tells you which case applies; `no_ratings` vs. `widget_absent`. This is Amazon's behavior, not a scraper failure — and it is never charged.

**Which marketplaces have the AI summary?** Verified live (August 2026): the widget renders on **de, com, co.uk, fr, it, es, ca, com.au, in, mx, ae**. It does **not** render on **nl, se, pl, be, sa** (confirmed absent even for products with 20,000+ ratings) and was not observed on **co.jp, br** either — ASINs there return `absent` / `widget_absent` (free). Amazon rolls the feature out gradually, so this can change; the actor reports whatever Amazon actually serves.

**Which languages are the summaries in?** Always the marketplace's native rendering language (German on amazon.de, English on amazon.com, …), unless you override it via `language`.

**Is this legal?** The actor extracts publicly displayed, AI-generated aggregate text — no personal reviewer data is collected. You are responsible for complying with applicable terms and regulations in your jurisdiction.

Found a bug or need a custom feature? Open a ticket on the **Issues** tab — custom solutions are available on request.

# Actor input Schema

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

Amazon ASINs (10 characters) to fetch the AI review summary for, e.g. B079VP6DH5. One dataset item per ASIN × selected marketplace. Provide asins and/or startUrls.

## `startUrls` (type: `array`):

Amazon product URLs (/dp/... or /gp/product/...). The ASIN is extracted from each URL; the run's marketplace setting decides which Amazon domain is fetched. Provide asins and/or startUrls.

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

Amazon marketplace all ASINs are fetched from (domain, locale and rendering language follow this setting). Used only when 'Marketplaces (multi)' below is empty; a non-empty multi-selection takes precedence.

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

Optional: fetch every ASIN on SEVERAL marketplaces in ONE run — one dataset item per ASIN × marketplace, each carrying its own marketplace code. When this list is non-empty it takes precedence over the single 'Marketplace' field above; when empty, that single field is used (unchanged behavior). Each selected marketplace gets its own pass with its own session/proxy/detection chain.

## `maxItems` (type: `integer`):

Upper bound of ASINs processed in this run — counted across ALL selected marketplaces combined (not per marketplace).

## `language` (type: `string`):

Optional Amazon language code (e.g. en\_US, de\_DE) appended as ?language= to every fetched page. By default the marketplace's verified language cookie is used — the summary renders in the marketplace's native language.

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

Residential proxies are strongly recommended. Custom proxies can be added as proxyUrls (http://user:pass@host:port).

## `proxiesByMarketplace` (type: `object`):

Optional: {"de": \["http://user:pass@host:port", …], "co.uk": \[…]}. Geo-pinned proxies per marketplace — exit-IP country should match the marketplace, otherwise Amazon serves bot-gates. Proxy tier chain per task: this explicit pool FIRST; otherwise the bundled shared pool (we cover it); on blocked/transport the run falls back to Apify datacenter, then Apify residential. With useApifyProxy off and no pool at all: single direct attempt.

## Actor input object example

```json
{
  "asins": [
    "B079VP6DH5"
  ],
  "startUrls": [
    "https://www.amazon.com/dp/B079VP6DH5"
  ],
  "marketplace": "com",
  "marketplaces": [],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "asins": [
        "B079VP6DH5"
    ],
    "startUrls": [
        "https://www.amazon.com/dp/B079VP6DH5"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cyprusapi/amazon-ai-summary").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": ["B079VP6DH5"],
    "startUrls": ["https://www.amazon.com/dp/B079VP6DH5"],
}

# Run the Actor and wait for it to finish
run = client.actor("cyprusapi/amazon-ai-summary").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": [
    "B079VP6DH5"
  ],
  "startUrls": [
    "https://www.amazon.com/dp/B079VP6DH5"
  ]
}' |
apify call cyprusapi/amazon-ai-summary --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cyprusapi/amazon-ai-summary"
        }
    }
}

```

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/2BYYF8uWRcIQT54tL/builds/VHHoVTliBa73NbCSu/openapi.json