# Amazon Search Scraper · 20 Marketplaces (`santamaria-automations/amazon-search-scraper`) Actor

Extract Amazon search results by keyword or /s?k= URL across 20 marketplaces. Returns ASIN, title, price, list price, stars, reviews, sponsored / Prime / Amazon's Choice / Best Seller flags, delivery promise, coupon, purchase volume and page position. Pay-per-result, no login.

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

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Search Scraper

Extract Amazon search results by keyword or `/s?k=...` URL across 20 marketplaces. Returns ASIN, title, price, list price, stars, review count, Prime / sponsored / Amazon's Choice / Best Seller flags, delivery promise, coupon, purchase volume, page position and more. Pay-per-result, no login required.

### What it does

You give it Amazon search keywords or direct search URLs. You get back clean, structured JSON, one row per search result.

- Search by keyword list (each keyword runs a separate search) or by direct `/s?k=...` URLs
- Paginate up to 20 pages per keyword (around 16 organic rows per page)
- Filter by price range, minimum stars, Prime-only (US in v1)
- Pick the Amazon sort order: relevance, price ascending or descending, average customer review, newest arrivals, featured
- Optionally drop sponsored rows from the output
- Every row carries the keyword that surfaced it, the page number, and the slot position

#### Sample output

```json
{
  "asin": "B09B8V1LZ3",
  "title": "Amazon Echo Dot (5th Gen, 2022 release) | With bigger vibrant sound",
  "url": "https://www.amazon.com/dp/B09B8V1LZ3",
  "marketplace": "US",
  "searchQuery": "echo dot",
  "sortBy": "relevance",
  "page": 1,
  "positionOnPage": 1,
  "positionOverall": 1,
  "isSponsored": false,
  "isAmazonChoice": true,
  "isBestSeller": false,
  "isPrime": true,
  "price": { "value": 49.99, "currency": "$", "raw": "$49.99" },
  "listPrice": { "value": 59.99, "currency": "$", "raw": "$59.99" },
  "stars": 4.7,
  "reviewsCount": 193736,
  "thumbnailImage": "https://m.media-amazon.com/images/I/example.jpg",
  "deliveryText": "FREE delivery Mon, Jun 16",
  "fastDeliveryText": "Or fastest delivery Sat, Jun 14",
  "badgeText": "Climate Pledge Friendly",
  "couponText": "Save $5 with coupon",
  "prevPurchased": true,
  "purchaseVolumeText": "10K+ bought in past month",
  "variantHint": "Available in 4 colors"
}
````

### Pricing

$0.001 per actor start, plus $0.001 per scraped result. Roughly $1 per 1,000 results.

You only pay for results that successfully return data. Failed fetches are not charged.

**New to Apify?** Every account gets a $5 free monthly platform credit, enough for around 5,000 results on this actor before you commit to paying anything. Plenty to test the full feature set.

### Why this scraper

**Full SERP teaser data.** Many search scrapers stop at ASIN, title and price. This one also returns delivery promises, coupons, badges, purchase volume, sponsored flag, variant hint, on-page position and overall position. Everything a shopper actually sees on the result card.

**Per-page positions echoed back.** The `page`, `positionOnPage` and `positionOverall` fields let you track ranking changes over time without re-implementing slot accounting downstream. Sponsored rows still count against the on-page position so the numbers match what a shopper sees.

**20 marketplaces.** Auto-detects the right marketplace from any `amazon.<TLD>/s?k=...` URL. For keyword searches, the `country` input picks the marketplace. Accept-Language is tuned per country so prices and currencies render in the right locale.

**Filterable at the source.** Price range, minimum stars, and the Amazon sort dropdown are all passed through to Amazon's own SERP URL parameters. No client-side filtering surprises.

**Pay only for results.** $0.001 per successfully scraped row. Failed fetches are not charged.

### Use with AI Agents (MCP)

Connect this actor to any MCP-compatible AI client: Claude Desktop, Claude.ai, Cursor, VS Code, LangChain, LlamaIndex, or custom agents.

**Apify MCP server URL:**

`https://mcp.apify.com?tools=santamaria-automations/amazon-search-scraper`

**Example prompt once connected:**

> "Use `amazon-search-scraper` to find the top 50 results for 'wireless earbuds' on amazon.com. Return ASINs ranked by position."

Clients that support dynamic tool discovery (Claude.ai, VS Code) will receive the full input schema automatically.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `searchQueries` | array of strings | Search keywords. Each keyword runs a separate search. |
| `startUrls` | array | Direct Amazon search URLs (`/s?k=...`). Marketplace auto-detected from the TLD. |
| `country` | string | Marketplace for `searchQueries`: US, UK, DE, FR, IT, ES, CA, MX, BR, NL, SE, PL, TR, JP, IN, AU, SG, SA, AE, EG. |
| `language` | string | `AUTO` matches the marketplace, or pick one: en, de, fr, it, es, ja, pt, ar, tr, sv, nl, pl. |
| `maxResultsPerQuery` | integer | Max rows per keyword. `0` means no per-keyword cap (uses `maxPages`). |
| `maxResults` | integer | Hard cap across all queries combined. `0` means unlimited. |
| `maxPages` | integer | How many SERP pages to walk per keyword. Up to 20. |
| `sortBy` | string | `relevance`, `price-asc-rank`, `price-desc-rank`, `review-rank`, `date-desc-rank`, `featured-rank`. |
| `minPrice` | integer | Lower bound for the price filter, in the marketplace's currency. `0` means no filter. |
| `maxPrice` | integer | Upper bound for the price filter. `0` means no filter. |
| `minStars` | integer | Filter by minimum stars: 0 (off), 1, 2, 3, or 4. |
| `primeOnly` | boolean | Restrict to Prime-eligible offers. US only in v1, silently ignored elsewhere. |
| `includeSponsored` | boolean | When `false`, drop sponsored rows from output. Default `true`. |
| `concurrency` | integer | Parallel SERP fetches, 1 to 20. Default `5`. |

You can mix `searchQueries` and `startUrls` in the same run.

#### Example input

```json
{
  "searchQueries": ["echo dot", "smart speaker"],
  "country": "US",
  "maxResultsPerQuery": 50,
  "maxPages": 4,
  "sortBy": "review-rank",
  "minStars": 4,
  "includeSponsored": false,
  "concurrency": 5
}
```

### Output fields

#### Identity and ranking

`asin`, `title`, `url`, `marketplace`, `searchQuery`, `sortBy`, `page`, `positionOnPage`, `positionOverall`

#### Pricing

- `price` as `{value, currency, raw}`
- `listPrice` (struck-through original when on sale)

#### Social proof

- `stars` (0 to 5)
- `reviewsCount`
- `prevPurchased` (true when Amazon shows "X bought in past month")
- `purchaseVolumeText` (the literal text Amazon shows)

#### Badges

- `isSponsored`, `isAmazonChoice`, `isBestSeller`, `isPrime`
- `badgeText` (Climate Pledge Friendly, sale percentage, etc.)
- `couponText` (coupon promo text when shown)

#### Shipping and teaser

- `deliveryText` (primary delivery promise)
- `fastDeliveryText` (fastest delivery option)
- `variantHint` ("Available in 3 colors" or "+2 sizes")

#### Media

`thumbnailImage`

#### Run metadata

`input`, `scrapedAt`

### Common use cases

- **Rank tracking.** Monitor where a SKU appears for a target keyword over time using `positionOverall`.
- **Competitive intelligence.** Compare badges, prices and stars across the top N results for a category keyword.
- **Sponsored share.** Use `isSponsored` to measure paid-placement intensity across a keyword set.
- **New launch monitoring.** Sort by `date-desc-rank` to surface new arrivals for a keyword.
- **Coupon and deal mining.** Filter rows where `couponText` or `listPrice` is populated to surface active promotions.

### Notes and limits

- **One row per result, not per ASIN.** The same ASIN appearing under two keywords produces two rows, each tagged with its `searchQuery`. This is intentional so you can compare ranks for the same ASIN across keyword variants.
- **Pagination depth.** Amazon's SERP typically caps around 20 pages. The actor stops earlier when a page returns fewer than 4 organic rows.
- **`primeOnly` is US-only in v1.** Other marketplaces use different Prime filter IDs, scheduled for v1.1.
- **Filters are passed via the SERP URL.** This is the same path the website uses. If Amazon's filter UI behaves oddly (e.g. minStars combined with a category-restricted keyword), the actor reflects that behavior rather than overriding it.
- **Sponsored rows.** Set `includeSponsored: false` to drop them. They're still detected and counted against the on-page position so the numbers stay consistent with what shoppers see.

#### Fields that may be null

Some fields are situational. They populate when Amazon shows them on the SERP card and stay null otherwise. This is not an extraction bug:

- `listPrice` only populates when the product is on sale.
- `stars` and `reviewsCount` are null on results with zero reviews.
- `deliveryText` and `fastDeliveryText` only when Amazon renders a delivery promise on the card.
- `badgeText`, `couponText`, `purchaseVolumeText`, `variantHint` only when the corresponding badge or teaser is shown.
- `isPrime` is best-effort on the SERP. Amazon serves a different rendering to signed-out viewers (delivery upsell text instead of an icon badge), so the SERP-level signal is less reliable than the Product Scraper's `isPrime`. For accurate Prime status, pass the ASINs into the Amazon Product Scraper as a follow-up step.

#### Recommended concurrency

3 to 5 concurrent SERP fetches is the sweet spot. Higher works but transient blocks become more frequent. Pages within a single keyword are walked sequentially to preserve session warmth. Cross-query parallelism is what the concurrency setting controls.

#### Multi-marketplace runs

Mixing marketplaces in one run is supported. Accept-Language, locale headers, and the proxy country are tuned per query. Expect slightly longer runtime on smaller marketplaces (`.sa`, `.ae`, `.eg`, `.sg`) where Amazon's anti-bot is more aggressive.

### Related Actors

- [Amazon Product Scraper](https://apify.com/santamaria-automations/amazon-product-scraper): pull the full 50+ field PDP detail for any ASIN returned here (description, A+ content, variants, AI review summary, top reviews).
- [Amazon Bestsellers Scraper](https://apify.com/santamaria-automations/amazon-bestsellers-scraper): scrape Amazon's bestseller, movers and shakers, new releases, most wished for and most gifted rankings.
- [Amazon Seller Scraper](https://apify.com/santamaria-automations/amazon-seller-scraper): extract seller storefronts, ratings, business addresses and full product catalogs.

### Support

For issues, feature requests, or marketplaces not yet supported, please open an issue on the [Issues tab](https://apify.com/santamaria-automations/amazon-search-scraper/issues) of this actor. We typically respond within 24 hours.

Contact: contact@nanoscrape.com

# Actor input Schema

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

List of search keywords. Each keyword runs a separate search and is echoed back in every result row as `searchQuery`. Combine with the Search URLs field below — both are merged into one queue.

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

Direct Amazon search URLs (e.g. `https://www.amazon.com/s?k=robot+vacuum&rh=p_72%3A1248915011`). Use this when you need fine-grained filter control via Amazon's own URL params. Marketplace is auto-detected from the URL TLD.

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

Which Amazon marketplace to use for the Search Keywords field above. Ignored for entries in Search URLs (TLD is detected from the URL).

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

Accept-Language preference sent to Amazon. `AUTO` matches the marketplace (e.g. de-DE for Germany, ja-JP for Japan) — recommended unless you need consistent English copy across all marketplaces.

## `maxResultsPerQuery` (type: `integer`):

Cap the number of result rows returned per keyword. `0` = no cap (uses Max Pages below to bound the run). Each SERP page returns ~16 organic results.

## `maxResults` (type: `integer`):

Hard cap on the total number of rows across all queries combined. `0` = unlimited (only Max Results per Query and Max Pages limit the run).

## `maxPages` (type: `integer`):

How deep to paginate per keyword. Amazon shows ~16 organic results per page; pagination stops earlier if Amazon returns an empty page. Amazon's SERP typically caps at 20 pages.

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

Which sort order to request from Amazon. `relevance` is the default ranking; other options match Amazon's sort dropdown.

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

Lower bound for price filter, in the marketplace's primary currency unit (USD for US, EUR for DE/FR/IT/ES/NL, GBP for UK, etc.). `0` = no lower bound.

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

Upper bound for price filter, in the marketplace's primary currency unit. `0` = no upper bound.

## `minStars` (type: `integer`):

Filter by minimum star rating. `0` = no filter. `1` = 1 star and up, `2` = 2 stars and up, `3` = 3 stars and up, `4` = 4 stars and up. Values above 4 are clamped to 4.

## `primeOnly` (type: `boolean`):

Restrict results to Prime-eligible offers. Currently uses the amazon.com Prime filter ID — on non-US marketplaces this is silently ignored.

## `includeSponsored` (type: `boolean`):

When false, sponsored rows are dropped from the output. They're still detected and counted against the page (so positionOnPage stays consistent with what shoppers see).

## `concurrency` (type: `integer`):

SERP pages fetched in parallel. 3-5 is reliable for most workloads; higher (up to 20) is faster but increases the chance of transient blocks that force retries.

## Actor input object example

```json
{
  "searchQueries": [
    "echo dot",
    "robot vacuum"
  ],
  "startUrls": [],
  "country": "US",
  "language": "AUTO",
  "maxResultsPerQuery": 50,
  "maxResults": 0,
  "maxPages": 5,
  "sortBy": "relevance",
  "minPrice": 0,
  "maxPrice": 0,
  "minStars": 0,
  "primeOnly": false,
  "includeSponsored": true,
  "concurrency": 5
}
```

# Actor output Schema

## `searchResults` (type: `string`):

Dataset containing scraped Amazon search result rows

# 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": [
        "echo dot",
        "robot vacuum"
    ],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("santamaria-automations/amazon-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": [
        "echo dot",
        "robot vacuum",
    ],
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("santamaria-automations/amazon-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "echo dot",
    "robot vacuum"
  ],
  "startUrls": []
}' |
apify call santamaria-automations/amazon-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Search Scraper · 20 Marketplaces",
        "description": "Extract Amazon search results by keyword or /s?k= URL across 20 marketplaces. Returns ASIN, title, price, list price, stars, reviews, sponsored / Prime / Amazon's Choice / Best Seller flags, delivery promise, coupon, purchase volume and page position. Pay-per-result, no login.",
        "version": "1.0",
        "x-build-id": "q7lUujcjcgpPkdYvU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/santamaria-automations~amazon-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-santamaria-automations-amazon-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/santamaria-automations~amazon-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-santamaria-automations-amazon-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/santamaria-automations~amazon-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-santamaria-automations-amazon-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "List of search keywords. Each keyword runs a separate search and is echoed back in every result row as `searchQuery`. Combine with the Search URLs field below — both are merged into one queue.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Direct Amazon search URLs (e.g. `https://www.amazon.com/s?k=robot+vacuum&rh=p_72%3A1248915011`). Use this when you need fine-grained filter control via Amazon's own URL params. Marketplace is auto-detected from the URL TLD.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "country": {
                        "title": "Marketplace Country",
                        "enum": [
                            "US",
                            "CA",
                            "MX",
                            "BR",
                            "UK",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "SE",
                            "PL",
                            "TR",
                            "JP",
                            "IN",
                            "AU",
                            "SG",
                            "SA",
                            "AE",
                            "EG"
                        ],
                        "type": "string",
                        "description": "Which Amazon marketplace to use for the Search Keywords field above. Ignored for entries in Search URLs (TLD is detected from the URL).",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "AUTO",
                            "en",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "ja",
                            "pt",
                            "ar",
                            "tr",
                            "sv",
                            "nl",
                            "pl"
                        ],
                        "type": "string",
                        "description": "Accept-Language preference sent to Amazon. `AUTO` matches the marketplace (e.g. de-DE for Germany, ja-JP for Japan) — recommended unless you need consistent English copy across all marketplaces.",
                        "default": "AUTO"
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results per Query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the number of result rows returned per keyword. `0` = no cap (uses Max Pages below to bound the run). Each SERP page returns ~16 organic results.",
                        "default": 50
                    },
                    "maxResults": {
                        "title": "Max Total Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the total number of rows across all queries combined. `0` = unlimited (only Max Results per Query and Max Pages limit the run).",
                        "default": 0
                    },
                    "maxPages": {
                        "title": "Max Pages per Query",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How deep to paginate per keyword. Amazon shows ~16 organic results per page; pagination stops earlier if Amazon returns an empty page. Amazon's SERP typically caps at 20 pages.",
                        "default": 5
                    },
                    "sortBy": {
                        "title": "Sort Order",
                        "enum": [
                            "relevance",
                            "price-asc-rank",
                            "price-desc-rank",
                            "review-rank",
                            "date-desc-rank",
                            "featured-rank"
                        ],
                        "type": "string",
                        "description": "Which sort order to request from Amazon. `relevance` is the default ranking; other options match Amazon's sort dropdown.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Min Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound for price filter, in the marketplace's primary currency unit (USD for US, EUR for DE/FR/IT/ES/NL, GBP for UK, etc.). `0` = no lower bound.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Max Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound for price filter, in the marketplace's primary currency unit. `0` = no upper bound.",
                        "default": 0
                    },
                    "minStars": {
                        "title": "Min Star Rating",
                        "minimum": 0,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Filter by minimum star rating. `0` = no filter. `1` = 1 star and up, `2` = 2 stars and up, `3` = 3 stars and up, `4` = 4 stars and up. Values above 4 are clamped to 4.",
                        "default": 0
                    },
                    "primeOnly": {
                        "title": "Prime-eligible Only (US only)",
                        "type": "boolean",
                        "description": "Restrict results to Prime-eligible offers. Currently uses the amazon.com Prime filter ID — on non-US marketplaces this is silently ignored.",
                        "default": false
                    },
                    "includeSponsored": {
                        "title": "Include Sponsored Results",
                        "type": "boolean",
                        "description": "When false, sponsored rows are dropped from the output. They're still detected and counted against the page (so positionOnPage stays consistent with what shoppers see).",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrent Pages",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "SERP pages fetched in parallel. 3-5 is reliable for most workloads; higher (up to 20) is faster but increases the chance of transient blocks that force retries.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
