# Currys Product Scraper (`sian.agency/currys-product-scraper`) Actor

Scrape Currys products — price, was-price, ratings, images, specs & finance. Keyword or category search, full detail enrichment, clean JSON/CSV, no code (UK · GBP).

- **URL**: https://apify.com/sian.agency/currys-product-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.75 / 1,000 overview products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Currys Product Scraper — Prices, Specs & Offers (UK) 🛒

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Google Shopping Price Scraper](https://img.shields.io/badge/Store-Google%20Shopping%20Price%20Scraper-4285F4)](https://apify.com/sian.agency/google-shopping-price-scraper?fpr=sian) [![Amazon Influencer & Deals Scraper](https://img.shields.io/badge/Store-Amazon%20Deals%20Scraper-FF9900)](https://apify.com/sian.agency/amazon-influencer-deals-scraper?fpr=sian) [![Walmart Product Scraper](https://img.shields.io/badge/Store-Walmart%20Product%20Scraper-0071CE)](https://apify.com/sian.agency/walmart-data-scraper?fpr=sian)

#### 🎉 Pull Currys prices, was-prices, offers, ratings, and full specs — by keyword or category, no code
##### Built for UK retail analysts, e-commerce sellers, and brands who need fresh Currys product data on demand

---

### 📋 Overview

**Track every price, promotion, and product spec on Currys — without writing a single line of code.** This scraper turns any Currys search or category into a clean, structured spreadsheet of products, complete with prices in GBP, was-prices, offers, ratings, images, and finance options.

**Why UK retail professionals choose us:**
- ✅ **Complete product data**: 25+ fields per product — price, was-price, offers, rating, review count, brand, SKU, EAN, finance and more
- ⚡ **Fast search-first mode**: pull 20 products per page in seconds; scale to thousands across multiple searches
- 🎯 **Native GBP pricing**: every price, was-price and finance figure exactly as a UK shopper sees it
- 💰 **Pay only for results**: charged per product you actually receive — no wasted spend, free tier to test
- 💎 **Detail enrichment**: add the full specifications table and long product description with one switch
- ✨ **NEW**: search by keyword *or* category, sort by most popular, price, or customer rating — just like the Currys site

---

### ✨ Features

- 🔎 **Keyword & Category Search**: scrape any Currys search term or category page
- 🏷️ **Full Pricing**: current price, was/marked price and every attached offer or promotion (GBP)
- 📆 **Finance Options**: headline monthly payment and representative APR where offered
- ⭐ **Ratings & Reviews**: star rating and total review count for every product
- 🖼️ **Product Images**: all product image URLs, ready for catalogs or feeds
- 📋 **Full Specifications**: complete technical spec table in detail mode
- 📝 **Long Descriptions**: the full marketing description in detail mode
- 🧭 **Category Breadcrumbs**: the full taxonomy path for each product
- 🛡️ **Care Plans**: available protection / care-plan options
- 📦 **Availability**: in-stock status and delivery availability label

---

### 🎬 Quick Start

Pick a mode, type a keyword (or paste a category id), set how many products you want — run. Results land in a clean dataset you can export to JSON, CSV or Excel.

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~currys-product-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"keywords": ["wireless headphones"], "scrapeMode": "overview", "maxResults": 40}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose what to scrape

Add one or more search keywords (e.g. `dishwasher`, `4k tv`) — or, for advanced category harvesting, paste a Currys category id.

#### Step 2: Pick a mode & sort

Choose **Overview** (fast) or **Detail** (full specs), then sort by most popular, price, or customer rating.

#### Step 3: Run & export

Start the run and export your products as JSON, CSV or Excel.

**That's it! In a couple of minutes, you'll have:**

- A clean spreadsheet of Currys products with GBP pricing
- Ratings, images, offers and finance for each product
- Full specification tables (in detail mode)

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| keywords | array | No | Free-text Currys searches (one per line) |
| categoryIds | array | No | Advanced: Currys category ids to harvest whole categories |
| scrapeMode | string | No | `overview` (fast) or `detail` (full specs + description) |
| sort | string | No | `most_popular`, `price_low`, `price_high`, `top_rated` |
| maxResults | integer | No | Cap on total products returned (FREE: 25, PAID: unlimited) |

Provide either `keywords` OR `categoryIds` (at least one is required).

**Example:**

```json
{
  "keywords": ["wireless headphones", "dishwasher"],
  "scrapeMode": "detail",
  "sort": "top_rated",
  "maxResults": 100
}
```

***

### 📤 Output

Results are saved to the Apify dataset with **25+ fields** including:

| Field | Type | Description |
|-------|------|-------------|
| productTitle | string | Full product name |
| brand | string | Manufacturer / brand |
| price | number | Current selling price (GBP) |
| original\_price | number | Was / marked price (GBP) |
| currency | string | Always `GBP` |
| rating | number | Average customer rating (out of 5) |
| review\_count | number | Number of customer reviews |
| images | array | All product image URLs |
| in\_stock | boolean | Whether the product is buyable now |
| availability | string | Availability label |
| category | string | Leaf category |
| offers | array | Promotion / offer descriptions |
| monthly\_payment | number | Headline finance monthly amount (GBP) |
| specs | object | Full key/value spec table (detail mode) |
| description | string | Long product description (detail mode) |

**Example:**

```json
{
  "item_id": "10299058",
  "productTitle": "SAMSUNG Galaxy Buds4 Pro Wireless Bluetooth Noise-Cancelling Earbuds - Black",
  "brand": "SAMSUNG",
  "price": 219.0,
  "original_price": null,
  "currency": "GBP",
  "rating": 4.8,
  "review_count": 965,
  "in_stock": true,
  "category": "IN EAR HEADPHONES",
  "url": "https://www.currys.co.uk/products/samsung-galaxy-buds4-pro-...-10299058.html"
}
```

***

### 💼 Use Cases & Examples

#### 1. Price & Promo Monitoring

**Retail analysts tracking Currys prices over time.**
**Input:** A list of category keywords · **Output:** Daily price, was-price and offers · **Use:** Spot price drops and competitor promotions early.

#### 2. Competitor Pricing Intelligence

**Electronics sellers benchmarking against Currys.**
**Input:** Keywords for your product range · **Output:** GBP prices, ratings and stock · **Use:** Position your own pricing against the UK market leader.

#### 3. Catalog & Assortment Research

**Brands auditing how their products appear on Currys.**
**Input:** Brand or product keywords · **Output:** Full product records with specs · **Use:** Verify listings, imagery and spec accuracy.

#### 4. Product-Spec Extraction for Feeds

**Marketplaces and aggregators building product feeds.**
**Input:** Category ids in detail mode · **Output:** Full spec tables + descriptions · **Use:** Populate rich product feeds without manual entry.

#### 5. Stock & Availability Checks

**Resellers monitoring what's in stock.**
**Input:** Specific product keywords · **Output:** In-stock flags and availability labels · **Use:** Trigger reorders or alerts.

#### 6. UK Electronics Market Research

**Analysts studying the UK consumer-electronics market.**
**Input:** Broad category keywords · **Output:** Prices, ratings, review counts · **Use:** Measure demand, ratings and pricing trends.

***

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/currys-product-scraper').call({
  keywords: ['wireless headphones'],
  scrapeMode: 'overview',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/currys-product-scraper').call(
    run_input={'keywords': ['wireless headphones'], 'scrapeMode': 'overview'}
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~currys-product-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"keywords": ["wireless headphones"]}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule or webhook
2. **HTTP Request**: Call actor API
3. **Process**: Handle JSON results
4. **Action**: Save, notify, or transform

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **25 products** per run — full feature access, same quality
- No credit card required
- Perfect for testing and small projects

#### PAID Tier (Production Ready)

- **Unlimited** products per run
- Faster processing, no delays
- Pay-per-result: only charged for products you actually receive

💰 **Transparent pay-per-result pricing** — the fast Overview row is the cheap, high-volume option; Detail adds the full spec sheet when you need it.

🔗 [View current pricing](https://apify.com/sian.agency/currys-product-scraper?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: How many products can I scrape?**
A: FREE tier: 25 per run. PAID tier: unlimited.

**Q: What currency are prices in?**
A: All prices, was-prices and finance figures are in GBP — Currys is a UK retailer.

**Q: What's the difference between Overview and Detail mode?**
A: Overview returns search-result data fast (price, ratings, images, offers, finance). Detail adds the full specifications table and the long product description from each product page.

**Q: How do I scrape a whole category?**
A: Use the advanced `categoryIds` field — paste a Currys category id. Or just use keywords; a broad keyword automatically resolves to its category.

**Q: What output formats are available?**
A: JSON, CSV, Excel — export directly from the Apify dataset.

**Q: Is this legal?**
A: Yes — we only extract publicly available data. See the legal section below.

***

### 🐛 Troubleshooting

**No products returned**

- Check your keyword spelling and try a broader term.
- Some very niche terms return few results — try a category-level keyword.

**Fewer products than expected**

- FREE tier is capped at 25 products per run — upgrade for unlimited.
- A lower-than-expected `maxResults` will cap the output.

**Missing specs / description**

- Specs and long descriptions only populate in **Detail** mode. Switch `scrapeMode` to `detail`.

***

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

**Trademark notice:** Currys™ is a trademark of Currys Group Limited. This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Currys. "Currys" is used only to describe the publicly available data this tool helps you collect.

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's repository
- Check [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `keywords` (type: `array`):

🔍 **KEYWORD SEARCH:** Free-text Currys searches — exactly what you'd type into the site's search bar.

📝 **EXAMPLES:** `wireless headphones` · `dishwasher` · `4k tv` · `acer laptop`

💡 **TIP:** Add one keyword per line — each runs as its own search and all results land in the same dataset.

🖊️ **BULK EDIT:** Click "Bulk edit" to paste many keywords at once (one per line).

✅ **IMPORTANT:** Provide either keywords OR category ids (at least one is needed to have something to scrape).

## `categoryIds` (type: `array`):

🧭 **CATEGORY BROWSING (Advanced):** Scrape a whole Currys category instead of a keyword search.

🔧 **HOW TO GET IT:** Open any Currys category page, then copy the category id — the `cgid` value. The fastest way: run a keyword search first and read the dataset's `category` / breadcrumbs, or copy the id from the category URL slug (e.g. `all-laptops-laptops-computing`). Paste just the id here.

💡 **TIP:** Leave this empty if you're only using keywords — it's purely an advanced alternative for category-level harvesting.

🖊️ **BULK EDIT:** Add one category id per line to sweep multiple categories in a single run.

## `scrapeMode` (type: `string`):

⚙️ **SCRAPE DEPTH:** Choose how much data to pull per product.

⚡ **Overview (fast):** Search results only — price, was-price, offers, ratings, images, brand/model and finance options. Fastest and cheapest path.

🔬 **Detail (enriched specs):** Everything in Overview PLUS the full specifications table and the long product description scraped from each product page.

💡 **TIP:** Start with Overview to scope your catalog, then switch to Detail when you need the complete spec sheet for feeds or comparisons.

## `sort` (type: `string`):

🔃 **RESULT ORDERING:** Order search results using Currys' own native sort options — so you get the same ranking real shoppers see.

🏆 **Most popular** surfaces the best-selling products first · 💲 **Price** sorts ascending or descending · ⭐ **Customer rating** leads with the highest-reviewed items.

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

🔢 **RESULT CAP:** Maximum number of products to return across all keywords and categories combined.

🎁 **TIER-BASED LIMITS:**

- **FREE users:** Up to 25 products per run
- **PAID users:** Unlimited — scrape entire catalogs in a single run

💡 **TIP:** Keep this low while you dial in your keywords, then raise it once the output looks right.

## Actor input object example

```json
{
  "keywords": [
    "wireless headphones"
  ],
  "scrapeMode": "overview",
  "sort": "most_popular",
  "maxResults": 100
}
```

# Actor output Schema

## `currysProducts` (type: `string`):

Scraped Currys products with prices, promotions, ratings, images, specs and availability.

# 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 = {
    "keywords": [
        "wireless headphones"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/currys-product-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 = { "keywords": ["wireless headphones"] }

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/currys-product-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 '{
  "keywords": [
    "wireless headphones"
  ]
}' |
apify call sian.agency/currys-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Currys Product Scraper",
        "description": "Scrape Currys products — price, was-price, ratings, images, specs & finance. Keyword or category search, full detail enrichment, clean JSON/CSV, no code (UK · GBP).",
        "version": "1.0",
        "x-build-id": "kuguVc9xWaNAU24mA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~currys-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-currys-product-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/sian.agency~currys-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-currys-product-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/sian.agency~currys-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-currys-product-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": {
                    "keywords": {
                        "title": "🔍 Search Keywords",
                        "type": "array",
                        "description": "🔍 **KEYWORD SEARCH:** Free-text Currys searches — exactly what you'd type into the site's search bar.\n\n📝 **EXAMPLES:** `wireless headphones` · `dishwasher` · `4k tv` · `acer laptop`\n\n💡 **TIP:** Add one keyword per line — each runs as its own search and all results land in the same dataset.\n\n🖊️ **BULK EDIT:** Click \"Bulk edit\" to paste many keywords at once (one per line).\n\n✅ **IMPORTANT:** Provide either keywords OR category ids (at least one is needed to have something to scrape).",
                        "default": [
                            "wireless headphones"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryIds": {
                        "title": "🧭 Category IDs (Advanced)",
                        "type": "array",
                        "description": "🧭 **CATEGORY BROWSING (Advanced):** Scrape a whole Currys category instead of a keyword search.\n\n🔧 **HOW TO GET IT:** Open any Currys category page, then copy the category id — the `cgid` value. The fastest way: run a keyword search first and read the dataset's `category` / breadcrumbs, or copy the id from the category URL slug (e.g. `all-laptops-laptops-computing`). Paste just the id here.\n\n💡 **TIP:** Leave this empty if you're only using keywords — it's purely an advanced alternative for category-level harvesting.\n\n🖊️ **BULK EDIT:** Add one category id per line to sweep multiple categories in a single run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeMode": {
                        "title": "⚙️ Scrape Mode",
                        "enum": [
                            "overview",
                            "detail"
                        ],
                        "type": "string",
                        "description": "⚙️ **SCRAPE DEPTH:** Choose how much data to pull per product.\n\n⚡ **Overview (fast):** Search results only — price, was-price, offers, ratings, images, brand/model and finance options. Fastest and cheapest path.\n\n🔬 **Detail (enriched specs):** Everything in Overview PLUS the full specifications table and the long product description scraped from each product page.\n\n💡 **TIP:** Start with Overview to scope your catalog, then switch to Detail when you need the complete spec sheet for feeds or comparisons.",
                        "default": "overview"
                    },
                    "sort": {
                        "title": "🔃 Sort Order",
                        "enum": [
                            "most_popular",
                            "price_low",
                            "price_high",
                            "top_rated"
                        ],
                        "type": "string",
                        "description": "🔃 **RESULT ORDERING:** Order search results using Currys' own native sort options — so you get the same ranking real shoppers see.\n\n🏆 **Most popular** surfaces the best-selling products first · 💲 **Price** sorts ascending or descending · ⭐ **Customer rating** leads with the highest-reviewed items.",
                        "default": "most_popular"
                    },
                    "maxResults": {
                        "title": "🔢 Max Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "🔢 **RESULT CAP:** Maximum number of products to return across all keywords and categories combined.\n\n🎁 **TIER-BASED LIMITS:**\n- **FREE users:** Up to 25 products per run\n- **PAID users:** Unlimited — scrape entire catalogs in a single run\n\n💡 **TIP:** Keep this low while you dial in your keywords, then raise it once the output looks right.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
