# StockX Scraper (`crawlerbros/stockx-scraper`) Actor

Scrape StockX, sneakers, apparel, accessories, electronics, collectibles, trading cards. Search by query, brand, or category, fetch by product slug, get prices, last-sale data, and sales history. Multi-currency.

- **URL**: https://apify.com/crawlerbros/stockx-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 16 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.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

## StockX Scraper

Scrape **StockX** — sneakers, apparel, accessories, electronics, collectibles,
trading cards and watches — at scale. Get product listings with current
**lowest-ask** prices, follow each tile to its product page for **last-sale**,
**highest-bid**, **release date**, **retail price**, **style ID**, and
**per-size variants**, or pull a product's **recent sales history**.

This actor is purpose-built for StockX's anti-bot stack (Cloudflare +
edge-network bot scoring): it ladders through `curl_cffi` (chrome131
TLS-fingerprint impersonation) → residential proxy → Camoufox (anti-detect
Firefox) automatically when the lower tiers get challenged.

### Use cases

- **Resale-price monitoring** — pull the lowest-ask, highest-bid and last-sale
  for any product line (Jordan 4, Yeezy 350 v2, Travis Scott, etc.) on a
  schedule.
- **New-release tracking** — list "Recently Released" sneakers daily and feed
  the slugs into byProduct mode for full detail.
- **Brand / category audits** — walk every Jordan, every Yeezy, every Rolex
  Submariner with `byBrand` or `byCategory`.
- **Sales-history backtesting** — pull recent transactions for a product and
  compute volatility, weekly volume, or seasonal patterns.
- **Multi-region pricing** — request prices in USD, EUR, GBP, JPY, AUD, CAD,
  CHF, HKD, SGD or MXN; routed through a residential proxy in the matching
  country for accurate localized pricing.

### Modes

| Mode | Input | What you get |
|------|-------|--------------|
| `search` | `searchQuery` (free-text) | Up to 40 product tiles per page, paginated |
| `byBrand` | `brand` (Nike, Jordan, Adidas, …) | All products tagged to the brand |
| `byCategory` | `category` (sneakers, apparel, …) | All products in the category |
| `byProduct` | `productSlugs[]` | One detail record per slug, with full market data |
| `byUrl` | `startUrls[]` | Mix of product / search / browse URLs |
| `salesHistory` | `productSlugs[]` | Recent transactions per product |

### Inputs

#### Mode & query

- `mode` — one of `search`, `byBrand`, `byCategory`, `byProduct`, `byUrl`, `salesHistory`. Default `search`.
- `searchQuery` — free-text. Default `jordan`.
- `brand` — dropdown of 50+ StockX brands (Nike, Jordan, Adidas, Yeezy,
  New Balance, ASICS, Supreme, Off-White, Louis Vuitton, Rolex, Casio, Apple,
  LEGO, Pokémon, …).
- `category` — dropdown: sneakers, apparel, accessories, electronics,
  collectibles, trading-cards, watches.
- `productSlugs` — array of slugs (the part after `stockx.com/`). Used by
  `byProduct` and `salesHistory` modes.
- `startUrls` — array of full StockX URLs (used by `byUrl`).

#### Region & locale

- `currency` — USD, EUR, GBP, JPY, AUD, CAD, CHF, HKD, SGD, MXN. Default `USD`.
- `country` — US, GB, DE, FR, IT, ES, NL, JP, AU, CA, CH, HK, SG, MX. Drives
  proxy country.

#### Filters

- `sortBy` — `featured`, `most_active`, `recently_released`,
  `price_high_to_low`, `price_low_to_high`. Default `featured`.
- `minPrice`, `maxPrice` — drop products outside the lowest-ask range.

#### Enrichment

- `fetchProductDetails` (boolean) — when true, follow each search tile to its
  product page and merge the richer detail record. Slower but richer. Default
  `false`.

#### Limits

- `maxItems` — hard cap on emitted records. 1–1000. Default 25.
- `maxPages` — pages of search/browse to walk. 1–50. Default 5.

#### Proxy & anti-bot

- `useProxy` — recommended `true`. StockX is hostile to datacenter IPs.
- `proxyConfiguration` — defaults to Apify Residential (recommended).
- `useBrowser` — set `true` to skip the HTTP tiers and go straight to
  Camoufox + residential. Slower but most reliable when StockX is hostile.

### Outputs

#### Product record (modes: search / byBrand / byCategory / byProduct / byUrl)

```json
{
  "recordType": "product",
  "siteName": "StockX",
  "scrapedAt": "2026-05-08T12:00:00+00:00",
  "slug": "air-jordan-4-retro-white-cement-2025",
  "productUrl": "https://stockx.com/air-jordan-4-retro-white-cement-2025",
  "title": "Jordan 4 Retro White Cement (2025)",
  "brand": "Jordan",
  "model": "Air Jordan 4",
  "productCategory": "sneakers",
  "styleId": "FV5029-100",
  "colorway": "White/Tech Grey-Fire Red-Black",
  "releaseDate": "2025-02-15",
  "retailPrice": 215.0,
  "lowestAsk": 215.0,
  "highestBid": 195.0,
  "lastSale": 225.0,
  "salesLast72Hours": 42,
  "deadstockSold": 12500,
  "annualHigh": 260.0,
  "annualLow": 205.0,
  "volatility": 0.08,
  "averageDeadstockPrice": 228.0,
  "currency": "USD",
  "region": "US",
  "imageUrl": "https://images.stockx.com/images/Air-Jordan-4-Retro-White-Cement-2025-Product.png",
  "gallery": ["https://images.stockx.com/...", "..."],
  "variants": [
    {"size": "10", "lowestAsk": 215, "highestBid": 195, "lastSale": 225},
    {"size": "10.5", "lowestAsk": 220, "highestBid": 200, "lastSale": 228}
  ]
}
````

Search-tile records (when `fetchProductDetails: false`) carry a subset:
`slug`, `productUrl`, `title`, `lowestAsk`, `currency`, `productCategory`,
`imageUrl`, `sponsored`, `sourceUrl`.

#### Sale record (mode: salesHistory)

```json
{
  "recordType": "sale",
  "siteName": "StockX",
  "scrapedAt": "2026-05-08T12:00:00+00:00",
  "chainId": "abc...",
  "amount": 215.0,
  "currency": "USD",
  "shoeSize": "10",
  "createdAt": "2025-01-01T00:00:00Z",
  "productSlug": "air-jordan-4-retro-white-cement-2025",
  "productUrl": "https://stockx.com/air-jordan-4-retro-white-cement-2025"
}
```

> Records are emitted with `strip_nulls` applied — empty strings, nulls,
> empty arrays and empty objects are never present in the dataset.

### FAQ

**Q: Do I need cookies or an account?**
A: No. StockX product/search/browse pages are public. The actor injects
`stockx_selected_currency` / `stockx_selected_region` cookies automatically
based on your `currency` and `country` inputs.

**Q: Why is residential proxy strongly recommended?**
A: StockX uses Cloudflare and additional bot-detection that flags datacenter
IPs (Hetzner, OVH, AWS, GCP, etc.) within a few requests. Residential proxy
makes search/browse reliable. The actor will auto-escalate to residential on
the first datacenter block; setting `useProxy: true` is the default.

**Q: Why are some `lowestAsk` fields missing?**
A: Products with no current asks (just released, sold out, or restocking)
display `--` on StockX. The actor omits these fields rather than emitting
a sentinel value.

**Q: Are sales-history transactions complete?**
A: We pull recent sales embedded in the product page's `__NEXT_DATA__` JSON.
Coverage depends on how much StockX hydrates server-side at request time —
typically dozens of recent sales per product.

**Q: Does the actor support cookies for logged-in features (Buyer/Seller dashboard)?**
A: Not in v1. All exposed surfaces are public. If you need account features,
open an issue.

**Q: Sometimes the run returns 0 records.**
A: Cloudflare can challenge entire ASN ranges intermittently. Try:

- Setting `useBrowser: true` to use Camoufox + residential.
- Re-running 10 minutes later (the IP may be on cooldown).
- Using a different `country` (different proxy ASN).

**Q: Can I run the actor without proxy?**
A: Yes — set `useProxy: false`. Works for a small burst, then expect blocks.

### Limitations

- Product pages frequently 403 from datacenter IPs even after a successful
  homepage warmup. Residential proxy mitigates this.
- StockX rotates obfuscated `__NEXT_DATA__` keys occasionally; the parser
  searches for products by structural heuristics (`urlKey` + `brand` /
  `productCategory`) rather than hard-coded paths, so updates don't break it.
- Sales-history coverage is per-page (whatever the product page hydrates),
  not the full historical archive.
- Multi-currency pricing depends on StockX honoring the
  `stockx_selected_currency` cookie + `x-stockx-currency` header. When the
  proxy IP is in a non-matching country, prices may revert to the IP's local
  currency.

# Actor input Schema

## `mode` (type: `string`):

What to fetch from StockX.

## `searchQuery` (type: `string`):

Free-text query, e.g. 'jordan 4 retro', 'yeezy 350', 'rolex submariner'.

## `brand` (type: `string`):

Brand slug. Used as both browse path and search constraint.

## `category` (type: `string`):

StockX top-level category.

## `productSlugs` (type: `array`):

StockX product URL slugs, e.g. \['air-jordan-4-retro-white-cement-2025']. Take from the URL after stockx.com/.

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

Direct StockX URLs (search, browse, or product pages).

## `currency` (type: `string`):

Currency for prices. StockX serves localized prices per region; we hint via the Accept-Currency header.

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

Region code. Drives the proxy country and Accept-Region header.

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

Sort applied to search/browse results.

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

Drop products with lowest-ask below this value (in selected currency).

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

Drop products with lowest-ask above this value (in selected currency).

## `fetchProductDetails` (type: `boolean`):

When true, follow each search result to its product page for richer data (last sale, retail price, release date, etc.). When false, emit only the search-card record. Default off — product pages are heavily protected and slow.

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

Hard cap on emitted records.

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

Maximum pages of search/browse results to walk. Each page returns up to 40 products.

## `useProxy` (type: `boolean`):

When true (recommended), routes via Apify residential proxy. StockX blocks datacenter IPs aggressively.

## `useBrowser` (type: `boolean`):

Skip the HTTP tiers and go straight to Camoufox + residential proxy. Slower (browser launch overhead) but most reliable when StockX's edge tier is hostile to even chrome131-impersonated curl\_cffi.

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

Residential proxy is mandatory for cloud runs. StockX uses Cloudflare + edge-network bot-detection that flags Apify datacenter IPs (Hetzner, OVH, AWS, GCP) within a handful of requests. RESIDENTIAL is the default group; we also use a sticky session id so warmup -> listing -> PDP shares the same egress IP.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "jordan",
  "brand": "jordan",
  "category": "sneakers",
  "productSlugs": [],
  "startUrls": [],
  "currency": "USD",
  "country": "US",
  "sortBy": "featured",
  "fetchProductDetails": false,
  "maxItems": 25,
  "maxPages": 5,
  "useProxy": true,
  "useBrowser": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped StockX product records.

# 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 = {
    "mode": "search",
    "searchQuery": "jordan",
    "brand": "jordan",
    "category": "sneakers",
    "productSlugs": [],
    "startUrls": [],
    "currency": "USD",
    "country": "US",
    "sortBy": "featured",
    "fetchProductDetails": false,
    "maxItems": 25,
    "maxPages": 5,
    "useProxy": true,
    "useBrowser": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/stockx-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 = {
    "mode": "search",
    "searchQuery": "jordan",
    "brand": "jordan",
    "category": "sneakers",
    "productSlugs": [],
    "startUrls": [],
    "currency": "USD",
    "country": "US",
    "sortBy": "featured",
    "fetchProductDetails": False,
    "maxItems": 25,
    "maxPages": 5,
    "useProxy": True,
    "useBrowser": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/stockx-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 '{
  "mode": "search",
  "searchQuery": "jordan",
  "brand": "jordan",
  "category": "sneakers",
  "productSlugs": [],
  "startUrls": [],
  "currency": "USD",
  "country": "US",
  "sortBy": "featured",
  "fetchProductDetails": false,
  "maxItems": 25,
  "maxPages": 5,
  "useProxy": true,
  "useBrowser": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call crawlerbros/stockx-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "StockX Scraper",
        "description": "Scrape StockX, sneakers, apparel, accessories, electronics, collectibles, trading cards. Search by query, brand, or category, fetch by product slug, get prices, last-sale data, and sales history. Multi-currency.",
        "version": "1.0",
        "x-build-id": "4WWKCxCgIL5Ox5OHh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~stockx-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-stockx-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/crawlerbros~stockx-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-stockx-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/crawlerbros~stockx-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-stockx-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byBrand",
                            "byCategory",
                            "byProduct",
                            "byUrl",
                            "salesHistory"
                        ],
                        "type": "string",
                        "description": "What to fetch from StockX.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text query, e.g. 'jordan 4 retro', 'yeezy 350', 'rolex submariner'.",
                        "default": "jordan"
                    },
                    "brand": {
                        "title": "Brand (mode=byBrand)",
                        "enum": [
                            "nike",
                            "jordan",
                            "adidas",
                            "yeezy",
                            "new-balance",
                            "asics",
                            "puma",
                            "reebok",
                            "converse",
                            "vans",
                            "supreme",
                            "off-white",
                            "fear-of-god",
                            "essentials",
                            "bape",
                            "stussy",
                            "kith",
                            "palace",
                            "anti-social-social-club",
                            "louis-vuitton",
                            "gucci",
                            "dior",
                            "chanel",
                            "hermes",
                            "balenciaga",
                            "prada",
                            "burberry",
                            "fendi",
                            "rolex",
                            "omega",
                            "audemars-piguet",
                            "patek-philippe",
                            "casio",
                            "tag-heuer",
                            "cartier",
                            "sony",
                            "apple",
                            "microsoft",
                            "samsung",
                            "nintendo",
                            "lego",
                            "funko",
                            "bearbrick",
                            "kaws",
                            "pokemon",
                            "topps",
                            "panini",
                            "upper-deck",
                            "hello-kitty",
                            "labubu",
                            "sanrio"
                        ],
                        "type": "string",
                        "description": "Brand slug. Used as both browse path and search constraint.",
                        "default": "jordan"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "sneakers",
                            "apparel",
                            "accessories",
                            "electronics",
                            "collectibles",
                            "trading-cards",
                            "watches"
                        ],
                        "type": "string",
                        "description": "StockX top-level category.",
                        "default": "sneakers"
                    },
                    "productSlugs": {
                        "title": "Product slugs (mode=byProduct or mode=salesHistory)",
                        "type": "array",
                        "description": "StockX product URL slugs, e.g. ['air-jordan-4-retro-white-cement-2025']. Take from the URL after stockx.com/.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Direct URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Direct StockX URLs (search, browse, or product pages).",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "JPY",
                            "AUD",
                            "CAD",
                            "CHF",
                            "HKD",
                            "SGD",
                            "MXN"
                        ],
                        "type": "string",
                        "description": "Currency for prices. StockX serves localized prices per region; we hint via the Accept-Currency header.",
                        "default": "USD"
                    },
                    "country": {
                        "title": "Country / Region",
                        "enum": [
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "JP",
                            "AU",
                            "CA",
                            "CH",
                            "HK",
                            "SG",
                            "MX"
                        ],
                        "type": "string",
                        "description": "Region code. Drives the proxy country and Accept-Region header.",
                        "default": "US"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "featured",
                            "most_active",
                            "recently_released",
                            "price_high_to_low",
                            "price_low_to_high"
                        ],
                        "type": "string",
                        "description": "Sort applied to search/browse results.",
                        "default": "featured"
                    },
                    "minPrice": {
                        "title": "Minimum price (lowest ask)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop products with lowest-ask below this value (in selected currency)."
                    },
                    "maxPrice": {
                        "title": "Maximum price (lowest ask)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop products with lowest-ask above this value (in selected currency)."
                    },
                    "fetchProductDetails": {
                        "title": "Fetch product detail pages",
                        "type": "boolean",
                        "description": "When true, follow each search result to its product page for richer data (last sale, retail price, release date, etc.). When false, emit only the search-card record. Default off — product pages are heavily protected and slow.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 25
                    },
                    "maxPages": {
                        "title": "Max pages",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum pages of search/browse results to walk. Each page returns up to 40 products.",
                        "default": 5
                    },
                    "useProxy": {
                        "title": "Use Apify proxy",
                        "type": "boolean",
                        "description": "When true (recommended), routes via Apify residential proxy. StockX blocks datacenter IPs aggressively.",
                        "default": true
                    },
                    "useBrowser": {
                        "title": "Force browser (Camoufox) tier",
                        "type": "boolean",
                        "description": "Skip the HTTP tiers and go straight to Camoufox + residential proxy. Slower (browser launch overhead) but most reliable when StockX's edge tier is hostile to even chrome131-impersonated curl_cffi.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy is mandatory for cloud runs. StockX uses Cloudflare + edge-network bot-detection that flags Apify datacenter IPs (Hetzner, OVH, AWS, GCP) within a handful of requests. RESIDENTIAL is the default group; we also use a sticky session id so warmup -> listing -> PDP shares the same egress IP.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
