# Amazon Search Products Scraper (`scraperforge/amazon-search-products-scraper`) Actor

🛒 Amazon Search Products Scraper pulls structured data from Amazon search results — titles, prices, ratings, reviews, ASINs, Prime/availability, images & links. 🚀 Perfect for market research, price monitoring, SEO, and product discovery at scale.

- **URL**: https://apify.com/scraperforge/amazon-search-products-scraper.md
- **Developed by:** [ScraperForge](https://apify.com/scraperforge) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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 Products Scraper

Amazon Search Products Scraper is a fast, scalable Amazon search results scraper that turns search result pages into structured product data — including ASINs, prices, ratings, reviews, images, and links. It solves the pain of manual copy-paste by providing a reliable Amazon product search scraper and Amazon SERP scraper for marketers, developers, data analysts, and researchers. With support for multiple locales and proxy fallback, it enables market research, price monitoring, and product discovery at scale. 🚀

### What data / output can you get?

Below are real fields this Amazon product listing scraper extracts directly from Amazon’s search results (SERP). Results can be exported from the Apify dataset to CSV, JSON, or Excel.

| Data type | Description | Example value |
| --- | --- | --- |
| asin | Unique Amazon product identifier from the search result | B0CL5KNB9M |
| productDescription | Product title/description as shown on the search results page | PlayStation®5 Digital Edition (slim) |
| price | Parsed price for the listing (if available) | 399.99 |
| retailPrice | Original/retail price when present (e.g., struck-through) | 449.99 |
| productRating | Average customer rating string | 4.7 out of 5 stars |
| countReview | Total number of reviews | 10500 |
| dpUrl | Link to the product page (as found on SERP) | /PlayStation%C2%AE5-Digital.../dp/B0CL5KNB9M |
| imgUrl | Product thumbnail image URL | https://m.media-amazon.com/images/I/51fM0CKG+HL._AC_UY218_.jpg |
| prime | Whether the listing shows Prime | true |
| sponsored | Whether the result is marked as sponsored | false |
| salesVolume | Purchase volume snippet (if present) | 7K+ bought in past month |
| deliveryMessage | Delivery/shipping snippet (if present) | FREE delivery Sun, Jun 8 |

Bonus metadata per item includes: manufacturer, series, variations, productDetails, secondaryOffer, resultCount, categories, similarKeywords, currentPage, sortStrategy, and searchResultPosition. This makes it a robust Amazon product details extractor and Amazon ASIN data scraper for deep analysis.

### Key features

- 🔄 Automatic pagination control  
  Continues through search pages until results are exhausted (stops after 2 consecutive empty pages) or up to maxPages you define — perfect for large-scale Amazon search results scraper runs.

- 🛡️ Smart proxy fallback  
  Built-in logic to handle blocks with Apify Proxy. Falls back from direct to datacenter, then to RESIDENTIAL when available — boosting stability for any Amazon price scraping tool workflow.

- 🌍 Multi-marketplace support  
  Choose amazonDomain to target amazon.com, amazon.co.uk, amazon.de, amazon.fr, amazon.it, amazon.es, and amazon.ca. Pair with Language and Proxy country for localized extraction.

- 🧠 Rich SERP intelligence  
  Captures resultCount, categories, similarKeywords, and searchResultPosition to enrich your Amazon SERP scraper outputs with ranking and navigational context.

- 🏷️ Clean product signals  
  Extracts asin, productDescription, dpUrl, imgUrl, price, retailPrice, productRating, countReview, prime, sponsored, salesVolume, and deliveryMessage directly from search listings.

- 🗣️ Language-aware requests  
  Sets Accept-Language based on your input for more consistent page layouts and localized data.

- ⚙️ Developer-friendly outputs  
  Results stream to the Apify dataset in real time — pull via API and export to JSON, CSV, or Excel. Ideal for pipelines that need an Amazon product search API alternative.

- 🚀 Built for automation  
  Schedule runs, connect to BI tools, or downstream to databases to scrape Amazon search results continuously. Great for pricing monitors, content updates, and enrichment jobs.

- 🧩 Python-based reliability  
  Implemented with aiohttp and BeautifulSoup for speed and resilience. A strong fit if you plan to scrape Amazon product listings Python-side and orchestrate via Apify.

### How to use Amazon Search Products Scraper - step by step

1. Create or log in to your Apify account.  
2. Open the “Amazon Search Products Scraper” actor in the Apify Store.  
3. Add input data in Enter Amazon Keywords or Search URLs (startUrls). You can paste keywords like “Playstation” or full search URLs like https://www.amazon.com/s?k=TV.  
4. Set amazonDomain (e.g., amazon.com) and optionally configure Language and Proxy country for localization.  
5. Choose a Review sort order (sortOrder) such as relevanceblender, price-asc-rank, price-desc-rank, review-rank, or date-desc-rank.  
6. Control depth with Maximum pages per search (maxPages). Leave at 1 to auto-continue until results end, or raise the limit (up to 1000).  
7. Improve stability by enabling Proxy configuration (proxyConfiguration) — use Apify Proxy and optionally select RESIDENTIAL if you need maximum resilience.  
8. Start the run. Watch logs update in real time; results are pushed to the dataset continuously.  
9. Export your dataset to JSON, CSV, or Excel, or pull via the Apify API for automation.

Pro tip: For ongoing monitoring (e.g., price tracking or content refresh), schedule runs and fetch “Amazon search results to CSV” on a cadence, or integrate via API for a fully automated Amazon product data scraping software pipeline.

### Use cases

| Use case | Description |
| --- | --- |
| E‑commerce market research | Identify trending items and benchmark pricing by region using an Amazon search results scraper with multi-locale support. |
| Affiliate content & SEO | Enrich pages with fresh ASINs, ratings, and prices; build comparison tables with an Amazon product scraper tool. |
| Competitive monitoring | Track sponsored vs. organic placements and salesVolume signals to understand category dynamics at a glance. |
| Dropshipping & sourcing | Discover demand with review counts and rating signals; extract productDescription and dpUrl fast. |
| Price intelligence | Use it as an Amazon price scraping tool to collect price/retailPrice at scale for dashboards and alerts. |
| Data pipelines & APIs | Treat the dataset + Apify API as an Amazon product search API alternative and feed downstream analytics. |
| Academic & trend analysis | Analyze categories, similarKeywords, and resultCount for research on marketplaces and consumer behavior. |

### Why choose Amazon Search Products Scraper?

This actor delivers production-grade, structured Amazon product data extraction from search results with an emphasis on reliability, scale, and clean fields.

- 🎯 Accurate SERP extraction — purpose-built selectors collect stable ASIN, price, rating, and review signals.  
- 🌐 Locale-ready — amazonDomain, Language, and Proxy country let you target regional SERPs precisely.  
- 📈 Scales with your needs — auto-continues across pages or up to maxPages for bulk collection.  
- 🔌 Developer access — stream to the dataset, export to CSV/JSON/Excel, or pull via the Apify API.  
- 🛡️ Block-resilient — optional Apify Proxy with automatic fallback to datacenter and RESIDENTIAL groups.  
- 💸 Cost-effective — use trial minutes to validate your workflow before scaling (trialMinutes: 120).  
- 🧩 Better than extensions — no brittle browser plugins; run in the cloud as a robust Amazon product data scraping software.

In short: a focused Amazon product listing scraper that beats unstable alternatives with automation-first reliability.

### Is it legal / ethical to use Amazon Search Products Scraper?

Yes — when used responsibly. This actor extracts publicly available product data from Amazon search result pages. It does not log in or access private data.

Guidelines for compliant use:
- Only collect public product information (titles, prices, ratings, etc.).  
- Respect Amazon’s terms and applicable laws (e.g., GDPR, CCPA).  
- Use reasonable rates and enable proxies responsibly to avoid excessive load.  
- Consult your legal team for your specific jurisdiction and use case.

### Input parameters & output format

#### Example JSON input
```json
{
  "startUrls": [
    "Playstation",
    "https://www.amazon.com/s?k=TV",
    "Shoes"
  ],
  "amazonDomain": "amazon.com",
  "language": "",
  "proxyCountry": "AUTO",
  "sortOrder": "relevanceblender",
  "maxPages": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameters

- startUrls (array, required): List of keywords (e.g., 'Playstation', 'TV') or full Amazon search URLs. Each keyword will be used to search Amazon. Default: none.
- amazonDomain (string, optional): Amazon domain to use (e.g., amazon.com, amazon.co.uk, amazon.de). Default: amazon.com.
- language (string, optional): Language for Amazon pages. Leave empty for automatic detection based on domain. Enum: "", "en-US", "en-GB", "de-DE", "fr-FR", "es-ES", "it-IT", "ja-JP", "zh-CN". Default: "".
- proxyCountry (string, optional): Country for proxy selection. Automatic selection based on Amazon domain if not specified. Enum: "AUTO", "US", "GB", "DE", "FR", "ES", "IT", "CA", "AU", "JP". Default: AUTO.
- sortOrder (string, optional): How to sort search results. One of "relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank". Default: relevanceblender.
- maxPages (integer, optional): Maximum number of pages to scrape per search keyword. If set to 1 or not specified, the actor will automatically continue until all results are found (stops after 2 consecutive empty pages). Min: 1, Max: 1000. Default: 1.
- proxyConfiguration (object, optional): Choose proxy settings. Default: no proxy, with automatic fallback to datacenter and residential proxies if blocked. Prefill: {"useApifyProxy": false}.

#### Example JSON output

```json
[
  {
    "asin": "B0CL5KNB9M",
    "productDescription": "PlayStation®5 Digital Edition (slim)",
    "imgUrl": "https://m.media-amazon.com/images/I/51fM0CKG+HL._AC_UY218_.jpg",
    "price": null,
    "retailPrice": null,
    "productRating": "4.7 out of 5 stars",
    "countReview": 10500,
    "dpUrl": "/PlayStation%C2%AE5-Digital-slim-PlayStation-5/dp/B0CL5KNB9M/ref=sr_1_1?...",
    "prime": false,
    "sponsored": false,
    "salesVolume": "7K+ bought in past month",
    "deliveryMessage": null,
    "manufacturer": "Amazon's Choice: Overall Pick",
    "series": null,
    "variations": [],
    "productDetails": [
      "Nov 24, 2023",
      "No featured offers available"
    ],
    "secondaryOffer": 0.0,
    "statusCode": 200,
    "statusMessage": "FOUND",
    "keyword": "Playstation",
    "domainCode": "com",
    "page": 1,
    "selectedCategory": "aps",
    "browseNode": null,
    "nodeHierarchy": null,
    "resultCount": 50000,
    "categories": [],
    "similarKeywords": [
      {
        "keyword": "playstation 5",
        "url": "/s?k=playstation+5&ref=rsl_sug_0_0&..."
      },
      {
        "keyword": "playstation gift card",
        "url": "/s?k=playstation+gift+card&ref=rsl_sug_0_3&..."
      }
    ],
    "currentPage": 1,
    "sortStrategy": "relevanceblender",
    "searchResultPosition": 0
  }
]
```

Notes:

- Optional fields such as price, retailPrice, salesVolume, deliveryMessage, manufacturer, series, variations, productDetails, browseNode, nodeHierarchy, and categories may be null or empty when not present on the SERP item.
- Only successful product items are pushed to the dataset (statusCode 200, statusMessage "FOUND"). Error objects are handled internally and not stored in the dataset.

### FAQ

#### Is there a free trial for Amazon Search Products Scraper?

Yes. The actor listing includes trialMinutes (120) on Apify, so you can test your workflow before subscribing. After the trial, standard usage applies per the actor’s pricing.

#### Which Amazon marketplaces are supported?

The scraper supports multiple domains via amazonDomain, including amazon.com, amazon.co.uk, amazon.de, amazon.fr, amazon.it, amazon.es, and amazon.ca. Choose the domain that matches your target market.

#### Do I need to log in or provide cookies?

No. The actor collects publicly available product data from search result pages without logging in. It sets basic cookies and headers to emulate a normal browser visit.

#### How can I avoid getting blocked?

Enable proxyConfiguration to use Apify Proxy and optionally set proxyCountry. The actor includes automatic fallback from direct to datacenter and then to RESIDENTIAL proxies when available, improving success on tough SERPs.

#### How many results can it scrape per run?

It automatically continues across pages until results are exhausted (stopping after 2 consecutive empty pages) or up to your maxPages limit (1–1000). Results stream to the dataset in real time for export.

#### What data fields are included?

From each search result, it extracts asin, productDescription, imgUrl, price, retailPrice, productRating, countReview, dpUrl, prime, sponsored, salesVolume, deliveryMessage, and more. Metadata includes resultCount, categories, similarKeywords, and searchResultPosition.

#### Can I export results to CSV or use an API?

Yes. Export the Apify dataset to CSV, JSON, or Excel directly from the run. You can also fetch results programmatically via the Apify API — a convenient Amazon product search API alternative.

#### Does it scrape full product pages?

This actor focuses on Amazon search results. It extracts data shown on SERP tiles. If you need product detail pages, combine this with a dedicated product page scraper.

### Final thoughts

Amazon Search Products Scraper is built to extract structured product listings from Amazon search results at scale. With multi-locale support, proxy fallback, and real-time dataset output, it empowers marketers, developers, analysts, and researchers to automate product discovery, price tracking, and SERP analysis.

Export to CSV/JSON/Excel, or integrate via the Apify API to power an end-to-end pipeline. Start collecting cleaner Amazon SERP data and accelerate your market intelligence today.

# Actor input Schema

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

List of keywords (e.g., 'Playstation', 'TV') or full Amazon search URLs. Each keyword will be used to search Amazon.

## `amazonDomain` (type: `string`):

Amazon domain to use (e.g., amazon.com, amazon.co.uk, amazon.de). Default: amazon.com

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

Language for Amazon pages. Leave empty for automatic detection based on domain.

## `proxyCountry` (type: `string`):

Country for proxy selection. Automatic selection based on Amazon domain if not specified.

## `sortOrder` (type: `string`):

How to sort search results: 'relevanceblender' (relevance), 'price-asc-rank' (price low to high), 'price-desc-rank' (price high to low), 'review-rank' (customer reviews), 'date-desc-rank' (newest arrivals)

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

Maximum number of pages to scrape per search keyword. If set to 1 or not specified, the actor will automatically continue scraping until all results are found (stops after 2 consecutive empty pages). Set a higher value to limit the number of pages scraped.

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

Choose proxy settings. Default: no proxy, with automatic fallback to datacenter and residential proxies if blocked.

## Actor input object example

```json
{
  "startUrls": [
    "Playstation",
    "https://www.amazon.com/s?k=TV"
  ],
  "amazonDomain": "amazon.com",
  "language": "",
  "proxyCountry": "AUTO",
  "sortOrder": "relevanceblender",
  "maxPages": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        "Playstation",
        "https://www.amazon.com/s?k=TV"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperforge/amazon-search-products-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 = {
    "startUrls": [
        "Playstation",
        "https://www.amazon.com/s?k=TV",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperforge/amazon-search-products-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 '{
  "startUrls": [
    "Playstation",
    "https://www.amazon.com/s?k=TV"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperforge/amazon-search-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Search Products Scraper",
        "description": "🛒 Amazon Search Products Scraper pulls structured data from Amazon search results — titles, prices, ratings, reviews, ASINs, Prime/availability, images & links. 🚀 Perfect for market research, price monitoring, SEO, and product discovery at scale.",
        "version": "0.1",
        "x-build-id": "15Ct5m2q5MUA4YqsX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperforge~amazon-search-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperforge-amazon-search-products-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/scraperforge~amazon-search-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperforge-amazon-search-products-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/scraperforge~amazon-search-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperforge-amazon-search-products-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Enter Amazon Keywords or Search URLs",
                        "type": "array",
                        "description": "List of keywords (e.g., 'Playstation', 'TV') or full Amazon search URLs. Each keyword will be used to search Amazon.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "amazonDomain": {
                        "title": "Amazon domain (optional)",
                        "type": "string",
                        "description": "Amazon domain to use (e.g., amazon.com, amazon.co.uk, amazon.de). Default: amazon.com",
                        "default": "amazon.com"
                    },
                    "language": {
                        "title": "Language (optional)",
                        "enum": [
                            "",
                            "en-US",
                            "en-GB",
                            "de-DE",
                            "fr-FR",
                            "es-ES",
                            "it-IT",
                            "ja-JP",
                            "zh-CN"
                        ],
                        "type": "string",
                        "description": "Language for Amazon pages. Leave empty for automatic detection based on domain.",
                        "default": ""
                    },
                    "proxyCountry": {
                        "title": "Proxy country (optional)",
                        "enum": [
                            "AUTO",
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "CA",
                            "AU",
                            "JP"
                        ],
                        "type": "string",
                        "description": "Country for proxy selection. Automatic selection based on Amazon domain if not specified.",
                        "default": "AUTO"
                    },
                    "sortOrder": {
                        "title": "Review sort order (optional)",
                        "enum": [
                            "relevanceblender",
                            "price-asc-rank",
                            "price-desc-rank",
                            "review-rank",
                            "date-desc-rank"
                        ],
                        "type": "string",
                        "description": "How to sort search results: 'relevanceblender' (relevance), 'price-asc-rank' (price low to high), 'price-desc-rank' (price high to low), 'review-rank' (customer reviews), 'date-desc-rank' (newest arrivals)",
                        "default": "relevanceblender"
                    },
                    "maxPages": {
                        "title": "Maximum pages per search (optional)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of pages to scrape per search keyword. If set to 1 or not specified, the actor will automatically continue scraping until all results are found (stops after 2 consecutive empty pages). Set a higher value to limit the number of pages scraped.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration (optional)",
                        "type": "object",
                        "description": "Choose proxy settings. Default: no proxy, with automatic fallback to datacenter and residential proxies if blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
