# Amazon Real-time Scraper (`jdtpnjtp/amazon`) Actor

Scrape Amazon products, full customer reviews (NO login / NO cookie), offers, sellers, bestsellers, deals and influencer storefronts in one run. ASINs, search queries or URLs in - clean structured rows out. Pay only per result, no subscription.

- **URL**: https://apify.com/jdtpnjtp/amazon.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 product 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 Real-time Scraper

**Scrape Amazon products, prices, offers, sellers, bestsellers, deals, influencer storefronts and customer reviews - all from one actor.** Feed it ASINs, search keywords, seller IDs, influencer usernames or raw Amazon URLs, tick the data types you want, and export clean structured rows across 8 marketplaces. Cached responses come back fast (competitors scrape live at 3+ seconds); you pay only per result, no subscription.

---

### What this actor does

Feed it any mix of ASINs, search keywords, seller IDs, influencer usernames, or Amazon URLs, tick the data types you want, and it pulls up to **seven verticals** in one run:

- 📦 **Products** - search any keyword (paginated to your cap) or fetch a full product page by ASIN: title, price, list price, rating, review count, brand, variations, all images, bullet points, description, bestseller rank
- 📝 **Reviews** - hundreds of real customer reviews per product across all five star ratings (deduped, newest-first): rating, title, text, author, date, verified-purchase flag, Vine flag, helpful votes, country, photos
- 🏷 **Offers** - every seller offer for an ASIN: price, condition, seller, seller rating, Buy Box flag, ships-from, delivery
- 🏪 **Sellers** - merchant profiles: rating, rating count, positive-feedback %, business name and address, ships-from (plus the full feedback breakdown in the `data` payload)
- 🏆 **Bestsellers / new releases** - ranked category lists
- 🔥 **Deals** - lightning deals, coupons, premium-brand and Amazon-brand deals, filtered by department, discount % and Prime
- 🌟 **Influencer storefronts** - creator profiles and their recommended products

Flip on **Fan out search results to full product detail** and every search / category / seller-products result is enriched with its full product page. Flip on **Also harvest reviews for every product** and reviews are pulled for every ASIN you supply AND every product your searches return.

Already have specific pages? Paste them into **Start URLs** - a product, search, bestseller, new-releases, seller, offer-listing or reviews URL is auto-detected and parsed directly.

### Input

```json
{
  "asins": ["B0CHX1W1XY"],
  "searchQueries": ["wireless earbuds"],
  "dataTypes": ["products", "reviews"],
  "country": "us",
  "maxResultsPerType": 20,
  "includeReviews": true,
  "reviewStarFilter": "all_stars",
  "reviewSort": "recent"
}
````

| Field | What it does |
|---|---|
| **ASINs** | Product IDs to pull as full detail (and reviews, if requested). |
| **Search queries** | Keyword searches, paginated to the per-type cap. |
| **Start URLs** | Paste any Amazon URL (product / search / bestseller / seller / reviews) to parse directly. |
| **Seller IDs** | Merchant IDs to pull as seller profiles (+ their catalog, optionally). |
| **Influencer usernames** | Creator storefronts to pull as profile + recommended products. |
| **Data types** | Multi-select: products, reviews, offers, sellers, bestsellers, deals, influencers (default: all). |
| **Country** | Amazon marketplace: us, uk, de, fr, it, es, ca, jp. |
| **Max results per type** | Cap per vertical / input item. Search paginates Amazon to reach it. |
| **Fan out to product detail** | Enrich every listing result with its full product page. Extra charge per detail. |
| **Also harvest reviews** | Pull reviews for every ASIN and every searched product. |
| **Review star filter / sort** | all\_stars / five\_star / .../ positive / critical, recent or helpful. |
| **Search filters** | Sort, category, brand, min/max price, min rating, Prime, condition. |
| **Deals filters** | Deal type, department, minimum discount %, Prime-exclusive. |

### Output

One flat row per result, discriminated by `row_type`, with the full payload under `data`. The dataset ships with **six ready-made table tabs** - **Overview**, **Products**, **Reviews**, **Offers**, **Sellers**, **Influencers** - so each vertical reads as a clean spreadsheet you can sort, filter and export to CSV / Excel / JSON in one click.

A real review row:

```json
{
  "query": "B0CHX1W1XY",
  "row_type": "review",
  "asin": "B0CHX1W1XY",
  "review_title": "Best earbuds I've owned",
  "review_text": "Battery life is excellent and the noise cancelling is...",
  "review_rating": 5,
  "review_author": "Jordan M.",
  "review_date": "March 14, 2026",
  "verified_purchase": true,
  "vine": false,
  "helpful_count": 12,
  "review_country": "us",
  "data": { "...": "full review object" }
}
```

Console columns include `asin`, `title`, `price`, `rating`, `review_count`, `url` for products; `review_rating`, `review_title`, `review_text`, `review_author`, `verified_purchase`, `helpful_count` for reviews; `price`, `condition`, `seller_name`, `is_buybox` for offers; and seller / influencer columns on their tabs. Error rows carry an `error_code` and are **free** - you only pay for real results.

A run-summary record (`OUTPUT` key) reports per-vertical counts and the estimated cost. Live per-event pricing is shown on this actor's Apify Store page.

### Why this actor

- **7 verticals in one run** - products, reviews, offers, sellers, bestsellers, deals, influencers.
- **Hundreds of reviews per product** - across all five star ratings, deduped and newest-first, as structured rows.
- **Fast cached responses** - repeat queries return in well under a second; competitors scrape live at 3+ seconds.
- **8 marketplaces** - us, uk, de, fr, it, es, ca, jp.
- **Every search filter** - sort, brand, price, rating, Prime, condition. No internal IDs to look up.
- **ASINs, keywords or URLs** - search a whole catalog, fetch exact products, or paste pages. All in one actor.
- **Clean per-vertical tabs** - export-ready tables, not a wall of mixed columns.
- **You only pay for results** - errors and your own misconfigurations are never charged.

### Need help? Enterprise plans? Custom scraping?

I personally support every customer - drop a message on any channel.

[![Telegram](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge\&logo=telegram\&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-25D366?style=for-the-badge\&logo=whatsapp\&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-D14836?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

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

Amazon products by ASIN or product URL (the 10-char code in any /dp/ link, e.g. `B0CHX1W1XY`, or paste the full URL). Each is pulled as a full product detail; when **Reviews** is selected, its reviews are pulled too. Optional if you provide search queries / URLs.

## `searchQueries` (type: `array`):

Keyword searches (e.g. `wireless earbuds`, `4k monitor`). Each query is paginated up to the per-type cap below. Apply the search filters (sort, price, brand, Prime, condition, rating) in the Search options section.

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

Paste any Amazon URL - a product (/dp/), a search results page (/s?k=), a bestseller / new-releases list, a seller page, an offer-listing or a reviews page. Each is auto-detected and parsed into its own row(s), independent of the data types below.

## `sellerIds` (type: `array`):

Amazon merchant IDs (e.g. `A2L77EE7U53NWQ`). Pulled as seller profiles when **Sellers** is selected. Turn on 'Also fetch seller products' to list each seller's catalog too.

## `influencerUsernames` (type: `array`):

Amazon influencer / creator storefront usernames (e.g. `mkbhd`). Pulled as a profile + recommended products when **Influencers** is selected.

## `dataTypes` (type: `array`):

Which Amazon verticals to pull. Defaults to all. Each type runs only when you supply matching input (e.g. Offers needs ASINs, Sellers needs Seller IDs). Start URLs always run regardless of this selection.

## `country` (type: `string`):

Which Amazon marketplace to scrape.

## `maxResultsPerType` (type: `integer`):

Upper bound on results pulled for EACH vertical / input item (search results per query, reviews per ASIN, seller products per seller, etc.). 20 = quick sample, 100 = solid dataset. Search paginates Amazon under the hood to reach this number.

## `includeProductDetails` (type: `boolean`):

When on, every product from a search / category / seller-products row is enriched with a second call that pulls its full product page (specs, variations, all images, description, bestseller rank). **This adds a `product-detail` charge per result on top of the listing event.** Leave off for a fast, cheap listing-only run.

## `includeReviews` (type: `boolean`):

When on, reviews are pulled for every ASIN you supply AND every product returned by your searches. If you tick the **Reviews** data type this is implied. Each review billed as one `review` event.

## `reviewStarFilter` (type: `string`):

Which reviews to keep. Default returns the deduped set across all star ratings; pick a single rating or sentiment to narrow it.

## `reviewSort` (type: `string`):

Order of harvested reviews.

## `searchSortBy` (type: `string`):

Order of keyword-search results.

## `searchCategoryId` (type: `string`):

Optional Amazon category node ID to restrict the search to a department.

## `searchBrand` (type: `string`):

Restrict results to one or more brands (comma-separated).

## `searchMinPrice` (type: `integer`):

Minimum price filter (whole units of the marketplace currency).

## `searchMaxPrice` (type: `integer`):

Maximum price filter (whole units of the marketplace currency).

## `searchMinRating` (type: `string`):

Keep only products at or above this average review. Amazon's SERP exposes only a '4 stars & up' facet, so values >= 4 apply it; lower values are not applied.

## `searchIsPrime` (type: `boolean`):

Keep only Prime-eligible search results.

## `searchCondition` (type: `string`):

Filter search results by item condition.

## `includeSellerProducts` (type: `boolean`):

When on, each Seller ID also returns that seller's product catalog (paginated to the per-type cap), each as a `product-result` row.

## `bestsellersCategory` (type: `string`):

Category slug for the bestsellers / new-releases lists (e.g. electronics, books, toys, kitchen).

## `includeNewReleases` (type: `boolean`):

When on, the new-releases list for the same category is pulled alongside the bestsellers list.

## `dealsCategory` (type: `string`):

Which deals to pull.

## `dealsDepartmentId` (type: `string`):

Optional Amazon department node ID to scope the deals (e.g. 16333373011).

## `dealsDiscountMin` (type: `integer`):

Keep only deals at or above this discount percentage.

## `dealsIsPrime` (type: `boolean`):

Keep only Prime-exclusive deals.

## `stopOnError` (type: `boolean`):

If on, the run aborts as soon as one vertical / URL fails (e.g. UPSTREAM\_BLOCKED). If off (default), the failure is logged with a free diagnostic row and the run continues.

## Actor input object example

```json
{
  "asins": [
    "B0CHX1W1XY"
  ],
  "searchQueries": [
    "wireless earbuds"
  ],
  "startUrls": [],
  "sellerIds": [],
  "influencerUsernames": [],
  "dataTypes": [
    "products",
    "reviews"
  ],
  "country": "us",
  "maxResultsPerType": 20,
  "includeProductDetails": false,
  "includeReviews": false,
  "reviewStarFilter": "all_stars",
  "reviewSort": "recent",
  "searchSortBy": "RELEVANCE",
  "searchMinRating": "",
  "searchIsPrime": false,
  "searchCondition": "ALL",
  "includeSellerProducts": false,
  "bestsellersCategory": "electronics",
  "includeNewReleases": false,
  "dealsCategory": "all",
  "dealsIsPrime": false,
  "stopOnError": false
}
```

# Actor output Schema

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

The default dataset. Each row carries one result discriminated by row\_type, with common fields flattened to top-level columns and the full payload under `data`. Use the Overview / Products / Reviews / Offers / Sellers / Influencers tabs to view per-vertical tables.

## `summary` (type: `string`):

A single JSON object written to the default key-value store under the OUTPUT key. Contains per-vertical counts (product\_results, product\_details, reviews, offers, seller\_profiles, influencer\_rows), total\_rows, errors, estimated\_cost\_usd, limit\_reached, and actor\_version.

# 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": [
        "B0CHX1W1XY"
    ],
    "searchQueries": [
        "wireless earbuds"
    ],
    "startUrls": [],
    "sellerIds": [],
    "influencerUsernames": [],
    "dataTypes": [
        "products",
        "reviews"
    ],
    "maxResultsPerType": 20,
    "bestsellersCategory": "electronics"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/amazon").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": ["B0CHX1W1XY"],
    "searchQueries": ["wireless earbuds"],
    "startUrls": [],
    "sellerIds": [],
    "influencerUsernames": [],
    "dataTypes": [
        "products",
        "reviews",
    ],
    "maxResultsPerType": 20,
    "bestsellersCategory": "electronics",
}

# Run the Actor and wait for it to finish
run = client.actor("jdtpnjtp/amazon").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": [
    "B0CHX1W1XY"
  ],
  "searchQueries": [
    "wireless earbuds"
  ],
  "startUrls": [],
  "sellerIds": [],
  "influencerUsernames": [],
  "dataTypes": [
    "products",
    "reviews"
  ],
  "maxResultsPerType": 20,
  "bestsellersCategory": "electronics"
}' |
apify call jdtpnjtp/amazon --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Real-time Scraper",
        "description": "Scrape Amazon products, full customer reviews (NO login / NO cookie), offers, sellers, bestsellers, deals and influencer storefronts in one run. ASINs, search queries or URLs in - clean structured rows out. Pay only per result, no subscription.",
        "version": "1.0",
        "x-build-id": "6yKnFarmTeNZ85PIY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jdtpnjtp~amazon/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jdtpnjtp-amazon",
                "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/jdtpnjtp~amazon/runs": {
            "post": {
                "operationId": "runs-sync-jdtpnjtp-amazon",
                "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/jdtpnjtp~amazon/run-sync": {
            "post": {
                "operationId": "run-sync-jdtpnjtp-amazon",
                "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 or URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Amazon products by ASIN or product URL (the 10-char code in any /dp/ link, e.g. `B0CHX1W1XY`, or paste the full URL). Each is pulled as a full product detail; when **Reviews** is selected, its reviews are pulled too. Optional if you provide search queries / URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keyword searches (e.g. `wireless earbuds`, `4k monitor`). Each query is paginated up to the per-type cap below. Apply the search filters (sort, price, brand, Prime, condition, rating) in the Search options section.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Paste any Amazon URL - a product (/dp/), a search results page (/s?k=), a bestseller / new-releases list, a seller page, an offer-listing or a reviews page. Each is auto-detected and parsed into its own row(s), independent of the data types below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerIds": {
                        "title": "Seller IDs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Amazon merchant IDs (e.g. `A2L77EE7U53NWQ`). Pulled as seller profiles when **Sellers** is selected. Turn on 'Also fetch seller products' to list each seller's catalog too.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "influencerUsernames": {
                        "title": "Influencer usernames",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Amazon influencer / creator storefront usernames (e.g. `mkbhd`). Pulled as a profile + recommended products when **Influencers** is selected.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dataTypes": {
                        "title": "Data types to scrape",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which Amazon verticals to pull. Defaults to all. Each type runs only when you supply matching input (e.g. Offers needs ASINs, Sellers needs Seller IDs). Start URLs always run regardless of this selection.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "products",
                                "reviews",
                                "offers",
                                "sellers",
                                "bestsellers",
                                "deals",
                                "influencers"
                            ],
                            "enumTitles": [
                                "📦 Products (search + ASIN detail)",
                                "📝 Reviews (across all star ratings)",
                                "🏷 Offers (all sellers for an ASIN)",
                                "🏪 Sellers (merchant profiles)",
                                "🏆 Bestsellers / new releases",
                                "🔥 Deals",
                                "🌟 Influencer storefronts"
                            ]
                        },
                        "default": [
                            "products",
                            "reviews",
                            "offers",
                            "sellers",
                            "bestsellers",
                            "deals",
                            "influencers"
                        ]
                    },
                    "country": {
                        "title": "Country (Amazon marketplace)",
                        "enum": [
                            "us",
                            "uk",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "ca",
                            "jp"
                        ],
                        "type": "string",
                        "description": "Which Amazon marketplace to scrape.",
                        "default": "us"
                    },
                    "maxResultsPerType": {
                        "title": "Max results per type",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Upper bound on results pulled for EACH vertical / input item (search results per query, reviews per ASIN, seller products per seller, etc.). 20 = quick sample, 100 = solid dataset. Search paginates Amazon under the hood to reach this number.",
                        "default": 50
                    },
                    "includeProductDetails": {
                        "title": "Fan out search results to full product detail",
                        "type": "boolean",
                        "description": "When on, every product from a search / category / seller-products row is enriched with a second call that pulls its full product page (specs, variations, all images, description, bestseller rank). **This adds a `product-detail` charge per result on top of the listing event.** Leave off for a fast, cheap listing-only run.",
                        "default": false
                    },
                    "includeReviews": {
                        "title": "Also harvest reviews for every product",
                        "type": "boolean",
                        "description": "When on, reviews are pulled for every ASIN you supply AND every product returned by your searches. If you tick the **Reviews** data type this is implied. Each review billed as one `review` event.",
                        "default": false
                    },
                    "reviewStarFilter": {
                        "title": "Review star filter",
                        "enum": [
                            "all_stars",
                            "five_star",
                            "four_star",
                            "three_star",
                            "two_star",
                            "one_star",
                            "positive",
                            "critical"
                        ],
                        "type": "string",
                        "description": "Which reviews to keep. Default returns the deduped set across all star ratings; pick a single rating or sentiment to narrow it.",
                        "default": "all_stars"
                    },
                    "reviewSort": {
                        "title": "Review sort",
                        "enum": [
                            "recent",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Order of harvested reviews.",
                        "default": "recent"
                    },
                    "searchSortBy": {
                        "title": "Search sort order",
                        "enum": [
                            "RELEVANCE",
                            "PRICE_LOW_TO_HIGH",
                            "PRICE_HIGH_TO_LOW",
                            "BEST_SELLER",
                            "NEWEST",
                            "AVG_REVIEW"
                        ],
                        "type": "string",
                        "description": "Order of keyword-search results.",
                        "default": "RELEVANCE"
                    },
                    "searchCategoryId": {
                        "title": "Category node ID",
                        "type": "string",
                        "description": "Optional Amazon category node ID to restrict the search to a department."
                    },
                    "searchBrand": {
                        "title": "Brand filter",
                        "type": "string",
                        "description": "Restrict results to one or more brands (comma-separated)."
                    },
                    "searchMinPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter (whole units of the marketplace currency)."
                    },
                    "searchMaxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter (whole units of the marketplace currency)."
                    },
                    "searchMinRating": {
                        "title": "Minimum customer rating",
                        "enum": [
                            "",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Keep only products at or above this average review. Amazon's SERP exposes only a '4 stars & up' facet, so values >= 4 apply it; lower values are not applied.",
                        "default": ""
                    },
                    "searchIsPrime": {
                        "title": "Prime eligible only",
                        "type": "boolean",
                        "description": "Keep only Prime-eligible search results.",
                        "default": false
                    },
                    "searchCondition": {
                        "title": "Item condition",
                        "enum": [
                            "ALL",
                            "NEW",
                            "USED",
                            "RENEWED",
                            "COLLECTIBLE"
                        ],
                        "type": "string",
                        "description": "Filter search results by item condition.",
                        "default": "ALL"
                    },
                    "includeSellerProducts": {
                        "title": "Also list each seller's products",
                        "type": "boolean",
                        "description": "When on, each Seller ID also returns that seller's product catalog (paginated to the per-type cap), each as a `product-result` row.",
                        "default": false
                    },
                    "bestsellersCategory": {
                        "title": "Bestsellers category",
                        "type": "string",
                        "description": "Category slug for the bestsellers / new-releases lists (e.g. electronics, books, toys, kitchen).",
                        "default": "electronics"
                    },
                    "includeNewReleases": {
                        "title": "Also pull new releases",
                        "type": "boolean",
                        "description": "When on, the new-releases list for the same category is pulled alongside the bestsellers list.",
                        "default": false
                    },
                    "dealsCategory": {
                        "title": "Deals type",
                        "enum": [
                            "all",
                            "lightning-deals",
                            "coupons",
                            "premium-brands",
                            "amazon-brands"
                        ],
                        "type": "string",
                        "description": "Which deals to pull.",
                        "default": "all"
                    },
                    "dealsDepartmentId": {
                        "title": "Deals department node ID",
                        "type": "string",
                        "description": "Optional Amazon department node ID to scope the deals (e.g. 16333373011)."
                    },
                    "dealsDiscountMin": {
                        "title": "Minimum discount %",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Keep only deals at or above this discount percentage."
                    },
                    "dealsIsPrime": {
                        "title": "Prime exclusive deals only",
                        "type": "boolean",
                        "description": "Keep only Prime-exclusive deals.",
                        "default": false
                    },
                    "stopOnError": {
                        "title": "Stop the whole run on the first error",
                        "type": "boolean",
                        "description": "If on, the run aborts as soon as one vertical / URL fails (e.g. UPSTREAM_BLOCKED). If off (default), the failure is logged with a free diagnostic row and the run continues.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
