# StockX Scraper – Sneaker Prices, Resale Data & Product Details (`rl1987/stockx-api-scraper`) Actor

Scrape StockX resale prices and product data: lowest ask, highest bid, last sale and retail price, plus per-size market data. Search by keyword or browse sneakers, streetwear, watches, handbags, electronics, collectibles and trading cards. No login and no browser automation.

- **URL**: https://apify.com/rl1987/stockx-api-scraper.md
- **Developed by:** [R.L.](https://apify.com/rl1987) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 77 total users, 28 monthly users, 99.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.54 / 1,000 product rows

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## StockX Scraper – Sneaker Prices, Resale Market Data & Product Details

**Scrape StockX at scale.** Extract sneakers, streetwear, watches, handbags, electronics, collectibles, and trading cards with live resale pricing — lowest ask, highest bid, and last sale — plus full product details, per-size market data and the individual sales behind the price chart. Search by keyword, look up products you already have ids for, or pull a product's whole sales history. No login, no browser automation, no rate-limit headaches.

Perfect for **sneaker resellers, price monitoring, dropshipping, market research, arbitrage, and price-comparison apps**.

### What does this StockX scraper do?

- **Keyword search** — find any product ("Jordan 1 Retro High", "Yeezy 350", "Rolex Submariner")
- **Three modes** — keyword search (with category, brand, gender and activity filters plus server-side sorting), product lookup by id/slug/URL, and per-sale price history
- **Live resale pricing** — lowest ask, highest bid, last sale, retail price
- **Per-size market data** — pricing across every available size (optional PDP enrichment)
- **Rich product data** — title, brand, model, colorway, style ID, images, description, release date
- **Fast API-based extraction** — no headless browser, low memory (runs on 128 MB)
- **Built-in proxy support** — routes through Apify Proxy by default

### Who uses a StockX scraper?

| Who | Why |
|-----|-----|
| Sneaker resellers | Track lowest ask / last sale to spot arbitrage and price trends |
| E-commerce & dropshipping | Pull catalog + pricing to feed price-comparison and listing tools |
| Market researchers | Monitor resale demand across brands, models, and categories |
| Developers | Get clean StockX JSON via API without reverse-engineering the site |

### StockX pricing terms, explained

StockX runs as a bid/ask marketplace rather than a fixed-price store, so the numbers in the output
mean something specific:

| Field | What it means |
| --- | --- |
| `lowestAsk` | The lowest ask **across all sizes** — the cheapest any seller will sell any size at right now. |
| `highestBid` | The highest bid **across all sizes** — the most any buyer will pay for any size right now. |
| `lastSale` | The price the most recent completed transaction actually cleared at. |
| `retailPrice` | The original launch price from the brand, for comparison against resale value. |

**Do not subtract the two product-level numbers.** They are aggregated across sizes and come from
*different* sizes — measured across products, the lowest ask is typically a small size and the
highest bid the largest — so `highestBid - lowestAsk` can come out positive and look like
risk-free arbitrage when no such trade exists. They are faithful to the two headline numbers
StockX itself shows, and they are not an order book.

**The bid-ask spread exists per size.** With **Include product details** enabled, `variantSizes`
breaks the book down per size and carries a `spread` field (that size's own ask minus its own
bid), which is the number to trade on — a shoe can sit above retail in one size and below it in
another.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | select | `search` (keyword), `product` (look up ids/slugs/URLs you already have), `salesHistory` (one row per individual sale). Default `search` |
| `q` | string | Search keyword (e.g. `Jordan 1 Retro High`) |
| `productIds` | array | For `product` and `salesHistory`: a product id, a slug (`air-jordan-1-retro-low-og-chicago-2025`) or a full `stockx.com` URL — StockX accepts the id and the slug interchangeably |
| `country` | string | Two-letter market code selecting **whose order book is quoted**. Default `US` |
| `currency` | select | 30 currencies — `USD`, `EUR`, `GBP`, `JPY`, `CAD`, `AUD`, `CHF`, `HKD`, `KRW`, `MXN`, `SEK`, `PLN`, `SGD`, `NZD`, `NOK`, `DKK`, `BRL`, `CLP`, `CNY`, `HUF`, `IDR`, `ILS`, `KWD`, `MOP`, `MYR`, `PEN`, `PHP`, `THB`, `TWD`, `VND`. Default `USD` |
| `includeDetails` | boolean | Fetch PDP fields (description, release date, per-size `variantSizes` with `spread`, 12-month statistics). Off by default for speed — **and it bills two events per product**, see Cost below |
| `minPrice` / `maxPrice` | integer | Keep only products in this price band, in the selected currency. Applied by the Actor **before billing**, so filtered-out products cost nothing |
| `maxItems` | integer | Max products to scrape. `0` = no limit (default `100`) |
| `maxPages` | integer | Stop after this many result pages (~40 products each; StockX clamps to 40 but has been seen returning 43), for a predictable per-run cost. `0` = no page limit |
| `maxSalesPerProduct` | integer | `salesHistory` only: sales per product, newest first. `0` = the whole history (one popular Jordan 1 has 18,000+) |
| `salesSince` | string | `salesHistory` only: stop at the first sale older than this date, e.g. `2026-01-01` |
| `category` | select | Scope to one StockX category: `sneakers`, `apparel`, `accessories`, `collectibles`, `shoes`, `trading-cards`, `electronics`. Works on its own or with a keyword. `streetwear` → Apparel, `watches`/`handbags` → Accessories |
| `brand` | select | Scope to one brand, server-side — `Nike`, `Jordan`, `adidas`, `New Balance`, `Pokemon`, `Louis Vuitton`, … Spelling- and case-exact, and it matches the `brandName` in the output, so a brand you see can be pasted back in. Other brands can be typed |
| `gender` | select | `men`, `women`, `kids`, `unisex`, `infant`, `toddler`, `preschool`, `child` — the complete set StockX accepts |
| `activity` | select | `running`, `basketball`, `soccer`, `football`, `skateboarding`, `tennis`, `golf`, `hiking`, `baseball` |
| `sortBy` | select | Server-side ordering: `featured`, `most-active`, `lowest_ask`, `highest_bid`, `recent_bids`, `recent_asks`, `deadstock_sold`, `release_date`, `price_premium`, `last_sale` |
| `proxyConfiguration` | object | Proxy settings (Apify Proxy on by default) |

#### Markets and currencies

`country` and `currency` are independent. `country` picks which market's order book is quoted;
`currency` only denominates it. For one product on the same day:

| `country` / `currency` | lowest ask | highest bid | last sale |
| --- | --- | --- | --- |
| `US` / `USD` | 245 | 645 | 345 |
| `GB` / `GBP` | 300 | 461 | 260 |
| `DE` / `EUR` | 366 | 554 | 308 |
| `JP` / `JPY` | 52,300 | 68,900 | 54,700 |
| `GB` / `USD` | 398 | 612 | 345 |

Every row echoes the `currency` it is denominated in, so a dataset collected across markets stays
unambiguous.

#### Modes

| Mode | What you give it | What you get |
| --- | --- | --- |
| `search` | `q` and/or any of `category` / `brand` / `gender` / `activity`, optionally `sortBy`, `minPrice`/`maxPrice`, `maxItems`, `maxPages` | One row per product |
| `product` | `productIds` | One row per product, always detail-enriched. No search needed if you already have ids |
| `salesHistory` | `productIds`, `maxSalesPerProduct`, `salesSince` | One row per completed sale (amount + timestamp) — the price history itself, not a summary |

#### Filters

`category`, `brand`, `gender` and `activity` are all applied **by StockX**, not by this
Actor — so they narrow the result set itself, and you are never charged for a row that was
filtered out. They combine: brand `adidas` + gender `men` + category `sneakers` returns only
adidas men's sneakers, and any of them works on its own with no keyword at all.

A contradictory combination returns nothing rather than quietly widening — brand `Pokemon`
with activity `running` is zero rows, and the run says so.

Two notes on values. **Brand is spelling- and case-exact**: `Hoka One One` works,
`HOKA ONE ONE` does not. And a brand also matches its collaborations, so asking for `Nike`
includes Palace x Nike. The `brand` and `activity` lists are the values verified to return
results rather than a complete catalogue, so you can type others; `gender` is a closed set of
eight, and the plausible-but-wrong guesses (`boys`, `girls`, `youth`, `male`, `female`) are
refused with an explanation instead of returning an empty run.

`minPrice` / `maxPrice` are the exception — StockX has no working server-side price filter
(its `lowest-ask-range` is accepted and ignored), so those two are applied by the Actor,
before billing.

#### Sorting

`sortBy` is applied by StockX, not by this Actor, so it orders the whole result set rather than
the page in hand. Each option carries the direction StockX declares for it — "Price: low to high"
is ascending, "Last sale: high to low" descending — which is why there is no separate direction
input: sending any other direction returns the default feed instead.

**On search depth:** StockX reports a constant `total: 1000` for every query — an empty query and
a hyper-specific product title both come back with 1000 — so it is not a result count and not a
ceiling. Paging continues past it and keeps returning new products, so this Actor stops when a
page delivers nothing new rather than at a reported total. To collect a wide slice of the
catalogue, combine `category` with several narrower keywords rather than running one broad
search, and use `sortBy` to take the top of a slice (cheapest, most-sold, newest) rather than
paging through all of it.

### Cost

| What you run | Events billed per product |
| --- | --- |
| `search` without details | `plp-row` |
| `search` with **Include product details** | `plp-row` **+** `pdp-row` |
| `product` mode | `pdp-row` only |
| `salesHistory` | `sales-history-row` per sale |

The price of each event is on the **Pricing** tab of this Actor's page, which is generated from
the Actor's own pricing record and is always current.

A detail-enriched product is charged twice, because two units of work happened: it was returned
by a search *and* then enriched from its product page — so it costs the sum of both events, not
one of them. Budget accordingly.
Products removed by `minPrice`/`maxPrice` are never charged, and `product` mode is not billed for
a list row it never had. Platform usage (compute, proxy, transfer) is passed through on top, as
shown on the Pricing tab.

Give a search keyword (`search` mode) or product ids (`product` / `salesHistory` mode). An input
with neither has no way in: the run finishes with a message saying so and charges nothing.

#### Example input

```json
{
  "mode": "search",
  "q": "Jordan 1 Retro High",
  "country": "GB",
  "currency": "GBP",
  "includeDetails": true,
  "maxItems": 50
}
```

Filters need no keyword — women's adidas running shoes, cheapest first:

```json
{
  "mode": "search",
  "category": "sneakers",
  "brand": "adidas",
  "gender": "women",
  "activity": "running",
  "sortBy": "lowest_ask",
  "maxItems": 100
}
```

A product lookup, for ids you already have:

```json
{
  "mode": "product",
  "productIds": [
    "air-jordan-1-retro-low-og-chicago-2025",
    "https://stockx.com/air-jordan-1-retro-high-og-chicago-reimagined-lost-and-found"
  ]
}
```

The last 200 sales of one product:

```json
{
  "mode": "salesHistory",
  "productIds": ["air-jordan-1-retro-high-og-chicago-reimagined-lost-and-found"],
  "maxSalesPerProduct": 200
}
```

### Output

Each product is one dataset record:

```json
{
  "id": "...",
  "name": "Jordan 1 Retro High OG Chicago",
  "title": "Jordan 1 Retro High OG Chicago Lost & Found",
  "brandName": "Jordan",
  "model": "Jordan 1 Retro High",
  "colorway": "Varsity Red/Black-Sail-Muslin",
  "styleId": "DZ5485-612",
  "retailPrice": 180,
  "currency": "USD",
  "lowestAsk": 310,
  "highestBid": 275,
  "lastSale": 295,
  "thumbUrl": "https://images.stockx.com/...",
  "images": ["https://images.stockx.com/..."],
  "productUrl": "https://stockx.com/...",
  "productSlug": "air-jordan-1-...",
  "description": "...",
  "releaseDate": "2021-11-19",
  "lastSaleDate": "2026-10-14T10:18:05.701Z",
  "salesLast72Hours": 158,
  "salesThisPeriod": 158,
  "volatility": 0.432846,
  "pricePremium": 1.226,
  "premiumOverRetail": 115,
  "premiumOverRetailPct": 63.89,
  "changeValue": -80,
  "changePercentage": -0.188235,
  "annualHigh": 1899,
  "annualLow": 230,
  "annualAveragePrice": 273,
  "annualSalesCount": 5257,
  "last72HoursAveragePrice": 341,
  "last72HoursSalesCount": 48,
  "deadstockSold": 18321,
  "deadstockAveragePrice": 404,
  "variantSizes": [
    { "size": "10", "lowestAsk": 320, "highestBid": 280, "spread": 40,
      "lastSale": 300, "lastSaleDate": "2026-10-13T...", "salesLast72Hours": 2 }
  ]
}
```

#### Market depth

| Field | What it means |
| --- | --- |
| `salesLast72Hours` / `last72HoursSalesCount` | How many pairs actually sold in the last three days — the "can I sell it, and how fast" number |
| `annualSalesCount` / `annualAveragePrice` | 12-month sales count and average clearing price |
| `annualHigh` / `annualLow` | 12-month price range |
| `volatility` | StockX's own volatility measure for the product |
| `changeValue` / `changePercentage` | Movement over StockX's current comparison window |
| `premiumOverRetail` / `premiumOverRetailPct` | `lastSale - retailPrice`, and that as a percentage of retail. Derived here |
| `pricePremium` | StockX's own premium figure, passed through unchanged — not the same number as `premiumOverRetailPct` |
| `last90DaysAveragePrice` / `last90DaysSalesCount` | 90-day average clearing price and sales count |
| `annualRangeHigh` / `annualRangeLow` | 12-month range as StockX charts it (tighter than the absolute high/low) |
| `lastLowestAskTime` / `lastHighestBidTime` | When each side of the book was last set — how stale the quote is |
| `deadstockSold` / `deadstockAveragePrice` | All-time deadstock units sold and their average price |
| `variantSizes[].spread` | That size's own ask minus its own bid — the only level at which a spread is meaningful |

`description`, `releaseDate`, `variantSizes`, the `annual*` / `last72Hours*` statistics and the
`deadstock*` fields are populated only when **Include product details** is enabled (or in
`product` mode, which always enriches).

#### Sales history rows

`salesHistory` mode emits one row per completed sale instead of one row per product, and bills per row — so `maxSalesPerProduct` and `salesSince` are the knobs that bound a run's cost:

```json
{
  "productId": "019cfdb4-3545-7b24-8773-11f7411145fb",
  "productName": "Jordan 1 Retro High OG Chicago Lost and Found",
  "productSlug": "air-jordan-1-retro-high-og-chicago-reimagined-lost-and-found",
  "styleId": "DZ5485-612",
  "amount": 345,
  "currency": "USD",
  "soldAt": "2026-10-14T10:18:05.701Z",
  "size": "11",
  "variantId": "019cfdb6-e638-72d1-a095-f063f172217b",
  "orderType": "EXPRESS"
}
```

Newest first, 50 sales per request, **billed per sale row**, and **each sale carries the size it sold in** — so the series
can be pivoted per size even though the feed itself is product-level. Use `maxSalesPerProduct` or
`salesSince` to take a window instead of the whole history.

### Export formats

Download results as **JSON, CSV, Excel, or XML**, or pull them programmatically via the [Apify API](https://docs.apify.com/api/v2). Push to Google Sheets, Airtable, Zapier, Make, and more through [Apify integrations](https://apify.com/integrations).

### n8n integration

Use the [`n8n-nodes-stockx-scraper`](https://www.npmjs.com/package/n8n-nodes-stockx-scraper) community node ([source](https://github.com/rl1987/n8n-nodes-stockx-scraper)) to run this Actor directly from an n8n workflow — search or look products up by id, get Simplified/Raw/Selected output, and use it as an AI Agent tool.

### How does it work?

The scraper talks directly to StockX's data API instead of rendering pages, so it's fast and cheap:

1. Runs a keyword search, a product lookup, or a sales-history walk
2. Paginates results up to `maxItems`
3. Optionally enriches each product with PDP details and per-size market data
4. Stores structured records in the dataset

### FAQ

**Is scraping StockX legal?** This tool collects publicly available data. You are responsible for complying with StockX's terms and applicable law. Don't collect personal data.

**Do I need an account or API key?** No StockX account needed. Runs on Apify with built-in proxy.

**Can I get per-size prices?** Yes — enable **Include product details** to get `variantSizes` with per-size ask/bid/last-sale.

**Which categories are supported?** Sneakers, streetwear, watches, handbags, electronics, collectibles, and trading cards.

**What is the difference between lowest ask and highest bid?** The lowest ask is the cheapest price a seller will accept right now; the highest bid is the most a buyer will currently pay. See the pricing terms table above.

**Can I track sneaker prices over time?** Yes. StockX exposes the current market state, not a price history, so build a history by scheduling the Actor and appending each run to the same dataset. Running daily gives you a daily price series per product and size.

**Does it work for Jordan, Yeezy, Dunk, New Balance and other popular models?** Yes — search by keyword (`"Jordan 1 Retro High"`, `"Yeezy 350"`, `"Dunk Low Panda"`), scope to a category, or pass product ids/URLs directly in `product` mode. There is no per-brand restriction.

**Can I get prices for a specific shoe size?** Yes — enable **Include product details** and read `variantSizes`, which carries ask, bid and last sale for every size StockX lists.

### Resources

- [Apify Platform documentation](https://docs.apify.com/platform)
- [Apify API reference](https://docs.apify.com/api/v2)
- [Integrations: Make, Zapier, Google Sheets, and more](https://apify.com/integrations)
- [n8n community node for this Actor](https://www.npmjs.com/package/n8n-nodes-stockx-scraper)
- [Join the Apify Discord community](https://discord.com/invite/jyEM2PRvMU)

### Sneaker & streetwear resale toolkit

Part of the **Sneaker & streetwear resale toolkit** — resale-market pricing and product data across the major sneaker/streetwear marketplaces and brands:

- [GOAT API Scraper](https://apify.com/rl1987/goat-api-scraper) — Scrapes GOAT.com product listings by search query or category.
- [Supreme API Scraper](https://apify.com/rl1987/supreme-api-scraper) — Supreme catalogue: categories, full product detail, every colour/size variant.
- [Nike API Scraper](https://apify.com/rl1987/nike-api-scraper) — Scrape Nike.com listings and full product detail from api.nike.com.
- [Puma API Scraper](https://apify.com/rl1987/puma-api-scraper) — Scrapes PUMA.com product listing and detail via mobile app GraphQL API.

### Did you find this useful?

Rate this actor on Apify! Your feedback helps other users find it and helps us keep improving it.

# Actor input Schema

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

What to scrape. <b>Search</b> finds products by keyword. <b>Product lookup</b> takes StockX product ids, slugs or URLs you already have. <b>Sales history</b> returns the individual sales behind a product's price chart, one row per sale.

## `q` (type: `string`):

Keywords to search for sneakers (e.g. 'Jordan 1 Retro High'). Give this or a category - an input with neither has no way in and collects nothing.

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

Scope the browse to one StockX category. Works on its own (no keyword needed) or alongside a search keyword. Three values from the old dropdown are not StockX categories and are redirected to the one that holds them, so saved tasks keep working.

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

Scope to one brand, server-side. Works on its own or with any other filter. <b>Spelling- and case-exact</b> — <code>Hoka One One</code> works, <code>HOKA ONE ONE</code> does not. The value matches the <code>brandName</code> this Actor returns, so a brand you see in the output can be pasted straight back in. The list is the brands verified to work, not all of them — type any exact StockX brand name. Note a brand also matches its collaborations (asking for Nike returns Palace x Nike).

## `gender` (type: `string`):

Scope to one gender or age group, server-side. These eight are the complete set StockX accepts — <code>boys</code>, <code>girls</code>, <code>youth</code>, <code>male</code> and <code>female</code> are <b>not</b> among them and are refused with an explanation rather than returning an empty run.

## `activity` (type: `string`):

Scope to one sport or activity, server-side. These nine are verified to return results; <code>lifestyle</code>, <code>training</code>, <code>gym</code>, <code>walking</code> and <code>outdoor</code> are not accepted. The list may be incomplete, so other values can be typed — one that matches nothing ends the run with a message saying so, unbilled.

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

Order the results server-side. Each option carries the sort direction StockX itself declares for it (sending any other direction silently returns the default feed, so the direction is not a separate input).

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

Keep only products whose lowest ask is at least this much, in the selected currency. StockX's API takes no price arguments, so this is applied by the Actor — but it is applied <b>before billing</b>, so filtered-out products are never charged.

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

Keep only products whose lowest ask is at most this much, in the selected currency. Applied by the Actor <b>before billing</b>, so filtered-out products are never charged.

## `productIds` (type: `array`):

Used by <b>Product lookup</b> and <b>Sales history</b>. Each entry can be a StockX product id (<code>019cfdb4-3545-7b24-8773-11f7411145fb</code>), a product slug (<code>air-jordan-1-retro-high-og-chicago-reimagined-lost-and-found</code>) or a full product URL (<code>https://stockx.com/air-jordan-1-retro-low-og-chicago-2025</code>) — StockX accepts the id and the slug interchangeably.

## `maxSalesPerProduct` (type: `integer`):

<b>Sales history</b> only. How many individual sales to collect per product, newest first. <code>0</code> = the whole history, which can be large — one popular Jordan 1 has over 18,000 sales. <b>Sales are billed per row</b>, so this is the knob that bounds the cost of a run: the default 100 is $0.15 per product.

## `salesSince` (type: `string`):

<b>Sales history</b> only. Stop at the first sale older than this date, e.g. <code>2026-01-01</code>. The feed is newest-first, so this is a cheap way to ask for a recent window instead of the whole history.

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

Two-letter ISO 3166 country code selecting <b>whose order book is quoted</b>. A resale price is market-specific: for one product the lowest ask was 245 in <code>US</code> and 398 in <code>GB</code>, both in USD. Defaults to <code>US</code>, which is what every run returned before this input existed.

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

Currency the ask / bid / last-sale amounts are denominated in. Independent of the market: <code>GB</code> + <code>USD</code> gives the UK book priced in dollars. Every value listed here is accepted by StockX.

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

Fetch each product's detail page for description, release date, per-size market pricing (<code>variantSizes</code>, including a per-size bid-ask <code>spread</code>) and the 12-month statistics. <b>Billing:</b> a detail-enriched product is charged twice — once as a product-list row and once as a product-detail row — so it costs $1.50 per 1,000 rather than $0.75. Off by default for speed and cost.

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

Maximum number of products to scrape. 0 = all (no limit).

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

Stop after this many result pages, for a predictable per-run cost. A page is <b>about 40 products</b> — StockX clamps the page size to 40 but has been measured returning 43 — so budget on the page count, not on an exact multiple of 40. <code>0</code> = no page limit. Note StockX reports a constant <code>total: 1000</code> for every query regardless of the real catalogue size, so paging stops when a page returns nothing new rather than at a reported total.

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

Route requests through a proxy (Apify Proxy by default).

## Actor input object example

```json
{
  "mode": "search",
  "q": "Jordan 1 Retro High",
  "productIds": [],
  "maxSalesPerProduct": 100,
  "country": "US",
  "currency": "USD",
  "includeDetails": false,
  "maxItems": 100,
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "q": "Jordan 1 Retro High",
    "productIds": [],
    "country": "US",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rl1987/stockx-api-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 = {
    "q": "Jordan 1 Retro High",
    "productIds": [],
    "country": "US",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rl1987/stockx-api-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "q": "Jordan 1 Retro High",
  "productIds": [],
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rl1987/stockx-api-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rl1987/stockx-api-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/v29w9UXaIBfki3ZSb/builds/rnVBdTc6V4YlpJWhC/openapi.json