# Amazon Search Scraper — Keyword SERP, ASIN, Prices & Rankings (`crawloop/amazon-search-scraper`) Actor

Amazon search scraper for keyword SERP extraction across 20+ marketplaces. Get ASIN, title, price, ratings, badges, Prime, sponsored flag, delivery, sales volume, and ranking position. Batch keywords, 40-page pagination, sort options, ASIN deduplication. Fast curl\_cffi HTTP + residential proxy.

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

## Pricing

from $1.00 / 1,000 search 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 — Keyword Results, Prices & Rankings

> **Disclaimer:** Unofficial integration for publicly accessible Amazon search pages. **Amazon** and related names are trademarks of Amazon.com, Inc. or its affiliates. Not affiliated with, sponsored by, or endorsed by Amazon. Provided for informational and research purposes only.

Search Amazon by **keyword** and extract **search result cards** with **ASIN**, **title**, **price**, **ratings**, **badges**, **Prime**, **sponsored flag**, **delivery**, **sales volume**, and **SERP position** across **20+ marketplaces**. Built for **product research**, **price monitoring**, **ranking analysis**, and **competitor tracking**.

> **Crawloop Marketplace & E-commerce Suite** — Amazon, eBay, and Mercado Libre scrapers for product discovery and pricing intelligence.

| **Amazon Search Scraper** ◄── *you are here* | [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) | [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | [Mercado Libre Listings Scraper](https://apify.com/crawloop/mercado-libre-listings-scraper) |
| :---: | :---: | :---: | :---: |
| Amazon keyword SERP, badges, sponsored | Live eBay listings, BIN/auction | Completed eBay sold comps | LATAM listings & optional PDP |

Also see: [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) · [Mercado Libre Market Intelligence](https://apify.com/crawloop/mercado-libre-market-intelligence)

---

### Key Features

- **Keyword search** — single `query` or sequential batch via `queries`
- **Pagination** — up to **40 pages** per query (~300–650 products depending on Amazon layout)
- **Smart sorting** — relevance, price (low/high), reviews, newest, best sellers
- **Rich SERP metadata** — badges, ratings, prices, images, sales volume, coupons, availability
- **Sponsored detection** — `isSponsored` flag for ad placements in search grids
- **Multi-marketplace** — US, GB, DE, FR, IT, ES, CA, AU, JP, IN, BR, MX, NL, SE, PL, BE, SA, AE, ZA, IE, SG, TR, EG
- **ASIN deduplication** — optional `deduplicateAsins` across batch keywords (default: on)
- **Resilient fetching** — session warmup, retry with proxy rotation, empty-page detection
- **Fast HTTP scraping** — `curl_cffi` Chrome TLS impersonation; no headless browser
- **Residential proxy** — geo-targeted Apify Proxy sessions matched to marketplace country

---

### Use Cases

| Use case | What you get | Why it helps |
| :--- | :--- | :--- |
| **Product research** | Keyword SERP with ASIN, title, badges | Discover trending items and category leaders |
| **Price monitoring** | Current price, strikethrough price, currency | Track deals and competitor pricing |
| **Ranking analysis** | `page`, `position`, `isSponsored` | Monitor organic vs paid placement |
| **Cross-border research** | Same keyword on US, DE, GB, JP, … | Compare markets and localization |
| **Data pipelines** | Clean JSON rows per search card | Feed dashboards, databases, and ML workflows |

---

### Quick Start

**Basic — one keyword, one page:**

```json
{
  "query": "wireless mouse",
  "country": "US",
  "maxPages": 1
}
````

**Advanced — multiple keywords, deep pagination:**

```json
{
  "queries": ["wireless mouse", "laptop"],
  "maxPages": 10,
  "country": "US",
  "language": "en_US",
  "sortBy": "RELEVANCE",
  "deduplicateAsins": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

***

### When to use this Actor

- **Amazon product discovery** — find items by keyword with ranking position and badges
- **Amazon price tracking** — monitor listing prices from search cards without opening PDPs
- **SEO & SERP analysis** — compare organic listings vs sponsored placements over time
- **Large catalog pulls** — combine multiple keywords with deduplication for 500+ unique ASINs

### When not to use this Actor

- **Full product detail pages** — search cards only; no bullet points, A+ content, or full offer tables
- **Review text extraction** — rating count is included; individual review bodies are not
- **Seller storefront catalogs** — keyword search only, not seller inventory pages
- **Historical sold prices** — use [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) or [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) for completed-sale comps
- **LATAM marketplace listings** — use [Mercado Libre Listings Scraper](https://apify.com/crawloop/mercado-libre-listings-scraper) for Mercado Libre across 18 country sites

***

### Input Parameters

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `query` | String | — | Primary search keyword |
| `queries` | Array | — | Batch keywords (processed **sequentially**) |
| `maxPages` | Integer | `1` | Pages per query (1–40) |
| `startPage` | Integer | `1` | First page to scrape |
| `country` | String | `"US"` | Marketplace country code |
| `language` | String | — | Optional locale (`en_US`, `de_DE`, …) |
| `sortBy` | String | `"RELEVANCE"` | Sort order enum |
| `deduplicateAsins` | Boolean | `true` | Skip duplicate ASINs across batch queries |
| `proxyConfiguration` | Object | Residential | Apify Proxy settings |

#### Sort options

| Value | Description |
| :--- | :--- |
| `RELEVANCE` | Most relevant to search query (default) |
| `LOWEST_PRICE` | Cheapest products first |
| `HIGHEST_PRICE` | Most expensive products first |
| `REVIEWS` | Most reviewed products |
| `NEWEST` | Newest arrivals |
| `BEST_SELLERS` | Best selling products |

***

### Output Format

Each dataset row is one product card from Amazon search results.

| Field | Type | Description |
| :--- | :--- | :--- |
| `asin` | String | Amazon Standard Identification Number |
| `productTitle` | String | Product title |
| `productPrice` / `priceValue` | String / Number | Display price and parsed numeric value |
| `productOriginalPrice` | String | Strikethrough/list price when shown |
| `currency` | String | Currency code |
| `productStarRating` | Number | Average rating (0–5) |
| `productNumRatings` | Integer | Number of ratings |
| `productUrl` | String | Product page URL |
| `productPhoto` | String | Main image URL |
| `productNumOffers` | Integer | Number of buying options when shown |
| `productMinimumOfferPrice` | String | Lowest offer price when shown |
| `isBestSeller` / `isAmazonChoice` / `isPrime` | Boolean | Badge flags |
| `isSponsored` | Boolean | Sponsored/ad placement flag |
| `climatePledgeFriendly` | Boolean | Climate Pledge Friendly badge |
| `salesVolume` | String | Recent sales text when shown |
| `delivery` | String | Delivery promise text |
| `hasVariations` | Boolean | Color/size/style variations indicated |
| `productAvailability` | String | Stock text when shown |
| `couponText` | String | Coupon/discount text |
| `productBadge` | String | Special badge (e.g. Overall Pick) |
| `page` / `position` | Integer | Page number and position on page |
| `searchQuery` | String | Keyword that produced the row |
| `country` / `domain` | String | Marketplace metadata |
| `totalProductsAvailable` | Integer | Total matching results count |
| `scrapedAt` | String | UTC ISO timestamp |

#### Output example

```json
{
  "source": "amazon_search",
  "searchQuery": "wireless mouse",
  "page": 1,
  "position": 3,
  "asin": "B004YAVF8I",
  "productTitle": "Logitech M185 Wireless Mouse...",
  "productPrice": "$13.95",
  "priceValue": 13.95,
  "currency": "USD",
  "productStarRating": 4.5,
  "productNumRatings": 429,
  "productUrl": "https://www.amazon.com/dp/B004YAVF8I",
  "isPrime": true,
  "isSponsored": false,
  "country": "US",
  "domain": "www.amazon.com",
  "scrapedAt": "2026-07-15T10:00:00.000Z"
}
```

***

### Supported marketplaces

| Region | Code | Region | Code | Region | Code |
| :--- | :--- | :--- | :--- | :--- | :--- |
| United States | US | United Kingdom | GB | Germany | DE |
| Japan | JP | India | IN | France | FR |
| Italy | IT | Spain | ES | Canada | CA |
| Brazil | BR | Australia | AU | Mexico | MX |
| Netherlands | NL | Sweden | SE | Poland | PL |
| Belgium | BE | Saudi Arabia | SA | UAE | AE |
| South Africa | ZA | Ireland | IE | Singapore | SG |
| Turkey | TR | Egypt | EG | | |

Common `language` values: `en_US`, `en_GB`, `de_DE`, `fr_FR`, `it_IT`, `es_ES`, `ja_JP`, `pt_BR`, `nl_NL`, `pl_PL`, `sv_SE`, `ar_AE`.

***

### FAQ

**What input do I need?**\
A search keyword in `query` (or a list in `queries`). All other parameters are optional.

**How many pages can I scrape?**\
Up to **40 pages** per query. Each page typically has 10–16 products depending on Amazon layout.

**Which marketplaces are supported?**\
23 country codes including US, GB, DE, JP, IN, FR, IT, ES, CA, BR, AU, MX, NL, SE, PL, BE, SA, AE, ZA, IE, SG, TR, EG.

**How do I sort results?**\
Use `sortBy`: `RELEVANCE`, `LOWEST_PRICE`, `HIGHEST_PRICE`, `REVIEWS`, `NEWEST`, or `BEST_SELLERS`.

**Does it detect sponsored listings?**\
Yes — each row includes `isSponsored` when Amazon marks the card as an ad placement.

**What if no results are found?**\
Pagination stops automatically. Try a broader keyword, another marketplace, or residential proxy geo-matched to `country`.

**Can I scrape 500+ unique products?**\
Use multiple keywords in `queries` with `deduplicateAsins: true`. A single keyword may return fewer unique ASINs on later pages.

***

### Troubleshooting

| Issue | Likely cause | What to try |
| :--- | :--- | :--- |
| Empty dataset | Blocked IP or captcha | Enable Apify Residential proxy with `apifyProxyCountry` matching `country` |
| Missing prices or ratings | Amazon did not render field on SERP card | Normal — field availability varies by listing and locale |
| Slow runs | Many pages or batch queries | Reduce `maxPages` or split keywords across runs |
| Duplicate ASINs in batch | Dedupe disabled | Set `deduplicateAsins: true` |

***

### Limitations

- **Residential proxy strongly recommended** — datacenter IPs may trigger captcha or empty responses
- **Search cards only** — fields depend on what Amazon renders on the SERP for each ASIN
- **Locale-specific markup** — badge and delivery text patterns vary by marketplace language
- **Batch queries run sequentially** — safer for Amazon anti-bot, but slower than parallel multi-keyword runs

***

### Related Actors

| Actor | Best for |
| :--- | :--- |
| [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) | Live eBay listings, BIN/auction, watchers, competition |
| [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | Completed eBay sales history and sold prices |
| [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) | Recommended price, demand score, CSV/report |
| [Mercado Libre Listings Scraper](https://apify.com/crawloop/mercado-libre-listings-scraper) | LATAM Mercado Libre search and PDP listings |
| [Mercado Libre Market Intelligence](https://apify.com/crawloop/mercado-libre-market-intelligence) | LATAM niche score, demand, GMV, market reports |

**Tags:** amazon search scraper, amazon keyword search, amazon serp scraper, amazon product search api, amazon asin scraper, amazon price scraper, amazon ranking tracker, amazon product research, amazon marketplace scraper, amazon search results extractor, amazon best seller scraper, amazon prime products, amazon sponsored listings, ecommerce scraper, product discovery, price monitoring

# Actor input Schema

## `query` (type: `string`):

Primary Amazon search keyword or phrase.

## `queries` (type: `array`):

Optional list of keywords. Each query runs sequentially with the same country, sort, and page settings.

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

Number of search result pages to scrape per query (1–40). Each page typically contains 10–16 products.

## `startPage` (type: `integer`):

First search results page to scrape (1-based).

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

Amazon marketplace country code. Controls domain, default currency, and proxy geo-targeting.

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

Preferred result language/locale. When omitted, Amazon uses the marketplace default.

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

Amazon search sort order.

## `deduplicateAsins` (type: `boolean`):

When enabled, each ASIN is saved only once across all queries in the run. Recommended for batch keyword searches.

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

Apify Proxy settings. Residential proxies geo-matched to the selected marketplace are strongly recommended for stable Amazon access.

## Actor input object example

```json
{
  "query": "wireless mouse",
  "maxPages": 1,
  "startPage": 1,
  "country": "US",
  "sortBy": "RELEVANCE",
  "deduplicateAsins": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "query": "wireless mouse",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/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 = {
    "query": "wireless mouse",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/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 '{
  "query": "wireless mouse",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call crawloop/amazon-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Search Scraper — Keyword SERP, ASIN, Prices & Rankings",
        "description": "Amazon search scraper for keyword SERP extraction across 20+ marketplaces. Get ASIN, title, price, ratings, badges, Prime, sponsored flag, delivery, sales volume, and ranking position. Batch keywords, 40-page pagination, sort options, ASIN deduplication. Fast curl_cffi HTTP + residential proxy.",
        "version": "1.0",
        "x-build-id": "qod8nzMtlkFDNvm3y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawloop~amazon-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawloop-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/crawloop~amazon-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawloop-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/crawloop~amazon-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawloop-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Primary Amazon search keyword or phrase."
                    },
                    "queries": {
                        "title": "Search queries (batch)",
                        "type": "array",
                        "description": "Optional list of keywords. Each query runs sequentially with the same country, sort, and page settings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPages": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "maximum": 40,
                        "type": "integer",
                        "description": "Number of search result pages to scrape per query (1–40). Each page typically contains 10–16 products.",
                        "default": 1
                    },
                    "startPage": {
                        "title": "Start page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "First search results page to scrape (1-based).",
                        "default": 1
                    },
                    "country": {
                        "title": "Marketplace country",
                        "enum": [
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "CA",
                            "AU",
                            "JP",
                            "IN",
                            "BR",
                            "MX",
                            "NL",
                            "SE",
                            "PL",
                            "BE",
                            "SA",
                            "AE",
                            "ZA",
                            "IE",
                            "SG",
                            "TR",
                            "EG"
                        ],
                        "type": "string",
                        "description": "Amazon marketplace country code. Controls domain, default currency, and proxy geo-targeting.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language (optional)",
                        "enum": [
                            "en_US",
                            "en_GB",
                            "de_DE",
                            "fr_FR",
                            "it_IT",
                            "es_ES",
                            "ja_JP",
                            "pt_BR",
                            "nl_NL",
                            "pl_PL",
                            "sv_SE",
                            "ar_AE",
                            "en_AU",
                            "en_CA",
                            "fr_CA",
                            "en_IN",
                            "hi_IN",
                            "en_SG",
                            "es_MX",
                            "pt_PT",
                            "zh_CN",
                            "tr_TR",
                            "en_ZA",
                            "en_IE",
                            "fr_BE",
                            "nl_BE"
                        ],
                        "type": "string",
                        "description": "Preferred result language/locale. When omitted, Amazon uses the marketplace default."
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "RELEVANCE",
                            "LOWEST_PRICE",
                            "HIGHEST_PRICE",
                            "REVIEWS",
                            "NEWEST",
                            "BEST_SELLERS"
                        ],
                        "type": "string",
                        "description": "Amazon search sort order.",
                        "default": "RELEVANCE"
                    },
                    "deduplicateAsins": {
                        "title": "Deduplicate ASINs",
                        "type": "boolean",
                        "description": "When enabled, each ASIN is saved only once across all queries in the run. Recommended for batch keyword searches.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Residential proxies geo-matched to the selected marketplace are strongly recommended for stable Amazon access.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
