# Google Shopping Scraper (`igview-owner/google-shopping-scraper`) Actor

Extract Google Shopping search results at scale – product titles, prices, original prices, discount %, ratings, reviews, store names, and shipping info. Scrape both organic listings and sponsored products.

- **URL**: https://apify.com/igview-owner/google-shopping-scraper.md
- **Developed by:** [Sachin Kumar Yadav](https://apify.com/igview-owner) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## 🛒 Google Shopping Scraper – Product Search Extractor

**🛍️ Search Google Shopping products by keyword and extract comprehensive listings with pricing, ratings, images, store info, discounts, and sponsored products. Supports pagination, advanced filtering, sorting options, and 25+ countries worldwide. Built with Apify best practices for reliability and speed.**

---

### 📋 Table of Contents

- [✨ Features](#-features)
- [🎯 Use Cases](#-use-cases)
- [⚡ Quick Start](#-quick-start)
- [📊 Input Parameters](#-input-parameters)
- [� Output Format](#-output-format)
- [🌐 Countries & Languages](#-countries--languages)
- [📈 Performance & Limits](#-performance--limits)
- [❓ FAQ](#-faq)
- [🛠️ Troubleshooting](#️-troubleshooting)
- [🏷️ Tags](#️-tags)

---

### ✨ Features

- **🔎 Keyword Search** – Search Google Shopping by any keyword or phrase
- ** Pagination Support** – Scrape multiple pages of search results (up to 10 pages)
- **💰 Price Filtering** – Filter by minimum and maximum price range
- **📊 Smart Sorting** – Sort by Best Match, Top Rated, Lowest or Highest Price
- **🏪 Store Filtering** – Filter results from specific stores (Amazon, Walmart, Best Buy, etc.)
- **📦 Condition Filter** – Filter by New, Used, or Refurbished products
- **🚚 Shipping & Returns** – Filter for free shipping and free returns only
- ** Sale Items** – Find only discounted/on-sale products
- **📢 Sponsored Products** – Extract sponsored/advertised product listings
- **⭐ Rich Metadata** – Ratings, reviews, discount percentages, store info, and more
- **🌍 Multi-Country** – Works across 25+ countries with 17 language options
- **⚡ Fast & Reliable** – Built-in retries, key rotation, rate-limit handling, and error recovery

---

### 🎯 Use Cases

| Use Case | Description | Key Benefits |
|----------|-------------|--------------|
| 🔍 Product Research | Discover products by keyword across Google Shopping | Find trending items, compare options |
| 💰 Price Comparison | Compare prices across multiple stores | Identify best deals, track price drops |
| 📊 Market Analysis | Analyze product listings and store presence | SEO insights, market trends |
| 🏆 Competitor Tracking | Monitor competitor products and pricing | Track rankings, pricing strategies |
| 📢 Ad Intelligence | Extract sponsored product listings | Analyze advertising strategies |
| 🏷️ Deal Hunting | Find on-sale products with discounts | Discover deals, coupon tracking |
| 🤖 Data Pipelines | Feed structured product data to your systems | Automation, dashboards, ML models |

---

### ⚡ Quick Start

#### 1️⃣ Basic – Simple Search
```json
{
  "query": "shoes"
}
````

#### 2️⃣ Intermediate – Multiple Pages with Sorting

```json
{
  "query": "wireless headphones",
  "maxPages": 3,
  "limit": 20,
  "sortBy": "TOP_RATED"
}
```

#### 3️⃣ Advanced – Full Filters

```json
{
  "query": "running shoes",
  "maxPages": 5,
  "limit": 50,
  "country": "us",
  "language": "en",
  "sortBy": "LOWEST_PRICE",
  "minPrice": 50,
  "maxPrice": 150,
  "productCondition": "NEW",
  "freeShipping": true,
  "onSale": true
}
```

***

### Input Parameters

| Parameter | Type | Required | Description | Default | Example |
|-----------|------|----------|-------------|---------|---------|
| `query` | String | ✅ Yes | Search keyword or phrase | - | `"shoes"`, `"laptop"`, `"headphones"` |
| `maxPages` | Integer | ❌ No | Number of pages to scrape (1-10) | `1` | `3`, `5`, `10` |
| `limit` | Integer | ❌ No | Products per page (1-100) | `10` | `20`, `50`, `100` |
| `country` | String | ❌ No | Country for regional results | `us` | `us`, `gb`, `de`, `in`, `jp` |
| `language` | String | ❌ No | Language for results | `en` | `en`, `fr`, `de`, `es` |
| `sortBy` | String | ❌ No | Sort order | `BEST_MATCH` | `TOP_RATED`, `LOWEST_PRICE`, `HIGHEST_PRICE` |
| `minPrice` | Integer | ❌ No | Minimum price filter | - | `50`, `100` |
| `maxPrice` | Integer | ❌ No | Maximum price filter | - | `200`, `500` |
| `productCondition` | String | ❌ No | Product condition filter | `ANY` | `NEW`, `USED`, `REFURBISHED` |
| `stores` | String | ❌ No | Comma-separated store names | - | `"amazon,walmart,best buy"` |
| `freeReturns` | Boolean | ❌ No | Only free returns products | `false` | `true` |
| `freeShipping` | Boolean | ❌ No | Only free shipping products | `false` | `true` |
| `onSale` | Boolean | ❌ No | Only on-sale/discounted products | `false` | `true` |

#### 🎯 Sort Options

- **BEST\_MATCH** – Most relevant to search query (default)
- **TOP\_RATED** – Highest rated products first
- **LOWEST\_PRICE** – Cheapest products first
- **HIGHEST\_PRICE** – Most expensive products first

#### 📦 Product Condition Options

- **ANY** – All conditions (default)
- **NEW** – Brand new products only
- **USED** – Pre-owned products only
- **REFURBISHED** – Refurbished/renewed products only

***

### 📤 Output Format

#### 🧾 Organic Product Data Structure

```json
{
  "source": "google_shopping",
  "type": "organic",
  "search_query": "shoes",
  "page": 1,
  "position": 1,
  "product_id": "catalogid:3825126699287686517,productid:15760960510130193747...",
  "product_title": "Nike Men's Air Max 95 Big Bubble",
  "price": "$160.00",
  "original_price": "$190",
  "on_sale": true,
  "discount_percent": "15% OFF",
  "product_photos": "https://encrypted-tbn0.gstatic.com/shopping?q=tbn:ANd9GcQ...",
  "store_name": "Finish Line",
  "product_rating": 4.6,
  "product_num_reviews": 11,
  "shipping": "Free delivery",
  "country": "us",
  "language": "en",
  "scraped_at": "2026-06-09T03:26:06.743Z"
}
```

#### 📢 Sponsored Product Data Structure

```json
{
  "source": "google_shopping",
  "type": "sponsored",
  "search_query": "shoes",
  "page": 1,
  "position": 1,
  "offer_id": "51661318029679",
  "offer_page_url": "https://emurj.com/womens/martine-rose/extended-toe-pumps/100132",
  "product_title": null,
  "price": null,
  "store_name": null,
  "merchant_id": "5512340318",
  "product_photos": "data:image/webp;base64,UklGRuAUAABXRUJQ...",
  "country": "us",
  "language": "en",
  "scraped_at": "2026-06-09T03:26:06.743Z"
}
```

#### Output Fields Explained

##### Organic Products

| Field | Type | Description |
|-------|------|-------------|
| `source` | String | Always `google_shopping` |
| `type` | String | `organic` for regular listings |
| `search_query` | String | Original search query |
| `page` | Integer | Page number in search results |
| `position` | Integer | Position on the page (1-based) |
| `product_id` | String | Google Shopping product identifier |
| `product_title` | String | Product name/title |
| `price` | String | Current price (e.g., "$160.00") |
| `original_price` | String | Original price before discount |
| `on_sale` | Boolean | Whether product is on sale |
| `discount_percent` | String | Discount text (e.g., "15% OFF") |
| `product_photos` | String | Product image URL |
| `store_name` | String | Selling store name |
| `product_rating` | Number | Average rating (1-5 scale) |
| `product_num_reviews` | Integer | Total number of reviews |
| `shipping` | String | Shipping/delivery information |
| `country` | String | Country code used for search |
| `language` | String | Language code used for search |
| `scraped_at` | String | ISO timestamp of scrape |

##### Sponsored Products

| Field | Type | Description |
|-------|------|-------------|
| `source` | String | Always `google_shopping` |
| `type` | String | `sponsored` for ads |
| `offer_id` | String | Unique offer identifier |
| `offer_page_url` | String | Direct link to product page |
| `product_title` | String | Product title (may be null) |
| `price` | String | Product price (may be null) |
| `store_name` | String | Store name (may be null) |
| `merchant_id` | String | Google Merchant ID |
| `product_photos` | String | Product image (base64 encoded) |

***

### 🌐 Countries & Languages

#### 🗺️ Supported Countries

| Region | Code | Region | Code | Region | Code |
|--------|------|--------|------|--------|------|
| 🇺🇸 United States | `us` | 🇬🇧 United Kingdom | `gb` | 🇩🇪 Germany | `de` |
| 🇫🇷 France | `fr` | 🇮🇹 Italy | `it` | 🇪🇸 Spain | `es` |
| 🇯🇵 Japan | `jp` | 🇮🇳 India | `in` | 🇨🇦 Canada | `ca` |
| 🇦🇺 Australia | `au` | 🇧🇷 Brazil | `br` | 🇲🇽 Mexico | `mx` |
| 🇳🇱 Netherlands | `nl` | 🇸🇪 Sweden | `se` | 🇵🇱 Poland | `pl` |
| 🇧🇪 Belgium | `be` | 🇦🇹 Austria | `at` | 🇨🇭 Switzerland | `ch` |
| 🇮🇪 Ireland | `ie` | 🇳🇿 New Zealand | `nz` | 🇸🇬 Singapore | `sg` |
| 🇦🇪 UAE | `ae` | 🇸🇦 Saudi Arabia | `sa` | 🇿🇦 South Africa | `za` |
| 🇹🇷 Türkiye | `tr` | 🇪🇬 Egypt | `eg` | | |

#### 🗣️ Supported Languages

| Language | Code | Language | Code | Language | Code |
|----------|------|----------|------|----------|------|
| English | `en` | Spanish | `es` | French | `fr` |
| German | `de` | Italian | `it` | Portuguese | `pt` |
| Dutch | `nl` | Polish | `pl` | Swedish | `sv` |
| Danish | `da` | Turkish | `tr` | Japanese | `ja` |
| Chinese | `zh` | Hindi | `hi` | Arabic | `ar` |
| Korean | `ko` | Russian | `ru` | | |

***

### 📈 Performance & Limits

| Metric | Value |
|--------|-------|
| Max pages per run | 10 |
| Max products per page | 100 |
| Max products per run | 1,000 (10 pages × 100 limit) |
| Avg request time | 2-5 seconds |
| Rate limiting | Automatic key rotation & retry |
| Delay between pages | 1.5 seconds |

***

### ❓ FAQ

- **Q: What input do I need?**
  - Just a search query (keyword/phrase). All other parameters are optional.

- **Q: How many products can I scrape?**
  - Up to 1,000 products per run (10 pages × 100 products per page).

- **Q: Which countries are supported?**
  - 25+ countries including US, GB, DE, FR, IT, ES, JP, IN, CA, AU, BR, MX, NL, SE, PL, BE, AT, CH, IE, NZ, SG, AE, SA, ZA, TR, EG.

- **Q: How do I filter by store?**
  - Use the `stores` parameter with comma-separated store names: `"amazon,walmart,best buy"`.

- **Q: What's the difference between organic and sponsored results?**
  - Organic results are regular product listings ranked by relevance. Sponsored results are paid advertisements by merchants.

- **Q: Why are some sponsored product fields null?**
  - Google Shopping often returns limited data for sponsored products (only offer URL and merchant ID may be available).

- **Q: How do I find only discounted products?**
  - Set `onSale` to `true` to get only products currently on sale with discount percentages.

- **Q: Can I filter by price range?**
  - Yes! Use `minPrice` and `maxPrice` parameters together or separately.

- **Q: What if no results are found?**
  - The actor will stop pagination and report the issue. Try a different search query or relax your filters.

***

### 🛠️ Troubleshooting

| Issue | Cause | Solution |
|-------|-------|----------|
| ❌ "No search query provided" | Empty or missing `query` | Provide a valid search keyword |
| ⚠️ "No products found" | Invalid query or filters too strict | Try broader search terms or remove filters |
| ⚠️ "No more products found" | All available results scraped | Normal behavior – reduce `maxPages` |
| ❌ "Access denied" | API key issue | Retry later or contact support |
| ❌ "Rate limit exceeded" | Too many requests | Wait and retry, automatic handling built-in |
| ⏱️ Slow runs | Many pages with high limit | Reduce `maxPages` or `limit` |
| 🔄 "Network error" | Connection issue | Check internet and retry |

***

### 🏆 Why Choose This Actor?

✅ Keyword-based search with full pagination\
✅ Advanced filtering (price, condition, stores, shipping, sales)\
✅ Both organic and sponsored product extraction\
✅ Rich metadata with ratings, reviews, and discounts\
✅ Works across 25+ countries and 17 languages\
✅ Smart sorting by relevance, price, or rating\
✅ Automatic retry and key rotation for reliability\
✅ Fast, structured, and production-ready data

***

### 🏷️ Tags

`google shopping scraper`, `google shopping api`, `google product search`, `google shopping extractor`, `product price comparison`, `google shopping deals`, `google shopping price tracker`, `product search scraper`, `google shopping data`, `shopping comparison tool`, `product listing extractor`, `google shopping sponsored ads`, `product rating scraper`, `store comparison tool`, `google shopping automation`, `product discovery`, `e-commerce scraper`, `price monitoring`, `deal finder`, `google shopping analytics`, `apify actor`

***

### 🚀 Get Started Now

**Ready to scrape Google Shopping results?**

1. 🎯 Enter the **search query** (e.g., `shoes`)
2. ⚙️ Set your **filters** (pages, price range, stores, etc.)
3. ▶️ Click **Start** to run the actor
4. 📥 Download your data in JSON, CSV, Excel, or HTML format
5. 📊 Use the built-in table views to browse products, prices, and ratings
6. Click ["Try for free"](https://apify.com?fpr=ykgg9c) to test the actor

**⭐ If this actor helps your workflow, please give it a star!**

***

*Built with ❤️ using Apify Platform | Optimized for Performance & Reliability*

# Actor input Schema

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

💬 Enter your search keyword or phrase (e.g., 'shoes', 'laptop', 'headphones'). This is the main search term to find products on Google Shopping.

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

📊 Number of search result pages to scrape (1-10). Each page contains up to the specified limit of products. More pages = more results but longer runtime.

## `limit` (type: `integer`):

🔢 Maximum number of products to return per page (1-100). Higher values return more products per request.

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

🗺️ Select the country/region for product offers. This determines the regional pricing, availability, and store results.

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

🌐 Select the language for search results.

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

🔢 Choose how to sort the search results.

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

💰 Only return products with price greater than this value. Leave empty for no minimum.

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

💰 Only return products with price lower than this value. Leave empty for no maximum.

## `productCondition` (type: `string`):

🏷️ Filter products by condition.

## `stores` (type: `string`):

🏬 Only return products from specific stores. Enter comma-separated store names (e.g., 'best buy,walmart,amazon'). Leave empty to include all stores.

## `freeReturns` (type: `boolean`):

✅ Only show products that offer free returns.

## `freeShipping` (type: `boolean`):

✅ Only show products that offer free shipping/delivery.

## `onSale` (type: `boolean`):

✅ Only show products that are currently on sale/discounted.

## Actor input object example

```json
{
  "query": "shoes",
  "maxPages": 1,
  "limit": 10,
  "country": "us",
  "language": "en",
  "sortBy": "BEST_MATCH",
  "productCondition": "ANY",
  "freeReturns": false,
  "freeShipping": false,
  "onSale": false
}
```

# Actor output Schema

## `search_results` (type: `string`):

Open the dataset view with an overview of all search results including query, position, title, price, rating, store, discount, and more.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "shoes",
    "maxPages": 1,
    "limit": 10,
    "country": "us",
    "language": "en",
    "sortBy": "BEST_MATCH",
    "productCondition": "ANY",
    "freeReturns": false,
    "freeShipping": false,
    "onSale": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("igview-owner/google-shopping-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "query": "shoes",
    "maxPages": 1,
    "limit": 10,
    "country": "us",
    "language": "en",
    "sortBy": "BEST_MATCH",
    "productCondition": "ANY",
    "freeReturns": False,
    "freeShipping": False,
    "onSale": False,
}

# Run the Actor and wait for it to finish
run = client.actor("igview-owner/google-shopping-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "query": "shoes",
  "maxPages": 1,
  "limit": 10,
  "country": "us",
  "language": "en",
  "sortBy": "BEST_MATCH",
  "productCondition": "ANY",
  "freeReturns": false,
  "freeShipping": false,
  "onSale": false
}' |
apify call igview-owner/google-shopping-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Shopping Scraper",
        "description": "Extract Google Shopping search results at scale – product titles, prices, original prices, discount %, ratings, reviews, store names, and shipping info. Scrape both organic listings and sponsored products.",
        "version": "0.0",
        "x-build-id": "5Ka3qqEij5vuwHpQM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/igview-owner~google-shopping-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-igview-owner-google-shopping-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/igview-owner~google-shopping-scraper/runs": {
            "post": {
                "operationId": "runs-sync-igview-owner-google-shopping-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/igview-owner~google-shopping-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-igview-owner-google-shopping-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "🔎 Search Query",
                        "minLength": 1,
                        "maxLength": 200,
                        "type": "string",
                        "description": "💬 Enter your search keyword or phrase (e.g., 'shoes', 'laptop', 'headphones'). This is the main search term to find products on Google Shopping.",
                        "default": "shoes"
                    },
                    "maxPages": {
                        "title": "📄 Maximum Pages",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "📊 Number of search result pages to scrape (1-10). Each page contains up to the specified limit of products. More pages = more results but longer runtime.",
                        "default": 1
                    },
                    "limit": {
                        "title": "📦 Products Per Page",
                        "minimum": 10,
                        "maximum": 100,
                        "type": "integer",
                        "description": "🔢 Maximum number of products to return per page (1-100). Higher values return more products per request.",
                        "default": 10
                    },
                    "country": {
                        "title": "🌍 Country",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "in",
                            "jp",
                            "br",
                            "mx",
                            "nl",
                            "se",
                            "pl",
                            "be",
                            "at",
                            "ch",
                            "ie",
                            "nz",
                            "sg",
                            "ae",
                            "sa",
                            "za",
                            "tr",
                            "eg"
                        ],
                        "type": "string",
                        "description": "🗺️ Select the country/region for product offers. This determines the regional pricing, availability, and store results.",
                        "default": "us"
                    },
                    "language": {
                        "title": "🗣️ Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "pl",
                            "sv",
                            "da",
                            "tr",
                            "ja",
                            "zh",
                            "hi",
                            "ar",
                            "ko",
                            "ru"
                        ],
                        "type": "string",
                        "description": "🌐 Select the language for search results.",
                        "default": "en"
                    },
                    "sortBy": {
                        "title": "📊 Sort Results By",
                        "enum": [
                            "BEST_MATCH",
                            "TOP_RATED",
                            "LOWEST_PRICE",
                            "HIGHEST_PRICE"
                        ],
                        "type": "string",
                        "description": "🔢 Choose how to sort the search results.",
                        "default": "BEST_MATCH"
                    },
                    "minPrice": {
                        "title": "💵 Minimum Price",
                        "type": "integer",
                        "description": "💰 Only return products with price greater than this value. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "💵 Maximum Price",
                        "type": "integer",
                        "description": "💰 Only return products with price lower than this value. Leave empty for no maximum."
                    },
                    "productCondition": {
                        "title": "📦 Product Condition",
                        "enum": [
                            "ANY",
                            "NEW",
                            "USED",
                            "REFURBISHED"
                        ],
                        "type": "string",
                        "description": "🏷️ Filter products by condition.",
                        "default": "ANY"
                    },
                    "stores": {
                        "title": "🏪 Filter by Stores",
                        "type": "string",
                        "description": "🏬 Only return products from specific stores. Enter comma-separated store names (e.g., 'best buy,walmart,amazon'). Leave empty to include all stores."
                    },
                    "freeReturns": {
                        "title": "🔁 Free Returns Only",
                        "type": "boolean",
                        "description": "✅ Only show products that offer free returns.",
                        "default": false
                    },
                    "freeShipping": {
                        "title": "🚚 Free Shipping Only",
                        "type": "boolean",
                        "description": "✅ Only show products that offer free shipping/delivery.",
                        "default": false
                    },
                    "onSale": {
                        "title": "🏷️ On Sale Only",
                        "type": "boolean",
                        "description": "✅ Only show products that are currently on sale/discounted.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
