# WebstaurantStore Scraper (`solidcode/webstaurantstore-scraper`) Actor

\[💰 $3.0 / 1K] Extract WebstaurantStore products — prices, brand, item numbers, UPC, specs, certifications, stock status, images, spec-sheet documents, and star ratings. Scrape by product, category, or search URL, or by keyword, across the food-service supply catalog.

- **URL**: https://apify.com/solidcode/webstaurantstore-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (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 $3.00 / 1,000 results

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## WebstaurantStore Scraper

Pull the full WebstaurantStore product catalog at scale — regular, sale, and member "Plus" prices, UPCs and manufacturer item numbers, NSF/UL certifications, live stock and freight flags, spec-sheet PDFs, images, and star ratings for every SKU. Built for food-service procurement teams, resellers and dropshippers, and price-monitoring analysts who need clean, structured catalog and pricing data without copy-pasting product pages one at a time.

### Why This Scraper?

- **Three price tiers on every product** — the regular `price`, the promotional `salePrice`, and the member-only "Plus" price (`plusPrice`), so you track the real transactable price instead of the sticker alone.
- **Honest MAP-price handling** — items under a Minimum Advertised Price policy return `price: null` by design, because the merchant hides the price until add-to-cart. You still get the full row (brand, specs, stock), and the null flags exactly which SKUs are MAP-restricted.
- **Identifiers built for catalog matching** — the WebstaurantStore `itemNumber` and the manufacturer `vendorItemNumber` on every product, plus the `upc` when full details are enabled, so you join this data to your own catalog, ERP, or a distributor feed without fuzzy name-matching.
- **Full specifications table plus NSF/UL certifications** — enable full details and each product returns a `specifications` object (dimensions, capacity, voltage, material, and more) and a `certifications` array (NSF, UL, ETL, and others) for compliance-sensitive sourcing.
- **Downloadable spec sheets and manuals** — with full details enabled, the `documents` array delivers direct PDF links to manufacturer spec sheets, manuals, and warranty docs from each product's detail page.
- **Live fulfillment signals** — `inStock`, `freeShipping`, and `commonCarrier` (freight) flags on every row, plus a human-readable `stockMessage` and `quickShip` eligibility when full details are enabled, so you know what's buyable and how it ships before you commit.
- **Whole-catalog reach across a dozen departments** — refrigeration, cooking equipment, smallwares, disposables, furniture, janitorial, and food & beverage, at up to 100 products per listing page.
- **Aggregate star rating + review count** — `rating` (0–5) and `reviewCount` on every product give you an at-a-glance demand and quality signal for ranking or filtering your dataset.

### Use Cases

**Price & MAP Monitoring**
- Track regular, sale, and "Plus" member prices across thousands of SKUs on a schedule
- Detect price drops and promotions the moment `salePrice` appears
- Flag MAP-restricted items (`price: null`) that hide their price until checkout
- Compare your own pricing against the largest US restaurant-supply catalog

**Product Catalog Enrichment**
- Fill gaps in your catalog with UPC, manufacturer item number, and full specifications
- Attach NSF/UL certifications and spec-sheet PDFs to your existing product records
- Pull main and gallery images to standardize your storefront imagery
- Normalize units of measure and shipping weights for logistics planning

**Competitor & Assortment Research**
- Map an entire department (refrigeration, smallwares, disposables) to size an assortment
- Benchmark competitor breadth, pricing, and brand mix by category
- Spot which products carry quick-ship or free-shipping incentives
- Track new items entering a category over time

**Dropship & Reseller Feeds**
- Build a ready-to-list product feed with titles, brands, prices, images, and stock
- Filter to in-stock, quick-ship items for reliable fulfillment
- Separate freight (`commonCarrier`) items that need special shipping handling
- Refresh availability and pricing before every marketplace upload

**Procurement & Sourcing**
- Source compliant equipment by filtering on NSF/UL certifications
- Compare capacity, voltage, and dimensions across models from the specifications table
- Download manufacturer manuals and spec sheets for purchase approvals
- Consolidate item numbers and UPCs for a clean purchase-order pipeline

### Getting Started

#### Simple Keyword Search

The fastest way to start — one keyword, 50 products:

```json
{
    "searchTerms": ["commercial refrigerator"],
    "maxItems": 50
}
````

#### Category URL with Full Details

Paste a category page and enrich every product with specs, certifications, documents, and all images:

```json
{
    "startUrls": [
        { "url": "https://www.webstaurantstore.com/52705/reach-in-refrigerators.html" }
    ],
    "includeDetails": true,
    "maxItems": 200
}
```

#### Multiple Searches at Once

Run several keyword searches in a single invocation and cap the total:

```json
{
    "searchTerms": ["sheet pan", "mixing bowl", "chafing dish"],
    "maxItems": 300
}
```

#### Mixed URLs and Keywords

Combine product, category, and search URLs with keywords — page types are detected automatically:

```json
{
    "startUrls": [
        { "url": "https://www.webstaurantstore.com/176BUNHF18US.html" },
        { "url": "https://www.webstaurantstore.com/52705/reach-in-refrigerators.html" }
    ],
    "searchTerms": ["ice machine"],
    "includeDetails": true,
    "maxItems": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | URL\[] | one sample category URL | WebstaurantStore page URLs — an individual product, a whole category, or a search results page. The page type is detected automatically and every product found is collected. |
| `searchTerms` | string\[] | `[]` | Keywords to search, such as "commercial refrigerator" or "sheet pan". Each keyword runs its own search and every matching product is collected. Leave empty to use URLs only. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `false` | Open each product's detail page to also collect full specifications, certifications, spec-sheet documents, the extended description, and all product images. Turn off for a faster run with just the core listing fields. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItems` | integer | `100` | Stop after collecting this many products in total across all URLs and keywords. A hard cap — you are never charged for more than this number of results. Set to `0` to collect everything found. |

### Output

Here's a representative product with full details enabled:

```json
{
    "url": "https://www.webstaurantstore.com/avantco-a-19r-hc-reach-in-refrigerator.html",
    "name": "Avantco A-19-HC 29\" Solid Door Reach-In Refrigerator",
    "brand": "Avantco",
    "description": "Keep your ingredients cold and organized with this Avantco A-19-HC reach-in refrigerator, featuring 19 cu. ft. of storage and a self-contained bottom-mount compressor...",
    "categories": ["Refrigeration Equipment", "Reach-In Refrigerators", "Solid Door Reach-In Refrigerators"],
    "itemNumber": "178A19RHC",
    "vendorItemNumber": "A-19R-HC",
    "upc": "840254605312",
    "price": 1329.00,
    "salePrice": 1199.00,
    "plusPrice": 1169.00,
    "currency": "USD",
    "inStock": true,
    "stockMessage": "In Stock — Ships today if ordered within 4 hours",
    "quickShip": true,
    "freeShipping": false,
    "commonCarrier": true,
    "unitOfMeasure": "Each",
    "weightLbs": 264.0,
    "specifications": {
        "Capacity": "19 cu. ft.",
        "Voltage": "115V",
        "Amps": "3.4",
        "Exterior Width": "29 Inches",
        "Number of Doors": "1"
    },
    "certifications": ["NSF Listed", "UL Sanitation", "ETL Listed"],
    "highlights": ["19 cu. ft. capacity", "Bottom-mount compressor", "3 adjustable shelves"],
    "documents": [
        { "name": "Specification Sheet", "url": "https://cdnimg.webstaurantstore.com/documents/pdf/178a19rhc_spec.pdf" },
        { "name": "Owner's Manual", "url": "https://cdnimg.webstaurantstore.com/documents/pdf/178a19rhc_manual.pdf" }
    ],
    "imageUrl": "https://cdnimg.webstaurantstore.com/images/products/large/178A19RHC.jpg",
    "images": [
        "https://cdnimg.webstaurantstore.com/images/products/large/178A19RHC.jpg",
        "https://cdnimg.webstaurantstore.com/images/products/large/178A19RHC_2.jpg"
    ],
    "rating": 4.7,
    "reviewCount": 213,
    "scrapedAt": "2026-07-18T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Product detail page URL |
| `name` | string | Product title |
| `brand` | string | Brand / manufacturer name |
| `description` | string | Extended product description (populated with `includeDetails`) |
| `categories` | string\[] | Breadcrumb category path |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

#### Identifiers

| Field | Type | Description |
|-------|------|-------------|
| `itemNumber` | string | WebstaurantStore item number |
| `vendorItemNumber` | string | Manufacturer / vendor item number |
| `upc` | string | UPC barcode (populated with `includeDetails`) |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number|null | Regular price. `null` for MAP-restricted items that hide the price until add-to-cart |
| `salePrice` | number|null | Promotional price when the item is on sale |
| `plusPrice` | number|null | Member "Plus" program price |
| `currency` | string | ISO 4217 currency code (USD) |

#### Stock & Shipping

| Field | Type | Description |
|-------|------|-------------|
| `inStock` | boolean | Whether the product is currently purchasable |
| `stockMessage` | string | Human-readable availability text (populated with `includeDetails`) |
| `quickShip` | boolean | Eligible for quick-ship handling (populated with `includeDetails`) |
| `freeShipping` | boolean | Ships free |
| `commonCarrier` | boolean | Ships by common carrier (freight) |
| `unitOfMeasure` | string | Selling unit (Each, Case, etc.) |
| `weightLbs` | number|null | Shipping weight in pounds |

#### Specs & Documents

| Field | Type | Description |
|-------|------|-------------|
| `specifications` | object | Key/value spec attributes — dimensions, capacity, voltage, material, and more (populated with `includeDetails`) |
| `certifications` | string\[] | Certifications such as NSF, UL, and ETL (populated with `includeDetails`) |
| `highlights` | string\[] | Marketing highlight bullets (populated with `includeDetails`) |
| `documents` | object\[] | Spec sheets and manuals as `{ name, url }` PDF links (populated with `includeDetails`) |

#### Media & Ratings

| Field | Type | Description |
|-------|------|-------------|
| `imageUrl` | string | Main product image URL |
| `images` | string\[] | All product image URLs (populated with `includeDetails`) |
| `rating` | number|null | Aggregate star rating (0–5) |
| `reviewCount` | integer | Number of customer reviews (count only) |

### Tips for Best Results

- **Leave `includeDetails` off for fast price sweeps.** Core listing fields — name, brand, all three price tiers, stock, and rating — come straight from the listing pages, so a details-off run is quick. Turn it on only when you also need UPCs, full specifications, certifications, spec-sheet PDFs, the extended description, and every image — those come from each product's own page, so expect a longer run (roughly a few minutes per 100 products). It costs the same either way — you pay per result — so on large categories with details on, set a `maxItems` cap to keep runs manageable.
- **Expect `price: null` on MAP-restricted items.** Some brands enforce a Minimum Advertised Price, so the store hides the number until add-to-cart. That row still bills as one result and still carries brand, specs, and stock — check `salePrice` and `plusPrice`, which are sometimes shown even when `price` is null.
- **Start small to validate.** Set `maxItems` to 10–50 on your first run to confirm the fields match your needs, then scale up.
- **Mix URLs and keywords in one run.** Product, category, and search URLs plus keyword searches can all go in a single invocation — page types are detected for you.
- **Use `vendorItemNumber` and `upc` for catalog joins.** They are the most reliable keys for matching WebstaurantStore products to your ERP, PIM, or a distributor feed — far more stable than product names.
- **Filter freight items with `commonCarrier`.** Large equipment ships by freight, not parcel — use this flag to route those SKUs into a separate fulfillment or quoting workflow.
- **Give each keyword its own entry in `searchTerms`.** The array runs one search per keyword, so broad and narrow terms return cleaner, non-overlapping result sets.

### Pricing

**From $3.00 per 1,000 results** — undercutting the going market rate for restaurant-supply catalog data. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows the total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.36 | $0.34 | $0.32 | $0.30 |
| 1,000 | $3.60 | $3.40 | $3.20 | $3.00 |
| 10,000 | $36.00 | $34.00 | $32.00 | $30.00 |
| 100,000 | $360.00 | $340.00 | $320.00 | $300.00 |

A "result" is any product row in the output dataset — MAP-restricted items count as one result even when the price field is `null`. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.**

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate price monitoring, catalog enrichment, market research, and product sourcing. Users are responsible for complying with applicable laws and WebstaurantStore's Terms of Service. Collect only publicly available product data, do not overload the source site, and do not use extracted data for spam, misrepresentation, or any unlawful purpose.

# Actor input Schema

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

Paste WebstaurantStore page URLs — an individual product page, a whole category, or a search results page. The scraper detects the page type automatically and collects every product it finds.

## `searchTerms` (type: `array`):

Search WebstaurantStore by keyword, for example 'commercial refrigerator' or 'sheet pan'. Each keyword runs its own search and every matching product is collected. Leave empty if you only want to use URLs above.

## `includeDetails` (type: `boolean`):

Open each product's detail page to also collect its full specifications, UPC, certifications, spec-sheet documents, extended description, and all product images. This makes the run noticeably slower — roughly a few minutes per 100 products, because each detail page is gathered individually — but it does NOT cost more (you pay per result, not per page). Leave it OFF for fast price and stock sweeps that only need the core listing fields (name, brand, all three prices, stock, rating). Tip: when this is on, set a Maximum Products cap so a large category doesn't turn into a very long run.

## `maxItems` (type: `integer`):

Stop after collecting this many products in total across all URLs and keywords. This is a hard cap — you will never receive or be charged for more than this number of results. Set to 0 to collect everything found. Note: 0 (unlimited) combined with Fetch Full Product Details on can make a very long run on a large category — set a cap here when details are on.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.webstaurantstore.com/52705/reach-in-refrigerators.html"
    }
  ],
  "searchTerms": [],
  "maxItems": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped products with name, brand, price, stock, and rating.

# 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": [
        {
            "url": "https://www.webstaurantstore.com/52705/reach-in-refrigerators.html"
        }
    ],
    "searchTerms": [],
    "includeDetails": false,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/webstaurantstore-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": [{ "url": "https://www.webstaurantstore.com/52705/reach-in-refrigerators.html" }],
    "searchTerms": [],
    "includeDetails": False,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/webstaurantstore-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": [
    {
      "url": "https://www.webstaurantstore.com/52705/reach-in-refrigerators.html"
    }
  ],
  "searchTerms": [],
  "includeDetails": false,
  "maxItems": 100
}' |
apify call solidcode/webstaurantstore-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WebstaurantStore Scraper",
        "description": "[💰 $3.0 / 1K] Extract WebstaurantStore products — prices, brand, item numbers, UPC, specs, certifications, stock status, images, spec-sheet documents, and star ratings. Scrape by product, category, or search URL, or by keyword, across the food-service supply catalog.",
        "version": "1.0",
        "x-build-id": "hPRvdWvB3jBecCT5I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~webstaurantstore-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-webstaurantstore-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/solidcode~webstaurantstore-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-webstaurantstore-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/solidcode~webstaurantstore-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-webstaurantstore-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": {
                    "startUrls": {
                        "title": "Product, Category or Search URLs",
                        "type": "array",
                        "description": "Paste WebstaurantStore page URLs — an individual product page, a whole category, or a search results page. The scraper detects the page type automatically and collects every product it finds.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerms": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Search WebstaurantStore by keyword, for example 'commercial refrigerator' or 'sheet pan'. Each keyword runs its own search and every matching product is collected. Leave empty if you only want to use URLs above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDetails": {
                        "title": "Fetch Full Product Details",
                        "type": "boolean",
                        "description": "Open each product's detail page to also collect its full specifications, UPC, certifications, spec-sheet documents, extended description, and all product images. This makes the run noticeably slower — roughly a few minutes per 100 products, because each detail page is gathered individually — but it does NOT cost more (you pay per result, not per page). Leave it OFF for fast price and stock sweeps that only need the core listing fields (name, brand, all three prices, stock, rating). Tip: when this is on, set a Maximum Products cap so a large category doesn't turn into a very long run."
                    },
                    "maxItems": {
                        "title": "Maximum Products",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after collecting this many products in total across all URLs and keywords. This is a hard cap — you will never receive or be charged for more than this number of results. Set to 0 to collect everything found. Note: 0 (unlimited) combined with Fetch Full Product Details on can make a very long run on a large category — set a cap here when details are on."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
