# Amazon Reviews Scraper — Review Text, Ratings & ASIN Data (`jaybird/amazon-reviews-scraper`) Actor

Scrape Amazon product reviews into clean JSON: review text, title, star rating, date, verified-purchase flag, helpful votes, variant, and author — plus a per-ASIN ratings histogram. Look up by ASIN, product URL, or keyword search. Pay per review.

- **URL**: https://apify.com/jaybird/amazon-reviews-scraper.md
- **Developed by:** [Jaybird Technologies](https://apify.com/jaybird) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 results

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

Scrape **Amazon product reviews** into clean, structured JSON — **review text, title, star rating, date, verified-purchase & Vine flags, helpful votes, purchased variant, author, and customer photos/videos** — plus a **per-ASIN ratings histogram**, rating totals, and Amazon's **"Customers say" AI summary with aspect-sentiment breakdown**. Look products up by **ASIN**, **product URL**, or **keyword search**. A fast, reliable **Amazon review API** alternative for product research, sentiment analysis, and AI/RAG pipelines.

**Highlights:** 📸 image & video reviews · 🧠 "Customers say" AI sentiment · ⭐ filter by star / verified / media + sort · 🔎 look up by ASIN, URL **or keyword search** · 🛡️ 100% success, 0 blocked in testing · 🌍 9 marketplaces · 💵 from **$0.85 / 1,000 reviews**

### What you get

One dataset record per review. The product page's **"Top reviews"** come with author, verified-purchase flag, and helpful votes:

```json
{
    "recordType": "review",
    "asin": "B00P8XQPY4",
    "productTitle": "SANDISK 128GB Ultra USB 3.0 Flash Drive - SDCZ48-128G-U46, Black",
    "reviewId": "R2RLBBVMWSN16G",
    "title": "Great buy!",
    "text": "This is for recording off of the tv. Easy hookup to the firestick so I can record programs for later viewing. Data integrity is excellent, size is perfect. Works well.",
    "rating": 5,
    "date": "April 26, 2026",
    "country": "United States",
    "verifiedPurchase": true,
    "vineReview": false,
    "helpfulVotes": 2,
    "variant": "Style: Old Generation, Size: 64GB",
    "variantAsin": "B00P8XQPY4",
    "authorName": "Jim F",
    "authorProfileUrl": "https://www.amazon.com/gp/profile/amzn1.account.AGHBTTDMZVKKQICPPHE7V6PHZSYQ",
    "reviewerId": "amzn1.account.AGHBTTDMZVKKQICPPHE7V6PHZSYQ",
    "url": "https://www.amazon.com/dp/B00P8XQPY4",
    "scrapedAt": "2026-06-07T21:43:00.672Z"
}
````

…and **customer image & video reviews** from the product's media gallery come with the full review text plus links to the photos/videos:

```json
{
    "recordType": "review",
    "asin": "B07CMS5Q6P",
    "productTitle": "Logitech G305 Lightspeed Wireless Gaming Mouse",
    "reviewId": "R13QTYS7W4GQM5",
    "title": "Great mouse for a great price",
    "text": "Mouse works great. I used the logitech g pro (wired) for years…",
    "rating": 5,
    "date": "June 4, 2026",
    "country": "United States",
    "language": "en-US",
    "verifiedPurchase": true,
    "vineReview": false,
    "variantAsin": "B07CMS5Q6P",
    "authorName": "Petre I.",
    "reviewerId": "amzn1.account.AHYIRSGWL76KCXLNY52XP5JISWAQ",
    "mediaType": "IMAGE",
    "images": [
        "https://m.media-amazon.com/images/I/41W75UraVHL.jpg",
        "https://m.media-amazon.com/images/I/41Ko2z26ZSL.jpg"
    ],
    "url": "https://www.amazon.com/dp/B07CMS5Q6P",
    "scrapedAt": "2026-06-09T18:20:00.000Z"
}
```

Plus **one summary record per ASIN** with the full ratings breakdown **and Amazon's "Customers say" AI summary** (the overall paragraph plus the aspect-sentiment chips, each linked back to the reviews it was distilled from) — captured for every product, even ones whose individual reviews are sparse:

```json
{
    "recordType": "summary",
    "asin": "B092XZH6CB",
    "productTitle": "Retrospec Solana Yoga Mat 1\" Thick w/Nylon Strap",
    "averageRating": 4.5,
    "totalRatingCount": 14426,
    "ratingsHistogram": { "fiveStar": 77, "fourStar": 12, "threeStar": 5, "twoStar": 2, "oneStar": 4 },
    "customersSay": {
        "summary": "Customers like the yoga mat's thickness, finding it comfortable and protective for knees… Customers find the yoga mat to be well-made…",
        "aspects": [
            { "aspect": "thickness", "sentiment": "positive", "mentions": 1083, "positivePercentage": 83, "summary": "Customers like the yoga mat's thickness…", "reviewIds": ["R1D55FQFLOCNVM", "R23YRWH3Y0XR2C"] },
            { "aspect": "quality", "sentiment": "positive", "mentions": 826, "positivePercentage": 91, "summary": "Customers find the yoga mat to be well-made…", "reviewIds": ["RX3B4OFBLRSD", "R2MV83T8FA58ER"] }
        ]
    },
    "url": "https://www.amazon.com/dp/B092XZH6CB",
    "scrapedAt": "2026-06-09T18:20:00.000Z"
}
```

### Why this scraper

Amazon review scrapers are a graveyard of broken tools — the second most-popular Amazon-reviews Actor on the market runs at **~66% success**, so users routinely get partial dumps and silent failures. This Actor is built around the two things that actually matter: **getting real review volume anonymously**, and **coping with Amazon's anti-bot stack** — while being honest about what anonymous scraping can and can't reach.

- 📸 **Image & video reviews, in full.** On `amazon.com`, the Actor pulls every customer photo/video review from the product's media gallery — **dozens to hundreds for popular products** — each with its complete review text, rating, and media links. This is the real volume, and it needs no login.
- 🛡️ **Battle-tested anti-blocking.** Datacenter→residential proxy escalation (country-pinned to the marketplace), a session pool with per-session browser fingerprints, and retire-on-captcha — the same stack behind our Amazon Product Scraper. In a 20-product test it ran at **100% success, 0 blocked**.
- 📊 **Always get the histogram.** Every ASIN yields its full ratings distribution (5★→1★), average, and total rating count — even when review text is thin.
- 🧠 **"Customers say" AI summary, structured.** Every ASIN with enough reviews returns Amazon's own AI review summary plus an aspect-by-aspect sentiment breakdown — *build quality*, *value for money*, *battery life* — with mention counts, a positive-sentiment percentage, and links to the exact reviews behind each. Ready-made product insights, no LLM step on your side.
- 🔎 **Three ways in.** Look up by ASIN, paste product URLs, or run a keyword search and scrape the top results' reviews — keyword lookup that the major competitors don't offer.
- ⭐ **Filter and sort built in.** Keep only the star ratings you want, Verified-Purchase only, or photos/video only — and sort by most recent, most helpful, or rating. You're billed only for what's returned.
- ✅ **Honest, never login-based.** No fake "every review on a million-review product" promises, and no credential login that could get *your* account banned. See [what's reachable](#what-the-actor-can-reach-read-this).
- 🤖 **AI/agent ready.** Flat, predictable JSON drops straight into RAG pipelines, sentiment models, and agent tools.

### What the Actor can reach (read this)

Straight, no marketing:

- **"Top reviews"** Amazon renders on every product page — typically **~8–15 per ASIN**, a recent/most-helpful mix — with full text, rating, date, verified-purchase flag, helpful votes, variant, and author. Captured on **every marketplace**.
- **Customer image & video reviews** from the product's media gallery — **on `amazon.com`**. For products with lots of customer photos this is **dozens to hundreds** of additional reviews, each with its full text, rating, date, language, and photo/video links. Products without customer media return just the Top reviews. Turn this off with `includeMediaReviews: false` for a faster, cheaper Top-reviews-only run.
- **The ratings histogram and total rating count** — always, for every ASIN, regardless of how many individual reviews are reachable.
- **Amazon's "Customers say" AI summary and aspect-sentiment breakdown** — for ASINs with enough reviews for Amazon to generate one. Decoded straight from the product page (no extra request).

What it deliberately does **not** do:

- **It does not log in.** Amazon login-gates its dedicated `/product-reviews/` pages (deep text pagination with sort/star filters). Credential scraping violates Amazon's Terms of Service and risks getting *your* account banned — never worth it. So the **non-media** review text beyond the Top set isn't reachable anonymously, and on non-US marketplaces only the Top reviews are returned.

If a product has heavy customer-photo activity, expect a lot of reviews. If it has none, expect the Top set plus the histogram. Either way you get exactly what's there, reliably — and an honest picture of the rest.

### How to scrape Amazon reviews

1. Click **Try for free** / open the Actor.
2. Provide input one of three ways:
   - **ASINs** — paste 10-character product IDs (e.g. `B07DF46NW9`).
   - **Product URLs** — paste any `/dp/` or `/gp/product/` links.
   - **Keyword** — type a search term and set **Max products from search**.
3. Click **Start**, then **download** JSON, CSV, or Excel — or fetch via the API.

### Input examples

By ASIN:

```json
{ "asins": ["B07DF46NW9", "B00P8XQPY4"], "maxReviewsPerAsin": 100 }
```

By keyword search:

```json
{ "keyword": "wireless earbuds", "maxProducts": 5 }
```

By product URL on another marketplace:

```json
{ "productUrls": ["https://www.amazon.co.uk/dp/B07DF46NW9"], "domain": "amazon.co.uk" }
```

| Input | Description |
|---|---|
| `asins` | Array of ASINs (10-char product IDs). |
| `productUrls` | Array of Amazon `/dp/` or `/gp/product/` URLs (each keeps its own marketplace domain). |
| `keyword` + `maxProducts` | Search term and how many top results to scrape reviews for. |
| `maxReviewsPerAsin` | Cap on reviews per ASIN (default 100; `0` = no cap). Applied **after** filtering, so you get up to N matching reviews. |
| `includeMediaReviews` | Fetch customer image/video reviews from the media gallery (default `true`; `amazon.com` only). The main source of volume. |
| `reviewStars` | Only return reviews with these star ratings, e.g. `["5"]` or `["1","2"]`. Empty = all. |
| `verifiedOnly` | Only return Verified Purchase reviews (default `false`). |
| `mediaOnly` | Only return reviews with photos/video (default `false`). |
| `sortReviewsBy` | `default` (Amazon's order), `mostRecent`, `mostHelpful`, `highestRating`, or `lowestRating`. |
| `domain` | Marketplace for bare ASINs and keyword search (`amazon.com`, `.co.uk`, `.de`, `.ca`, `.com.au`, `.in`, `.fr`, `.it`, `.es`). |

> **Note on filters:** `reviewStars`, `verifiedOnly`, `mediaOnly`, and `sortReviewsBy` operate on the reviews reachable anonymously (Top reviews + media gallery) — they slice and order what's available; they don't unlock Amazon's deeper login-gated review pages. You're billed only for the reviews actually returned after filtering.

### What data can it extract?

| Field | Description |
|---|---|
| `asin`, `productTitle` | Product the review belongs to |
| `reviewId` | Amazon's stable review ID |
| `rating` | Star rating, 1–5 |
| `title`, `text` | Review headline and body |
| `date`, `country` | Review date and the country it was written in |
| `verifiedPurchase` | Whether Amazon marks it a Verified Purchase |
| `vineReview` | Whether it carries the "Vine Customer Review of Free Product" badge |
| `helpfulVotes` | "N people found this helpful" count (Top reviews) |
| `variant` | Purchased size/color/style, when shown |
| `variantAsin` | ASIN of the specific variant the review targets (can differ from the parent) |
| `authorName`, `authorProfileUrl` | Reviewer name and public profile link |
| `reviewerId` | Reviewer's stable Amazon account id (`amzn1.account.…`) |
| `images` | Customer photo/video URLs attached to the review (media-gallery reviews) |
| `mediaType` | `IMAGE` or `VIDEO` for media-gallery reviews |
| `language` | Review's source language, e.g. `en-US` (media-gallery reviews) |
| **Summary record** | `averageRating`, `totalRatingCount`, `ratingsHistogram` (5★→1★ percentages), and `customersSay` — one per ASIN |
| `customersSay` | Amazon's "Customers say" AI summary + aspect-sentiment breakdown: per aspect (e.g. *build quality*, *value for money*) a `sentiment`, `mentions` count, `positivePercentage`, one-line `summary`, and the `reviewIds` it was distilled from |

### How much will it cost?

Pay-per-event: **$0.00095 per review scraped — $0.95 per 1,000 reviews** — plus a negligible Actor-start fee ($0.00005 per run). Per-ASIN summary records are **free**. Higher Apify subscription tiers get progressively lower per-review prices (down to **$0.85 per 1,000**). Current prices are always on the **Pricing** tab.

Volume varies a lot by product — a popular item with hundreds of customer photos yields far more reviews (and costs more) than a niche one with none. Use `maxReviewsPerAsin` to bound spend precisely:

- **`maxReviewsPerAsin: 20`, 10 ASINs** ≈ up to 200 reviews ≈ **$0.19**.
- **Top reviews only** (`includeMediaReviews: false`) ≈ ~13/ASIN ≈ **$0.12 for 10 ASINs**.

Summary records, not-found ASINs, and blocked pages are never billed.

### Tips

- **Want maximum review volume?** Leave `includeMediaReviews` on and set a generous `maxReviewsPerAsin` (or `0` for no cap) — popular `amazon.com` products return dozens to hundreds of image/video reviews.
- **Want it fast and cheap?** Set `includeMediaReviews: false` for just the Top reviews and histogram.
- **Want just the ratings distribution, for free?** The summary record (histogram + totals) is always included and never billed. Schedule recurring runs with `maxReviewsPerAsin: 0` and `includeMediaReviews: false`… or read only the `summary` records.
- **Use `productUrls`** when you already have links; **use `keyword`** to discover products and pull their reviews in one run.

### Integrations

Export to **Google Sheets, Google Drive, S3**, or a database; automate with **Zapier, Make, and webhooks**; **schedule** recurring runs; or call it from anywhere via the **Apify API** and JS/Python SDKs.

### FAQ

**How many reviews can it get per product?** The product page's "Top reviews" (~8–15/ASIN, every marketplace) plus, on `amazon.com`, every customer image/video review from the media gallery — often dozens to hundreds for popular products, few or none for products without customer photos. Plus the full ratings histogram for every ASIN. See [what's reachable](#what-the-actor-can-reach-read-this).

**Can it get *every* review on a product?** No anonymous scraper can — Amazon login-gates deep text-review pagination. This Actor returns the Top reviews + all media-gallery reviews + the histogram, without logging in.

**Does it log into Amazon?** No. Credential login violates Amazon's ToS and risks an account ban. This Actor is anonymous-only by design.

**Which marketplaces work?** `amazon.com` and major locales (`.co.uk`, `.de`, `.ca`, `.com.au`, `.in`, `.fr`, `.it`, `.es`). Image/video media reviews are currently `amazon.com` only; other marketplaces return the Top reviews and histogram. Product URLs keep their own domain automatically.

**Can I scrape Amazon reviews by keyword?** Yes. Enter a search term and a `maxProducts` count, and the Actor finds the top matching products and pulls their reviews in one run — no ASINs needed. Most Amazon review scrapers only accept ASINs or URLs.

**Does it extract Amazon's "Customers say" AI summary?** Yes. Every product with enough reviews returns Amazon's own "Customers say" paragraph plus a structured aspect-sentiment breakdown (e.g. *build quality*, *value for money*) with mention counts, a positive-sentiment percentage, and the review IDs behind each — ready for sentiment analysis with no LLM step on your side.

**Can I filter reviews by star rating or verified purchase?** Yes. Use `reviewStars` (e.g. only 5-star or only 1–2-star), `verifiedOnly`, and `mediaOnly`, and order results with `sortReviewsBy` (most recent, most helpful, highest/lowest rating). Filtering happens before billing, so you only pay for the reviews returned.

**How do I export Amazon reviews to Excel or CSV?** Run the Actor, then download the dataset as **CSV, Excel, JSON, or XML** from the run's Storage tab — or pull it via the Apify API. You can also push results straight to Google Sheets, a database, or S3.

**Is it legal to scrape Amazon reviews?** This Actor extracts only publicly visible review data. Reviews can contain personal data (author names/profiles), which is protected by GDPR and similar laws — you're responsible for how you use the results; consult your lawyers if unsure.

### Changelog

**0.3 (June 2026)** — added Amazon's **"Customers say" AI summary + aspect-sentiment** breakdown (on the per-ASIN summary record), and review **filtering & sorting** (`reviewStars`, `verifiedOnly`, `mediaOnly`, `sortReviewsBy`). New review fields: `vineReview`, `variantAsin`, `reviewerId`, plus author/verified recovered on media reviews.

**0.2 (June 2026)** — added customer **image & video reviews** from the product media gallery (`amazon.com`), lifting per-product volume from ~13 to dozens/hundreds for popular items. New fields: `images`, `mediaType`, `language`. New input: `includeMediaReviews`.

**0.1 (June 2026)** — initial release: ASIN / product-URL / keyword lookup, product-page review extraction, per-ASIN ratings histogram + totals, residential-proxy escalation, and pay-per-event pricing.

Found a bug or need a field added? Open an issue on the **Issues** tab.

# Actor input Schema

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

Amazon Standard Identification Numbers (10-character product IDs, e.g. B07DF46NW9). Reviews are scraped for each ASIN.

## `productUrls` (type: `array`):

Amazon product page URLs (any /dp/ or /gp/product/ link). The ASIN is extracted from each URL.

## `keyword` (type: `string`):

A search term. The Actor finds the top products for this keyword and scrapes their reviews. Use with 'Max products from search'.

## `maxProducts` (type: `integer`):

When using a search keyword, how many of the top search-result products to scrape reviews for.

## `maxReviewsPerAsin` (type: `integer`):

Cap on reviews collected per ASIN. The Actor returns the product page's "Top reviews" plus all customer image/video reviews from the media gallery (on amazon.com this is often dozens to hundreds for popular products; few or none for products without customer photos). The ratings histogram and totals are always captured. Set 0 for no cap.

## `includeMediaReviews` (type: `boolean`):

Fetch the customer image/video reviews from the product's media gallery (amazon.com only; other marketplaces return Top reviews only). This is the main source of review volume. Turn off to return just the page's Top reviews, which is faster and cheaper.

## `reviewStars` (type: `array`):

Only return reviews with these star ratings. Leave empty to return all ratings. (Filters the reviews collected anonymously; it does not unlock additional login-gated reviews.)

## `verifiedOnly` (type: `boolean`):

Return only reviews marked "Verified Purchase".

## `mediaOnly` (type: `boolean`):

Return only reviews that include customer photos or video.

## `sortReviewsBy` (type: `string`):

Order of the returned reviews. "Amazon default" keeps the page's Top-reviews order followed by media-gallery reviews.

## `domain` (type: `string`):

The Amazon marketplace to scrape. Bare ASINs and keyword searches use this domain; full product URLs keep their own domain. More marketplaces can be added on request.

## Actor input object example

```json
{
  "asins": [
    "B07CMS5Q6P"
  ],
  "keyword": "wireless earbuds",
  "maxProducts": 5,
  "maxReviewsPerAsin": 100,
  "includeMediaReviews": true,
  "reviewStars": [],
  "verifiedOnly": false,
  "mediaOnly": false,
  "sortReviewsBy": "default",
  "domain": "amazon.com"
}
```

# Actor output Schema

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

No description

## `reviews` (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": [
        "B07CMS5Q6P"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("jaybird/amazon-reviews-scraper").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": [
    "B07CMS5Q6P"
  ]
}' |
apify call jaybird/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Reviews Scraper — Review Text, Ratings & ASIN Data",
        "description": "Scrape Amazon product reviews into clean JSON: review text, title, star rating, date, verified-purchase flag, helpful votes, variant, and author — plus a per-ASIN ratings histogram. Look up by ASIN, product URL, or keyword search. Pay per review.",
        "version": "0.3",
        "x-build-id": "s2CbC7orSJItDAdCG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jaybird~amazon-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jaybird-amazon-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/jaybird~amazon-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jaybird-amazon-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/jaybird~amazon-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jaybird-amazon-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "asins": {
                        "title": "ASINs",
                        "type": "array",
                        "description": "Amazon Standard Identification Numbers (10-character product IDs, e.g. B07DF46NW9). Reviews are scraped for each ASIN.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Amazon product page URLs (any /dp/ or /gp/product/ link). The ASIN is extracted from each URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "A search term. The Actor finds the top products for this keyword and scrapes their reviews. Use with 'Max products from search'."
                    },
                    "maxProducts": {
                        "title": "Max products from search",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "When using a search keyword, how many of the top search-result products to scrape reviews for.",
                        "default": 5
                    },
                    "maxReviewsPerAsin": {
                        "title": "Max reviews per ASIN",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on reviews collected per ASIN. The Actor returns the product page's \"Top reviews\" plus all customer image/video reviews from the media gallery (on amazon.com this is often dozens to hundreds for popular products; few or none for products without customer photos). The ratings histogram and totals are always captured. Set 0 for no cap.",
                        "default": 100
                    },
                    "includeMediaReviews": {
                        "title": "Include image & video reviews",
                        "type": "boolean",
                        "description": "Fetch the customer image/video reviews from the product's media gallery (amazon.com only; other marketplaces return Top reviews only). This is the main source of review volume. Turn off to return just the page's Top reviews, which is faster and cheaper.",
                        "default": true
                    },
                    "reviewStars": {
                        "title": "Filter by star rating",
                        "type": "array",
                        "description": "Only return reviews with these star ratings. Leave empty to return all ratings. (Filters the reviews collected anonymously; it does not unlock additional login-gated reviews.)",
                        "items": {
                            "type": "string",
                            "enum": [
                                "5",
                                "4",
                                "3",
                                "2",
                                "1"
                            ],
                            "enumTitles": [
                                "5 stars",
                                "4 stars",
                                "3 stars",
                                "2 stars",
                                "1 star"
                            ]
                        },
                        "default": []
                    },
                    "verifiedOnly": {
                        "title": "Verified purchases only",
                        "type": "boolean",
                        "description": "Return only reviews marked \"Verified Purchase\".",
                        "default": false
                    },
                    "mediaOnly": {
                        "title": "Reviews with photos/video only",
                        "type": "boolean",
                        "description": "Return only reviews that include customer photos or video.",
                        "default": false
                    },
                    "sortReviewsBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "default",
                            "mostRecent",
                            "mostHelpful",
                            "highestRating",
                            "lowestRating"
                        ],
                        "type": "string",
                        "description": "Order of the returned reviews. \"Amazon default\" keeps the page's Top-reviews order followed by media-gallery reviews.",
                        "default": "default"
                    },
                    "domain": {
                        "title": "Amazon domain (marketplace)",
                        "enum": [
                            "amazon.com",
                            "amazon.co.uk",
                            "amazon.de",
                            "amazon.ca",
                            "amazon.com.au",
                            "amazon.in",
                            "amazon.fr",
                            "amazon.it",
                            "amazon.es"
                        ],
                        "type": "string",
                        "description": "The Amazon marketplace to scrape. Bare ASINs and keyword searches use this domain; full product URLs keep their own domain. More marketplaces can be added on request.",
                        "default": "amazon.com"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
