# Amazon Product Scraper (`jdtpnjtp/amazon-products`) Actor

Scrape Amazon products, prices, offers, sellers, bestsellers and deals in one run. ASINs, search queries, seller IDs, category node IDs or URLs in - clean structured rows out. Pay only per result, no subscription.

- **URL**: https://apify.com/jdtpnjtp/amazon-products.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 Product Scraper

**Get live Amazon product, price, offers, bestseller and deal data in clean JSON.** Feed it ASINs, search keywords, seller IDs, category node IDs or paste Amazon URLs, pick your data types, and export ready-to-use structured rows. Eleven search filters, eight marketplaces, full per-seller offer breakdowns and merchant profiles. No subscription, pay only per result.

---

### What this actor does

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

- 🔎 **Products (search + category)** - search any keyword (paginated to your cap) or browse a category node: title, price, list price, rating, review count, brand, image, Prime badge, URL
- 📦 **Product detail (by ASIN)** - the full product page: specs, variations, all images, bullet points, description, bestseller rank (everything in the `data` payload)
- 🏷 **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), optionally their whole catalog
- 🏆 **Bestsellers** - ranked category lists
- 🆕 **New releases** - the newest products by category
- 🔥 **Deals** - lightning deals, coupons, premium-brand and Amazon-brand deals, filtered by department, discount % and Prime

Flip on **Fan out search results to full product detail** and every search / category / seller-products result is enriched with its full product page.

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

**Eleven search filters** are built in: sort order, restrict-to-category, brand, min price, max price, minimum rating, Prime-only, item condition, discount filter, plus the deals department / discount / Prime filters. No internal IDs to look up - search a keyword like a human and the filters do the rest.

### Input

```json
{
  "searchQueries": ["wireless earbuds"],
  "asins": ["B0CHX1W1XY"],
  "dataTypes": ["search", "product"],
  "country": "us",
  "maxResultsPerType": 20,
  "sortBy": "PRICE_LOW_TO_HIGH",
  "minPrice": 20,
  "maxPrice": 200,
  "isPrime": true,
  "includeProductDetails": false
}
````

| Field | What it does |
|---|---|
| **Search queries** | Keyword searches, paginated to the per-type cap. |
| **ASINs** | Product IDs to pull as full detail (and offers, if requested). |
| **Seller IDs** | Merchant IDs to pull as seller profiles (+ their catalog, optionally). |
| **Category node IDs** | Numeric category nodes to browse page by page. |
| **Start URLs** | Paste any Amazon URL (product / search / bestseller / seller / offers) to parse directly. |
| **Data types** | Multi-select: search, product, offers, sellers, bestsellers, newReleases, deals (default: search + product). |
| **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. |
| **Search filters** | Sort, restrict-to-category, brand, min/max price, min rating, Prime, condition, discount filter. |
| **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 **four ready-made table tabs** - **Overview**, **Products**, **Offers**, **Sellers** - so each vertical reads as a clean spreadsheet you can sort, filter and export to CSV / Excel / JSON in one click.

A real search-result row:

```json
{
  "query": "wireless earbuds",
  "row_type": "search_result",
  "asin": "B0CHX1W1XY",
  "title": "Wireless Earbuds Bluetooth 5.3 Headphones",
  "price": "39.99 USD",
  "original_price": "59.99 USD",
  "rating": 4.4,
  "review_count": 12834,
  "brand": "Acme",
  "is_prime": true,
  "url": "https://www.amazon.com/dp/B0CHX1W1XY",
  "image_url": "https://m.media-amazon.com/images/I/61abc.jpg",
  "country": "us",
  "seller_id": null,
  "rank": null,
  "discount_percent": 33,
  "data": { "...": "full listing object" }
}
```

Console columns include `asin`, `title`, `price`, `original_price`, `rating`, `review_count`, `is_prime`, `url` for products; `price`, `condition`, `seller_name`, `seller_rating`, `is_buybox`, `ships_from`, `delivery_info` for offers; and `seller_id`, `seller_name`, `rating`, `rating_count`, `positive_feedback_pct`, `business_name`, `business_address` on the Sellers tab. 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

- **Product, offers, sellers and deals in one run** - search, product detail, offers, seller profiles, bestsellers, new releases, deals.
- **8 marketplaces** - us, uk, de, fr, it, es, ca, jp.
- **Eleven search filters** - sort, brand, price, rating, Prime, condition, discount. No internal IDs to look up.
- **Keywords, ASINs, category nodes or URLs** - search a whole catalog, fetch exact products, browse a department, or paste pages. All in one actor.
- **Full offer + seller intelligence** - every seller offer for an ASIN, full merchant profiles with feedback breakdowns.
- **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

## `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. Optional if you provide ASINs / URLs / seller IDs / category IDs.

## `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 **Offers** is selected, every seller offer for it is pulled too. Optional if you provide search queries / URLs.

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

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

## `categoryNodeIds` (type: `array`):

Amazon category node IDs (numeric, e.g. `172282`). Each is browsed page by page up to the per-type cap and returns its product listings. Runs when **Products (search + category)** is selected.

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

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

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

Which Amazon verticals to pull. 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, products per category, offers 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.

## `sortBy` (type: `string`):

Order of keyword-search and category-browse results.

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

Optional Amazon category node ID to restrict keyword searches to a department (different from the Category node IDs input, which browses a category directly).

## `brand` (type: `string`):

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

## `minPrice` (type: `integer`):

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

## `maxPrice` (type: `integer`):

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

## `minRating` (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.

## `isPrime` (type: `boolean`):

Keep only Prime-eligible search results.

## `productCondition` (type: `string`):

Filter search results by item condition.

## `dealsAndDiscounts` (type: `string`):

Restrict keyword-search results to discounted / today's-deal items.

## `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 and 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 (you can also select 'New releases' in Data types directly).

## `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
{
  "searchQueries": [
    "wireless earbuds"
  ],
  "asins": [
    "B0CHX1W1XY"
  ],
  "sellerIds": [],
  "categoryNodeIds": [],
  "startUrls": [],
  "dataTypes": [
    "search",
    "product"
  ],
  "country": "us",
  "maxResultsPerType": 20,
  "includeProductDetails": false,
  "sortBy": "RELEVANCE",
  "minRating": "",
  "isPrime": false,
  "productCondition": "ALL",
  "dealsAndDiscounts": "NONE",
  "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 / Offers / Sellers 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, offers, seller\_profiles), 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 = {
    "searchQueries": [
        "wireless earbuds"
    ],
    "asins": [
        "B0CHX1W1XY"
    ],
    "sellerIds": [],
    "categoryNodeIds": [],
    "startUrls": [],
    "dataTypes": [
        "search",
        "product"
    ],
    "maxResultsPerType": 20,
    "bestsellersCategory": "electronics"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Scraper",
        "description": "Scrape Amazon products, prices, offers, sellers, bestsellers and deals in one run. ASINs, search queries, seller IDs, category node IDs or URLs in - clean structured rows out. Pay only per result, no subscription.",
        "version": "1.0",
        "x-build-id": "7GxjPn0AikptXuDHn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jdtpnjtp~amazon-products/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jdtpnjtp-amazon-products",
                "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-products/runs": {
            "post": {
                "operationId": "runs-sync-jdtpnjtp-amazon-products",
                "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-products/run-sync": {
            "post": {
                "operationId": "run-sync-jdtpnjtp-amazon-products",
                "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": {
                    "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. Optional if you provide ASINs / URLs / seller IDs / category IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "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 **Offers** is selected, every seller offer for it is pulled too. Optional if you provide search queries / URLs.",
                        "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 list each seller's products' to list each seller's catalog too.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryNodeIds": {
                        "title": "Category node IDs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Amazon category node IDs (numeric, e.g. `172282`). Each is browsed page by page up to the per-type cap and returns its product listings. Runs when **Products (search + category)** is selected.",
                        "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 or an offer-listing. Each is auto-detected and parsed into its own row(s), independent of the data types below. (Review URLs are not handled here - use the Amazon Reviews actor.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dataTypes": {
                        "title": "Data types to scrape",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which Amazon verticals to pull. 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": [
                                "search",
                                "product",
                                "offers",
                                "sellers",
                                "bestsellers",
                                "newReleases",
                                "deals"
                            ],
                            "enumTitles": [
                                "🔎 Products (search + category)",
                                "📦 Product detail (by ASIN)",
                                "🏷 Offers (all sellers for an ASIN)",
                                "🏪 Sellers (merchant profiles)",
                                "🏆 Bestsellers",
                                "🆕 New releases",
                                "🔥 Deals"
                            ]
                        },
                        "default": [
                            "search",
                            "product",
                            "offers",
                            "sellers",
                            "bestsellers",
                            "newReleases",
                            "deals"
                        ]
                    },
                    "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, products per category, offers 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
                    },
                    "sortBy": {
                        "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 and category-browse results.",
                        "default": "RELEVANCE"
                    },
                    "searchCategoryId": {
                        "title": "Restrict search to category node ID",
                        "type": "string",
                        "description": "Optional Amazon category node ID to restrict keyword searches to a department (different from the Category node IDs input, which browses a category directly)."
                    },
                    "brand": {
                        "title": "Brand filter",
                        "type": "string",
                        "description": "Restrict results to one or more brands (comma-separated)."
                    },
                    "minPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter (whole units of the marketplace currency)."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter (whole units of the marketplace currency)."
                    },
                    "minRating": {
                        "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": ""
                    },
                    "isPrime": {
                        "title": "Prime eligible only",
                        "type": "boolean",
                        "description": "Keep only Prime-eligible search results.",
                        "default": false
                    },
                    "productCondition": {
                        "title": "Item condition",
                        "enum": [
                            "ALL",
                            "NEW",
                            "USED",
                            "RENEWED",
                            "COLLECTIBLE"
                        ],
                        "type": "string",
                        "description": "Filter search results by item condition.",
                        "default": "ALL"
                    },
                    "dealsAndDiscounts": {
                        "title": "Discount filter (search)",
                        "enum": [
                            "NONE",
                            "ALL_DISCOUNTS",
                            "TODAYS_DEALS"
                        ],
                        "type": "string",
                        "description": "Restrict keyword-search results to discounted / today's-deal items.",
                        "default": "NONE"
                    },
                    "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 / new releases category",
                        "type": "string",
                        "description": "Category slug for the bestsellers and new-releases lists (e.g. electronics, books, toys, kitchen).",
                        "default": "electronics"
                    },
                    "includeNewReleases": {
                        "title": "Also pull new releases with bestsellers",
                        "type": "boolean",
                        "description": "When on, the new-releases list for the same category is pulled alongside the bestsellers list (you can also select 'New releases' in Data types directly).",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
