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

🛒 Amazon Search Products Scraper extracts product data from Amazon search results—titles, prices, ratings, reviews, ASINs, images, sellers & availability. ⚡ Fast, scalable, pagination & filters support. 📊 Export CSV/JSON, API-ready. 🔎 Perfect for market research & price monitoring.

- **URL**: https://apify.com/scrapeengine/amazon-search-products-scraper.md
- **Developed by:** [ScrapeEngine](https://apify.com/scrapeengine) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 4 total users, 2 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, reliable Amazon search results scraper that turns keywords or Amazon search URLs into structured product data at scale. It eliminates manual copy-paste by extracting ASINs, prices, ratings, images, and availability from Amazon SERPs—an ideal Amazon product search scraper and Amazon product data extractor for market research, pricing, and catalog analysis. Built for marketers, developers, data analysts, and researchers, it helps you scrape Amazon product search results across supported marketplaces and move from search to insight efficiently. 🚀

### What data / output can you get?

Below are real fields captured from Amazon search pages. Items are pushed to the Apify dataset in real time and can be exported as JSON, CSV, or Excel.

| Data type | Description | Example value |
| --- | --- | --- |
| asin | Unique product identifier (ASIN) | B0CL5KNB9M |
| productDescription | Title/description shown in search results | “PlayStation®5 Digital Edition (slim)” |
| price | Current price parsed from the listing | 499.99 |
| retailPrice | Original/retail price when present | 549.99 |
| productRating | Star rating text from the SERP | “4.7 out of 5 stars” |
| countReview | Number of customer reviews | 10500 |
| dpUrl | Product page URL (may be relative) | “/PlayStation%C2%AE5-Digital-slim-PlayStation-5/dp/B0CL5KNB9M” |
| imgUrl | Product image URL from the search result | https://m.media-amazon.com/images/I/51fM0CKG+HL._AC_UY218_.jpg |
| prime | Prime eligibility flag | false |
| sponsored | Sponsored listing flag | false |
| salesVolume | “Bought in past month” string when available | “7K+ bought in past month” |
| deliveryMessage | Shipping/delivery info when detected | “FREE delivery Tue, Apr 21” |

Bonus metadata you’ll also get:
- manufacturer, series, variations, productDetails, secondaryOffer (used/refurbished price if detected)
- categories, resultCount, similarKeywords (related search suggestions), currentPage, sortStrategy, searchResultPosition
- keyword, domainCode, page, selectedCategory, browseNode, nodeHierarchy, statusCode, statusMessage

### Key features

- 🧠 Smart SERP parsing  
  Cleans and extracts product metadata (ASIN, price, rating, reviews, image, availability) from Amazon results—perfect for an Amazon product listing scraper or Amazon product details scraper workflow.

- 🌍 Multi-marketplace support  
  Scrape amazon.com, amazon.co.uk, amazon.de, amazon.fr, amazon.it, amazon.es, and amazon.ca via the amazonDomain option—ideal for an Amazon product catalog scraper across regions.

- 🔎 Keywords or full URLs  
  Feed keywords or Amazon search URLs using startUrls to drive an Amazon product search scraper tool without writing custom code.

- 🧭 Sorting controls  
  Choose sortOrder: relevanceblender, price-asc-rank, price-desc-rank, review-rank, or date-desc-rank to tailor your Amazon search results scraper runs.

- 📄 Automatic pagination  
  By default, it continues across pages until results are exhausted (stops after 2 consecutive empty pages) or up to your maxPages limit—great for Amazon product listings extraction at scale.

- 🛡️ Proxy-aware reliability  
  Configure proxyConfiguration and proxyCountry. When a proxy is enabled, the actor falls back between datacenter and residential proxies for fewer blocks—robust for Amazon price scraping tool pipelines.

- 🗣️ Language header selection  
  Set language to control Accept-Language headers for localized scraping—useful for an Amazon product details scraper in multiple locales.

- 📤 Real-time dataset output  
  Each product is pushed as it’s found. Export to JSON/CSV/Excel or integrate via the Apify API—an effective Amazon product search API alternative for automation.

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

1. Create or log in to your Apify account 🟢  
   Access the actor from the Apify platform.

2. Open the Amazon Search Products Scraper  
   In the Apify Store, click “Try for free” to start a new run.

3. Add input data  
   In “Enter Amazon Keywords or Search URLs” (startUrls), paste keywords and/or full Amazon search URLs (e.g., “Playstation”, “https://www.amazon.com/s?k=TV”).

4. Configure marketplace & language  
   - Set amazonDomain (e.g., amazon.com, amazon.co.uk, amazon.de, …).  
   - Set language for Accept-Language headers (leave empty "" to auto-align with domain).

5. Choose sorting, depth, and location  
   - sortOrder to control ranking (relevance, price, reviews, newest arrivals).  
   - maxPages to cap depth, or leave the default to auto-continue.  
   - proxyCountry to prefer a specific country when using proxies.

6. Enable proxy if needed  
   Configure proxyConfiguration and set useApifyProxy to true for higher success on large runs (the actor supports datacenter/residential fallback).

7. Run the actor  
   Click Start. Logs show each keyword, page, and the number of products saved.

8. Download results  
   Open the Dataset tab to view items. Export as JSON, CSV, or Excel, or access programmatically via the Apify API.

Pro Tip: Schedule runs and pipe dataset results into your analytics stack for ongoing monitoring—great for an Amazon ASIN scraper and Amazon SERP scraper for products.

### Use cases

| Use case | Description |
| --- | --- |
| Market research & trend tracking | Identify trending products and categories, compare ratings, and benchmark pricing across supported locales using structured search data. |
| Price monitoring & analytics | Track current vs. retail prices, Prime flags, and delivery messaging for pricing models and alerting. |
| Affiliate & content teams | Enrich product roundups with ASINs, ratings, and positions from an Amazon product search scraper tool. |
| Dropshipping product sourcing | Discover high-demand items using salesVolume and review signals with an Amazon product listing scraper approach. |
| Competitive intelligence | Analyze brands and sponsored placements to map competitors on Amazon SERPs. |
| Data pipelines & enrichment | Feed resultCount, categories, and similarKeywords into BI dashboards or ML models through the Apify API. |

### Why choose Amazon Search Products Scraper?

Built for precision, automation, and reliability, this Amazon product data scraper delivers structured outputs ready for analysis and workflows.

- 🔍 Accurate parsing for ASINs, prices, ratings, reviews, availability
- 🌐 Multi-marketplace support across amazon.com, .co.uk, .de, .fr, .it, .es, .ca
- 🧰 Developer-friendly via Apify Dataset & API for pipelines and apps
- 🧭 Sorting & pagination controls for flexible Amazon product search results crawler runs
- 🛡️ Proxy-ready with datacenter/residential fallback when configured
- 💾 Easy exports (JSON/CSV/Excel) for analytics and reporting
- 🚀 Cloud-native and scalable—more reliable than browser extensions or local tools

In short, it’s a production-ready Amazon product search scraper that scales beyond manual tools and unstable alternatives.

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

Yes—when done responsibly. This actor extracts publicly available product information (e.g., titles, prices, ratings) from Amazon search pages.

Guidelines for compliant use:
- Only collect public product data and avoid personal information.
- Respect Amazon’s terms and applicable laws (e.g., GDPR, CCPA).
- Use proxies responsibly and avoid excessive request rates.
- Consult your legal team for edge cases and large-scale operations.

### Input parameters & output format

#### Example input (JSON)
```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)\
  Description: List of keywords (e.g., 'Playstation', 'TV') or full Amazon search URLs. Each keyword will be used to search Amazon.\
  Default: none\
  Required: Yes

- amazonDomain (string)\
  Description: Amazon domain to use (e.g., amazon.com, amazon.co.uk, amazon.de). Default: amazon.com\
  Default: "amazon.com"\
  Required: No

- language (string)\
  Description: Language for Amazon pages. Leave empty for automatic detection based on domain.\
  Default: ""\
  Required: No

- proxyCountry (string)\
  Description: Country for proxy selection. Automatic selection based on Amazon domain if not specified.\
  Default: "AUTO"\
  Required: No

- sortOrder (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"\
  Required: No

- maxPages (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\
  Required: No

- proxyConfiguration (object)\
  Description: Choose proxy settings. Default: no proxy, with automatic fallback to datacenter and residential proxies if blocked.\
  Default: { "useApifyProxy": false }\
  Required: No

#### Example output (JSON)

```json
[
  {
    "asin": "B0CL5KNB9M",
    "productDescription": "PlayStation®5 Digital Edition (slim)",
    "imgUrl": "https://m.media-amazon.com/images/I/51fM0CKG+HL._AC_UY218_.jpg",
    "price": 499.99,
    "retailPrice": 549.99,
    "productRating": "4.7 out of 5 stars",
    "countReview": 10500,
    "dpUrl": "/PlayStation%C2%AE5-Digital-slim-PlayStation-5/dp/B0CL5KNB9M",
    "prime": false,
    "sponsored": false,
    "salesVolume": "7K+ bought in past month",
    "deliveryMessage": "FREE delivery Tue, Apr 21",
    "manufacturer": "Sony",
    "series": null,
    "variations": [],
    "productDetails": [
      "Ultra-high speed SSD for fast load times",
      "Haptic feedback for more immersive gaming"
    ],
    "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" }
    ],
    "currentPage": 1,
    "sortStrategy": "relevanceblender",
    "searchResultPosition": 0
  }
]
```

Notes:

- Numeric fields like price, retailPrice, countReview, and secondaryOffer may be null or 0.0 if not present on the SERP.
- dpUrl may be relative; resolve it using the domain indicated by domainCode.
- Arrays such as categories, similarKeywords, variations, and productDetails may be empty when data is not available.

### FAQ

#### Is there a trial or free usage option?

✅ Yes. This actor includes 120 trial minutes so you can evaluate the Amazon product search scraper tool before subscribing.

#### Does it support different Amazon countries and languages?

✅ Yes. Choose amazonDomain (amazon.com, amazon.co.uk, amazon.de, amazon.fr, amazon.it, amazon.es, amazon.ca) and set language to control Accept-Language for localized runs.

#### Can I sort Amazon search results?

✅ Yes. Use sortOrder to select relevanceblender, price-asc-rank, price-desc-rank, review-rank, or date-desc-rank for tailored Amazon product search results crawler runs.

#### How deep can it scrape per query?

✅ By default, it auto-continues across pages until results are exhausted (it stops after 2 consecutive empty pages). Set maxPages to limit depth and speed up runs.

#### What data fields does it return?

✅ You’ll get ASINs, productDescription, price and retailPrice, productRating, countReview, dpUrl and imgUrl, Prime/sponsored flags, salesVolume, deliveryMessage, manufacturer/series/variations/productDetails, plus metadata like categories, resultCount, similarKeywords, and searchResultPosition.

#### How do I export or integrate the data?

✅ All items are saved to the Apify dataset. Export to JSON/CSV/Excel from the UI, or access via the Apify API to power an Amazon product search API alternative in your workflows.

#### Do I need proxies?

ℹ️ Not always, but Amazon can block direct requests. Enable proxyConfiguration with useApifyProxy for best reliability. The actor supports fallback between datacenter and residential proxies when available.

#### Is this suitable for ASIN collection and SERP analysis?

✅ Yes. It functions as an Amazon ASIN scraper by capturing asin for each result and provides searchResultPosition and similarKeywords for SERP analytics.

### Final thoughts

Amazon Search Products Scraper is built to turn Amazon search pages into clean, structured product datasets for research, pricing, and analytics. With keyword/URL inputs, marketplace and language controls, smart pagination, and proxy-ready reliability, it’s a scalable Amazon search results scraper for teams that need fast, dependable outputs. Marketers, analysts, developers, and researchers can export to JSON/CSV/Excel or plug into the Apify API to automate end‑to‑end pipelines. Start extracting smarter product insights and build your next market advantage 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("scrapeengine/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("scrapeengine/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 scrapeengine/amazon-search-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapeengine/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 extracts product data from Amazon search results—titles, prices, ratings, reviews, ASINs, images, sellers & availability. ⚡ Fast, scalable, pagination & filters support. 📊 Export CSV/JSON, API-ready. 🔎 Perfect for market research & price monitoring.",
        "version": "0.1",
        "x-build-id": "ktN9VmHdfHJSsZwYr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~amazon-search-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-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/scrapeengine~amazon-search-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-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/scrapeengine~amazon-search-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
