# StockX Scraper - Ask, Bid, Last Sale by Size (`abotapi/stockx-market-data-scraper`) Actor

Scrape StockX market data by keyword, category or URL. Every row carries lowest ask, highest bid, last sale, bid ask spread, ask counts, 72 hour and 90 day sales volume, 12 month average price, volatility and premium over retail. Pick a size and every row becomes that size's own order book.

- **URL**: https://apify.com/abotapi/stockx-market-data-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce
- **Security:** Limited permissions
- **Stats:** 10 total users, 4 monthly users, 98.4% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 market records

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: Live Ask, Bid and Last Sale by Size

StockX Scraper turns StockX into a market data feed for sneakers, streetwear, apparel and collectibles. Search by keyword, browse a category, or paste StockX links, and get back the numbers a reseller actually trades on: lowest ask, highest bid, last sale, the bid/ask spread, ask depth by shipping speed, 72 hour, 90 day and 12 month sales volume, price volatility and the premium over retail. Pick a size and every row becomes that size's own order book, which is the grain a trade actually gets priced against. Export the dataset to JSON, CSV or Excel, or read it straight through the API.

### Why This Scraper?

- **Two ways to start.** Search by keyword or paste StockX product, search, category or brand links; most filters apply to both, except a pasted product URL, which always returns that one product in full. Most filters narrow the site's own pages read; four (minimum last sale, minimum recent sales, live-ask-only, live-bid-only) are checked after a page is read instead.
- **The live market is on every row, no surcharge.** Lowest ask, highest bid, last sale, the bid/ask spread, ask depth by shipping speed and 72 hour, 90 day and 12 month sales volume come back whether or not full product details are switched on.
- **Size level order books.** Set a size scale and a size and every row becomes that one size's own market. Turn on full product details instead and each row carries the whole size table, every size with its own order book and its own sale history.
- **Filter honesty.** StockX echoes back the filter set it actually resolved on every result page. The run reports that echo and warns when a filter you asked for was not applied, so a page that quietly widened never reads as a narrower result than it is.
- **Multi market pricing.** Seven StockX country markets, each with its own live order book and its own currency, not a currency conversion of one market.
- **Built for monitoring.** Incremental mode tracks a saved search over time and returns only new and updated records by default; reappeared and expired ones need Emit expired too. Resume continues one interrupted run without paying twice for what it already collected.
- **A run that could read nothing fails instead of returning empty.** "Nothing matched this search" and "the connection could not be read" are tracked separately, so a fully blocked run never comes back looking like an honestly empty one; a run that read at least something still succeeds even if part of it was refused.

### Use Cases

- **Resale trading and arbitrage:** compare lowest ask, highest bid and spread across sizes to find where a flip is actually worth doing.
- **Pricing and inventory tools:** feed live ask, bid and last sale data into your own storefront or pricing engine.
- **Market research:** build historical sales volume, volatility and price premium datasets across sneakers, apparel or collectibles.
- **Drop and price monitoring:** track a search or category on a schedule and get only new items and items whose price or sales statistics changed, not a full re-download.
- **Demand modeling and data science:** use per size sale history and 72 hour, 90 day and 12 month volume to model demand and seasonality.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `rowType` | `"variant"` (also `"product"` for a whole-product row) |
| `recordId` | `"a1b2c3d4-2222-4a2b-9c3d-000000000002"` |
| `productId` / `variantId` | `"a1b2c3d4-1111-4a2b-9c3d-000000000001"` / `"a1b2c3d4-2222-4a2b-9c3d-000000000002"` |
| `title` | `"Northaven Trailcore 02 Storm Grey Ember"` |
| `brand` / `model` | `"Northaven"` / `"Northaven Trailcore 02"` |
| `url` | `"https://stockx.com/northaven-trailcore-02-storm-grey-ember"` |
| `size` / `sizeType` | `"9"` / `"us m"` |
| `requestedSize` | `"US M 9"` |
| `sizeConversions` | `[{ "size": "US M 9", "type": "us m" }, { "size": "UK 8", "type": "uk" }]` |
| `lowestAsk` | `210` |
| `highestBid` | `178` |
| `lastSale` | `205` |
| `bidAskSpread` | `32` |
| `standardAskCount` / `standardLowestAsk` | `54` / `210` |
| `expressNextDayAskCount` / `expressNextDayLowestAsk` | `9` / `228` |
| `salesLast72Hours` | `21` |
| `salesLast90Days` / `averagePriceLast90Days` | `640` / `198` |
| `salesLast12Months` / `averagePriceLast12Months` | `2100` / `205` |
| `priceVolatility` | `0.087` |
| `pricePremium` | `0.45` |
| `market` / `currency` | `"US"` / `"USD"` |
| `releaseDate` | `"2022-11-05"` |
| `gender` / `productCategory` | `"men"` / `"sneakers"` |
| `imageUrl` | `"https://images.stockx.com/images/Northaven-Trailcore-02-Storm-Grey-Ember-Product.jpg"` |
| `scrapedAt` | `"2026-09-20T09:15:00Z"` |

With **Fetch full product details** on, each row also carries `lastSaleDate`, `annualRangeHigh`, `annualRangeLow` (the 12 month trade range, quoted in the row's own `currency`), `premiumOverRetail` and `premiumOverRetailPct` (last sale against the original retail price; the retail price is a US dollar figure, so these two are filled only on rows whose `currency` is USD and are null on every other market), `lastSaleChange` and `lastSaleChangePercent` (the last sale against the sale before it), `salesPrevious72Hours` (completed sales in the 72 hours before the latest 72 hours), `annualHighPrice` and `annualLowPrice` (highest and lowest completed sale of the last 12 months, in the row's currency), `styleId`, `colorway`, `retailPrice`, `restockDate`, `sizeConversionTypes`, `images`, `tags`, `traits`, `detailDescription`, and the full `availableSizes` table: every size the product offers, each with its own `lowestAsk`, `highestBid`, `lastSale`, `bidAskSpread`, `askCount` and sales volume. `breadcrumbs` and `productLine` are only added when a product's own page had to be read directly rather than through the main listing path; per-size `saleHistory` and the `saleHistoryPoints` count are only added by that same main path, so no single row carries both sets together. In incremental mode, records also carry `changeType` (`NEW`, `UPDATED`, `UNCHANGED` by default; `REAPPEARED`/`EXPIRED` only with Emit expired too), `changedFields`, `firstSeenAt` and `lastSeenAt`.

### How to Use

1. Pick a **mode**: `search` (by keyword), `url` (paste StockX links) or `salesHistory` (every completed sale of the products you list).
2. Add filters to narrow the scope: category, brand, gender, colour, price range, availability, or set a size scale and a size to get one row per size instead of one row per product.
3. Turn on **Fetch full product details** if you want the style code, colourway, retail price and the whole size table (adds a per record surcharge); it is pre-checked in the Console form, uncheck it for a fast, cheaper market crawl.
4. Set **Max items** to control run size and cost, then click **Start**. Download the dataset as JSON, CSV or Excel, or read it through the API.

**The order book for one size, across a search:**

```json
{
  "mode": "search",
  "searchTerms": ["trail runner"],
  "sizeScale": "mens",
  "size": "10",
  "orderBy": "most-active",
  "maxItems": 100
}
```

**Everything trading right now, under retail:**

```json
{
  "mode": "search",
  "category": "sneakers",
  "belowRetailOnly": true,
  "minSalesLast72Hours": 5,
  "orderBy": "most-active",
  "maxItems": 200
}
```

**Paste links (search, brand and product):**

```json
{
  "mode": "url",
  "urls": [
    "https://stockx.com/search?s=trail+runner",
    "https://stockx.com/northaven",
    "https://stockx.com/northaven-trailcore-02-storm-grey-ember"
  ],
  "fetchDetails": true,
  "maxItems": 50
}
```

**Daily monitoring of one search:**

```json
{
  "mode": "search",
  "searchTerms": ["retro basketball high"],
  "incrementalMode": true,
  "stateKey": "retro-basketball-watch",
  "maxItems": 0
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/stockx-market-data-scraper").call(
    run_input={"mode": "search", "searchTerms": ["trail runner"], "maxItems": 50})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["title"], row["lowestAsk"], row["highestBid"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/stockx-market-data-scraper').call({
  mode: 'search', searchTerms: ['trail runner'], maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Honesty about scope and filters

StockX returns at most 1000 results for any one search or category. When a scope hits that ceiling the run says so explicitly and suggests narrowing it with the brand, model, size, colour, price or availability filters; a truncated scope is never reported as a complete one. Sponsored placements on result pages are dropped before they reach the dataset, so they are never counted or billed as a row.

#### Resume and recurring updates

These are two different tools. **Resume** (`resumeFromRunId`) continues one specific interrupted run: paste its run or dataset id, and this run walks the same scope from its start page again, skipping every record id the earlier run already returned, so nothing already collected is re-emitted or re-billed. Because it re-walks every page rather than jumping to where the earlier run stopped, it also picks up any item that has shifted into an earlier page since that run, at the cost of reading (but not paying for) pages already read once; those re-read pages still count against Max pages, so set it generously on a resumed run.

**Incremental mode** (`incrementalMode`) is for running the same search again and again on a schedule. Each record is classified `NEW`, `UPDATED` (with `changedFields`), or `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on) by default. A price move on ask, bid or last sale always counts as `UPDATED`, since on a resale marketplace a moving price is the signal, not noise; so does a change in the sales-volume or average-price statistics; an ask simply re-listed at the same amount does not. Always left out of the comparison (but still returned), at any depth including `availableSizes` and `saleHistory`: `scrapedAt`, `detailCarriedForward`, `lowestAskUpdatedAt`, `highestBidUpdatedAt`, `annualRangeHigh`, `annualRangeLow`, `lastSaleDate`, `premiumOverRetail`, `premiumOverRetailPct`, `orderType`, `lastSaleChange`, `lastSaleChangePercent`, `salesPrevious72Hours`, `annualHighPrice`, `annualLowPrice` (the last eleven were added after earlier baselines existed, so they never flag a record as `UPDATED`), and the resize / cache-bust query string of image URLs. On a market other than the US the per-size prices in `availableSizes` are now quoted in the row's own currency (they were US dollars before); to keep that from flagging every tracked record as `UPDATED`, the first run after the upgrade compares such an older saved record without its `availableSizes` block and saves the new one, after which the per-size prices are compared again (a record whose product page was refused on that first run keeps its older saved per-size prices out of the row and is handled the same way on the next run). `ignoreFieldsForChanges` adds your own field names (matched at any depth); changing that list never causes a one-time wave of `UPDATED` rows, because the saved baseline is compared using the same list. `REAPPEARED` and `EXPIRED` additionally need `emitExpired` on: `EXPIRED` is only produced by a run with `emitExpired` on that scanned the tracked scope all the way to its natural end, with no cap, no Resume, no refusal and no page limit in the way, and `REAPPEARED` only for a record a previous such run marked `EXPIRED`. A partial run still saves what it saw (so `NEW`/`UPDATED` records and `lastSeenAt` are kept), it just never marks unseen records `EXPIRED`. `stateKey` names or deliberately shares one monitoring campaign; leave it empty and the actor derives one from the search terms, URLs and filters, so two different searches never share a baseline. Resume and incremental mode are not combined on the same state: turning on incremental mode against a state key that already has saved history while also setting Resume stops the run before anything is collected or charged, rather than risk double billing.

#### Sales history mode

Set `mode` to `salesHistory` and list products under `productIds` (product ids, product page links or slugs). Each completed sale is one row with `rowType` `sale`, `productName`, `size`, `variantId`, `amount`, `currency`, `soldAt` and `orderType`, newest first. `maxSalesPerProduct` caps the rows per product (default 100, maximum 5000; sales are drawn across all sizes), `salesSince` (YYYY-MM-DD) drops older sales and `currency` picks the currency of `amount`. `maxItems` still caps the whole run. A sale row is an ordinary result: it is billed as one result and there is no extra fee. If StockX refuses some sales pages, the run never reads that as an empty history: a warning names the product and how many sizes were skipped, the final status message says the result is incomplete, and the run ends as failed when nothing could be read. A run summary (products requested, resolved and failed, sizes refused, rows saved, whether `maxItems` cut the run short) is saved under the `OUTPUT` key of the run's key-value store. Incremental mode and Resume do not apply to this mode. Ordering also accepts `recent_bids`, `recent_asks`, `deadstock_sold` and `price_premium`; category accepts `streetwear` and `watches`; gender accepts `infant`, `toddler`, `preschool` and `child`.

### Send results into your apps (MCP connectors)

Optionally pipe results into Notion, Linear, Airtable or Apify via MCP connectors, in the **Export to your apps (MCP connectors, optional)** section of the input. Each connector receives a condensed summary per record; the complete record always stays in the dataset, so nothing is lost if you leave this off.

- `mcpConnectors`: the MCP connectors to export this run's records into (Notion, Linear, Airtable, Apify). Leave it empty and nothing is exported.
- `notionParentPageUrl`: Notion connector only, the page under which one child page per record is created. Required when `mcpConnectors` includes Notion, ignored otherwise.
- `maxNotifyListings`: how many records are exported to each connector in one run. This caps the export only, it never changes what the dataset returns.

Export runs after the dataset is complete and is best effort: if a connector is unreachable the run still succeeds with a warning, and your records are still in the dataset.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` runs StockX keyword searches; `url` walks the StockX links you paste; `salesHistory` returns one row per completed sale. |
| `productIds` | array | (none) | salesHistory mode only: product ids, product links or slugs. |
| `maxSalesPerProduct` | integer | `100` | salesHistory mode only: sales per product, 1 to 5000. |
| `salesSince` | string | (none) | salesHistory mode only: only sales on or after this date (YYYY-MM-DD). |
| `currency` | string | `USD` | salesHistory mode only: currency of the sale amounts. |
| `searchTerms` | array | `["air jordan 1"]` | Search mode only: one or more keywords, each walked independently. |
| `urls` | array | one example per link shape (keyword search, paginated search, sorted search, category, category with filter and page, brand, product page) | URL mode only: StockX product, search, category or brand links. If you switch to URL mode and leave this field untouched, the run scrapes one example of each shape; clear it and paste your own links to scrape only those. |
| `category` | string | (any) | Restrict to a StockX category, top level or sneaker sub category. Applies in both modes. |
| `brands` | array | (none) | One or more brand slugs, combined with OR. Applies in both modes. |
| `models` | array | (none) | One or more StockX model slugs, combined with OR. Applies in both modes. |
| `productLines` | array | (none) | One or more product line slugs; StockX rebuilds this list per scope, so it is free text. |
| `gender` | string | (any) | Men, women, kids or unisex. Applies in both modes. |
| `color` | string | (any) | One of the 10 colours StockX indexes. Applies in both modes. |
| `activity` | string | (any) | Running, basketball, skateboarding, soccer, hiking, golf or football. |
| `shoeHeight` | string | (any) | Low, mid or high cut. Applies in both modes. |
| `market` | string | `US` | Which StockX country market and currency to price against; the market follows the connection's exit country. |
| `sizeScale` | string | (off) | Turns on per size rows when set together with Size: men's, women's or kids. Setting a size with no category picked automatically selects the sneakers category. |
| `size` | string | (none) | The size to price, in the scale above. Ignored unless Size scale is set. |
| `minPriceUsd` | integer | (none) | Only items whose lowest ask is at least this many US dollars. |
| `maxPriceUsd` | integer | (none) | Only items whose lowest ask is at most this many US dollars. |
| `availableNow` | boolean | `false` | Only items with a live ask right now. |
| `xpressShipOnly` | boolean | `false` | Only items available with expedited, pre verified shipping. |
| `belowRetailOnly` | boolean | `false` | Only items whose lowest ask is below original retail price. |
| `minLastSaleUsd` | integer | (none) | Drop rows whose most recent sale was below this; applied to the rows this run reads, since StockX has no server side filter for it. |
| `minSalesLast72Hours` | integer | (none) | Drop rows with fewer than this many sales in the last 72 hours; applied to the rows this run reads. |
| `hasLiveAskOnly` | boolean | `false` | Drop rows with no live ask; applied to the rows this run reads. |
| `hasLiveBidOnly` | boolean | `false` | Drop rows with no live bid; applied to the rows this run reads. |
| `orderBy` | string | `featured` | Asks StockX to order the whole catalogue, so it decides which items you get first. |
| `sortResultsBy` | string | `site_order` | Rearranges the rows this run collected, after they are read; does not change which items you get. |
| `fetchDetails` | boolean | `false` (form prefill is checked) | Fetch each item's product page for the style code, colourway, retail price, dates and the complete size table. Charged once per record that is returned with its details, as the rows are saved; the market fields above are on every row either way. |
| `maxItems` | integer | `20` | Stop after collecting this many records, split evenly across all search terms or URLs and not rebalanced if one source runs dry early. `0` means the hard maximum of 100000 records, which is also the highest value accepted. |
| `maxPages` | integer | `0` | Optional safety bound on result pages walked per search term or URL. `0` means no page limit. |
| `resumeFromRunId` | string | (none) | Continue one interrupted run without returning or billing what it already collected. |
| `incrementalMode` | boolean | `false` | Return only new and changed records on recurring runs of the same search. |
| `stateKey` | string | (none) | Name a monitoring campaign, or deliberately share one across differently configured runs. |
| `emitUnchanged` | boolean | `false` | Also return, and bill, rows that did not change. |
| `emitExpired` | boolean | `false` | Incremental mode only. Also detect and return (and bill) rows that disappeared, but only once a run with this on has completed a scan of the tracked scope end to end. |
| `ignoreFieldsForChanges` | array | `[]` | Incremental mode only. Field names (any depth) to leave out when deciding whether a record changed; they stay in the row and out of `changedFields`. |
| `mcpConnectors` | array | (none) | Optional: send a summary of each record to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | (none) | Notion connector only: page under which record pages are created. |
| `maxNotifyListings` | integer | `50` | Cap on items exported to each connector per run. |
| `proxy` | object | Apify Proxy | Connection settings. Leave the default (residential); datacenter connections are refused by StockX. |

#### Link shapes in URL mode

| Link you paste | Example | What you get |
| --- | --- | --- |
| Keyword search | `https://stockx.com/search?s=jordan+1` | The search results; `page` and `sort` in the link are honoured. |
| Category | `https://stockx.com/category/sneakers` | The category listing, with filters such as `brand` and `page` from the link. |
| Brand | `https://stockx.com/brands/nike` | The brand listing. |
| Product | `https://stockx.com/nike-dunk-low-retro-white-black-2021` | That one product in full. |

When you leave the links field untouched in URL mode, one example of each listing shape above is scraped. Clear it to scrape only your own links.

#### Output views

The dataset has four views: **Overview** (one row per product or size), **Per size market** (ask, bid and last sale by size), **Sales history** (one row per completed sale in `salesHistory` mode) and **Changes** (rows with `changeType` and `changedFields` in incremental mode).

#### Billing

You are billed per result row saved to the dataset: one row is one product, or one size when a size scale is set, or one completed sale in `salesHistory` mode. With **Fetch full product details** on, each row that is saved with its details also bills the product details event, once per row, as the rows are saved; a row saved without details does not bill it. Unchanged rows in incremental mode, sponsored placements and failed fetches are not billed. The actor start is billed once per run. See the **Pricing** tab for the current rates; Max items caps the run.

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "rowType": "variant",
  "recordId": "a1b2c3d4-2222-4a2b-9c3d-000000000002",
  "productId": "a1b2c3d4-1111-4a2b-9c3d-000000000001",
  "variantId": "a1b2c3d4-2222-4a2b-9c3d-000000000002",
  "title": "Northaven Trailcore 02 Storm Grey Ember",
  "brand": "Northaven",
  "model": "Northaven Trailcore 02",
  "urlKey": "northaven-trailcore-02-storm-grey-ember",
  "url": "https://stockx.com/northaven-trailcore-02-storm-grey-ember",
  "size": "9",
  "sizeType": "us m",
  "requestedSize": "US M 9",
  "sizeConversions": [
    { "size": "US M 9", "type": "us m" },
    { "size": "UK 8", "type": "uk" },
    { "size": "EU 42.5", "type": "eu" },
    { "size": "CM 27", "type": "cm" },
    { "size": "US W 10.5", "type": "us w" }
  ],
  "lowestAsk": 210,
  "lowestAskUpdatedAt": "2026-09-14T03:20:00Z",
  "highestBid": 178,
  "highestBidUpdatedAt": "2026-09-12T18:05:00Z",
  "lastSale": 205,
  "bidAskSpread": 32,
  "standardAskCount": 54,
  "standardLowestAsk": 210,
  "expressNextDayAskCount": 9,
  "expressNextDayLowestAsk": 228,
  "salesLast72Hours": 21,
  "salesLast90Days": 640,
  "averagePriceLast90Days": 198,
  "salesLast12Months": 2100,
  "averagePriceLast12Months": 205,
  "priceVolatility": 0.087,
  "pricePremium": 0.45,
  "currency": "USD",
  "market": "US",
  "releaseDate": "2022-11-05",
  "gender": "men",
  "productCategory": "sneakers",
  "imageUrl": "https://images.stockx.com/images/Northaven-Trailcore-02-Storm-Grey-Ember-Product.jpg",
  "scrapedAt": "2026-09-20T09:15:00Z"
}
```

### Plan Requirement

StockX blocks datacenter connections: in testing, every datacenter request was refused. The actor therefore needs residential access, which the default Apify Proxy setting requests. A paid Apify plan is required for it. Even on residential exits StockX refuses a share of requests, so the run rotates exits and retries, and moves to a backup connection when the default one is unavailable.

Messages you may see:

- On a free plan the run logs: "The selected connection is unavailable to this run. Apify free plans do not include residential proxies. Continuing on a backup connection; some pages may still be unavailable." When a backup connection serves a page it logs "Served over the backup connection (the default connection was unavailable)."
- If no page can be read, the run fails with one of: "The proxy connection was refused for this account, so no page could be read. Your Apify plan does not include proxy access; a paid plan is required", "No results: residential proxies are unavailable on this run (Apify free plans do not include them), and the backup connection could not load the requested StockX pages", or "Could not load any results page (the requests failed), so nothing was collected. This is a connection problem, not an empty search. Please try again later." In `salesHistory` mode, when the connection itself worked but StockX refused every product or sales request, the run fails with "No sales could be read: StockX refused the product or sales requests. This is a connection problem, not an empty history. Please try again later." When none of the given products could be found (a malformed id, URL or slug, or a product StockX does not have) and nothing was refused, the run fails instead with "None of the given products could be found on StockX: check the product ids, URLs or slugs." The OUTPUT summary splits the two causes as `productsNotFound` and `productsRefused`.
- If you supply your own proxy URLs, use residential ones; datacenter addresses are refused.

### FAQ

#### How much does it cost?

You pay per market record returned (one row, or one size when a size scale is set), plus full product details only when that toggle is switched on. The **Pricing** tab shows the current rates. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape StockX?

This actor collects only publicly available market data. You are responsible for how you use it: follow StockX's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Ask and bid prices are generally facts, but product photography and descriptions may be subject to third-party rights.

#### Can I get only new listings or price moves on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only new and updated records by default (plus reappeared ones once you also turn on **Emit expired**), and unchanged ones are not billed unless you ask for them.

#### Why did my run return fewer rows than I expected?

StockX returns at most 1000 results for any one search or category; a broad scope is truncated there rather than read in full, and the run tells you so. Narrow it with the category, brand, size, colour, price or availability filters, or raise Max items and Max pages. With multiple search terms or URLs, Max items is also split evenly across them and not rebalanced if one comes up short, so a search term with few results doesn't hand its unused budget to the others; the four client-side filters (minimum last sale, minimum recent sales, live-ask-only, live-bid-only) and cross-source deduplication can also leave a run with fewer rows than Max items alone would suggest.

#### Why did my run fail instead of returning an empty dataset?

If the connection is refused on every request, the run stops with a clear message so "nothing matched" is never confused with "nothing could be read." Run it again in a few minutes, or change the Connection setting. A search that genuinely matches nothing still succeeds, with an explanation instead of rows.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 Want more fashion data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>👗 <a href="https://apify.com/abotapi/kream-scraper"><b>KREAM Scraper</b></a><br>Scrape KREAM (kream.co.kr) sneaker and fashion resale data by keyword search, filters...</td><td>👗 <a href="https://apify.com/abotapi/goat-sneaker-scraper"><b>GOAT Scraper</b></a><br>Scrape GOAT (goat.com), the sneaker and streetwear resale marketplace. Search or paste...</td></tr>
<tr><td>👗 <a href="https://apify.com/abotapi/klekt-com-scraper"><b>KLEKT Sneaker &amp; Apparel Resale Scraper</b></a><br>Scrape sneaker and streetwear listings from KLEKT (klekt.com). Browse the catalog with...</td><td>👗 <a href="https://apify.com/abotapi/snkrdunk-com-scraper"><b>SNKRDUNK Scraper</b></a><br>Scrape SNKRDUNK (snkrdunk.com), Japan's sneaker and streetwear resale marketplace: JP and...</td></tr>
<tr><td>⚽ <a href="https://apify.com/abotapi/whatnot-scraper"><b>Whatnot Scraper</b></a><br>Scrape Whatnot live and upcoming shows, queued items and lots, and seller profiles...</td><td>👗 <a href="https://apify.com/abotapi/fashionnova-com-scraper"><b>Fashion Nova Scraper</b></a><br>Scrape Fashion Nova products by keyword, collection or URL. Extract product names...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/stockx-market-data-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

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

How to start the scrape. 'search' runs StockX keyword searches. 'url' processes the StockX URLs you paste: a product URL is fetched as a single product, and a search, category or brand URL is paged like a search. Only where the scope comes from differs: the filters below apply in BOTH modes. 'salesHistory' returns one row per completed sale (price, time, size, order type) for the products you list under Product ids.

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

One or more things to search StockX for, for example 'air jordan 1', 'nike dunk low', 'yeezy 350'. Each term is scraped independently. Search mode only: in URL mode the scope is read out of each pasted StockX URL instead. Leave this empty and the run browses the category you picked below (sneakers when you pick none), narrowed by the filters.

## `urls` (type: `array`):

Paste StockX product URLs (https://stockx.com/nike-dunk-low-retro-white-black-2021), search URLs (https://stockx.com/search?s=jordan+1), category URLs (https://stockx.com/category/sneakers) or brand pages (https://stockx.com/brands/nike). Add ?page=3 to any browse URL to start walking from that page instead of the first. The filters below are NOT ignored here: every pasted search, category or brand URL is re-run with them applied, and anything already in the URL wins for that URL. A pasted product URL is the one exception, since it returns that single product in full.

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

StockX product ids (UUIDs), product page URLs or product slugs such as air-jordan-1-retro-high-og-chicago-2015. Used by salesHistory mode only.

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

The most sale rows returned for each product, drawn across all of its sizes. Between 1 and 5000; 0 or empty uses the default of 100. salesHistory mode only.

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

Only return sales on or after this date, written YYYY-MM-DD (for example 2026-01-01). Leave empty for no date limit. salesHistory mode only.

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

Currency the sale amounts are quoted in. Applies to salesHistory mode; search and URL modes quote in the currency of the selected Market.

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

Only return items in this StockX category. Both top level categories (sneakers, apparel, collectibles) and sneaker sub categories (lifestyle, performance, luxury) are accepted. Applies in BOTH search mode and URL mode.

## `brands` (type: `array`):

Only return items from these brands, for example 'nike', 'adidas', 'jordan', 'new-balance'. Several brands are combined with OR. Leave empty for every brand. Applies in BOTH search mode and URL mode. A pasted brand page URL overrides this filter for that URL only.

## `models` (type: `array`):

Only return items in these StockX models, for example 'dunk', 'air-force-1', 'air-max-90', 'campus-00s'. Use the slug StockX itself uses in its filter panel; spaces are converted for you. Several models are combined with OR. Applies in BOTH search mode and URL mode.

## `productLines` (type: `array`):

Only return items in these StockX product lines, for example 'blazer', 'cortez', '860v2'. StockX rebuilds this list per category and brand, so it is free text rather than a fixed list. Several product lines are combined with OR. Applies in BOTH search mode and URL mode.

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

Only return items cut for this audience. Applies in BOTH search mode and URL mode.

## `color` (type: `string`):

Only return items StockX files under this colour. Applies in BOTH search mode and URL mode.

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

Only return items StockX files under this activity. Applies in BOTH search mode and URL mode.

## `shoeHeight` (type: `string`):

Only return low, mid or high cut shoes. Applies in BOTH search mode and URL mode.

## `market` (type: `string`):

Which StockX market to price against. StockX runs a separate order book per country, each in its own currency, and the prices genuinely differ (Germany and France both bill in euro and still quote different asks), so this is a real narrowing rather than a currency conversion. The market follows the connection's exit country, so picking one here pins the exit; if you pinned a country on the Proxy configuration yourself, yours wins. Every row states the market and currency it was actually quoted in. Applies in BOTH search mode and URL mode.

## `sizeScale` (type: `string`):

Which size scale the Size below is written in. Setting a scale AND a size changes what one row means: instead of one row per product with the cheapest ask across all sizes, you get one row per SIZE, carrying that size's own lowest ask, highest bid, last sale, spread, ask counts and sales volume. Leave on 'Off' for one row per product. Applies in BOTH search mode and URL mode.

## `size` (type: `string`):

The size to price, in the scale picked above, for example '10' or '9.5' for men's, '8' for women's, '4' for kids. Ignored unless Size scale is set. When both are set, every row is that size and every price on the row is that size's own price. Applies in BOTH search mode and URL mode.

## `minPriceUsd` (type: `integer`):

Only return items whose lowest ask is at least this many US dollars. Sent to StockX as a price range together with the maximum. Applies in BOTH search mode and URL mode.

## `maxPriceUsd` (type: `integer`):

Only return items whose lowest ask is at most this many US dollars. Sent to StockX as a price range together with the minimum. Applies in BOTH search mode and URL mode.

## `availableNow` (type: `boolean`):

Only return items that have at least one live ask right now, so they can be bought immediately. Applies in BOTH search mode and URL mode.

## `xpressShipOnly` (type: `boolean`):

Only return items available with Xpress Ship, meaning stock already verified and held, which ships in a few days instead of a couple of weeks. Applies in BOTH search mode and URL mode.

## `belowRetailOnly` (type: `boolean`):

Only return items whose lowest ask is below the original retail price. Applies in BOTH search mode and URL mode.

## `minLastSaleUsd` (type: `integer`):

Only keep rows whose most recent sale was at least this many US dollars. StockX has no server side filter for this, so it is applied to the rows this run reads. Applies in BOTH search mode and URL mode.

## `minSalesLast72Hours` (type: `integer`):

Only keep rows that sold at least this many times in the last 72 hours, which is the quickest way to separate liquid items from dead stock. StockX has no server side filter for this, so it is applied to the rows this run reads. Applies in BOTH search mode and URL mode.

## `hasLiveAskOnly` (type: `boolean`):

Only keep rows that currently have a lowest ask. Applied to the rows this run reads. Applies in BOTH search mode and URL mode.

## `hasLiveBidOnly` (type: `boolean`):

Only keep rows that currently have a highest bid. Applied to the rows this run reads. Applies in BOTH search mode and URL mode.

## `orderBy` (type: `string`):

Ordering sent to StockX itself, so it decides WHICH items you get first across the whole catalogue, not just how this run's rows are arranged. Each value here was checked against StockX and genuinely reorders results. Applies in BOTH search mode and URL mode, and a sort already present in a pasted URL wins for that URL.

## `sortResultsBy` (type: `string`):

Arranges the rows this run collected, after they are read. This is a local tidy up of one run's output, not a catalogue wide ordering: to change WHICH items you get, use 'Ask StockX to order results by' above. Applies in BOTH search mode and URL mode.

## `fetchDetails` (type: `boolean`):

Fetch each item's product page for the style code (SKU), colourway, original retail price, release and restock dates, the complete size run in six size systems (US M, US W, UK, EU, CM, KR), the product line breadcrumb, the available conditions, tags and the full image set. Slower, and charged once per record. Leave off for a fast market crawl: identity, images, release date and the whole market block are included either way.

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

The single cap on this run: stop after collecting this many records across all search terms and URLs. With a size scale set, one record is one size. Set 0 for the hard maximum of 100000 records.

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

Safety bound on how many result pages to walk per search term or URL. Leave empty (0) for no page limit: the run then stops at Max items, not here. Does not impose a separate cap below Max items. StockX itself returns at most 1000 results per search or category, so a very broad scope needs the filters above rather than more pages.

## `proxy` (type: `object`):

Leave the default for the cheapest run. Change it only if a run reports that it could not read any results.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large crawl without returning or charging for records already collected there. Use this after an interrupted or capped run. For recurring monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or weekly recurring monitoring of the same search. The first run returns everything matching as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED records. Compared: the market and catalogue fields (asks, bids, last sale, sales counts and averages, sizes and their per-size prices, title, images, tags), except the fields listed next. Ask, bid and last sale moves ARE reported as UPDATED: on a resale marketplace they are the signal, not noise. Excluded from the comparison (still returned in each row), at any depth including availableSizes and saleHistory: scrapedAt, detailCarriedForward, lowestAskUpdatedAt and highestBidUpdatedAt (restamped when an ask is re-listed at the same amount), annualRangeHigh, annualRangeLow, lastSaleDate, premiumOverRetail, premiumOverRetailPct, orderType, lastSaleChange, lastSaleChangePercent, salesPrevious72Hours, annualHighPrice and annualLowPrice (added after earlier baselines existed, so they never flag a record as UPDATED), and the query string of image URLs (resize and cache-bust parameters). On markets other than the US the per-size prices are now quoted in the row's own currency; the first run after the upgrade compares older saved records without availableSizes so this never flags them as UPDATED. Add more with Ignore fields below. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed). State is kept separately per search, URL, filter and size setup; use State key to name or deliberately share a monitoring campaign. To continue one specific interrupted run instead, use Resume from a previous run above.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the search terms, URLs, filters and size setup, so two different searches never mix state.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return records that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have, so leave it off unless you specifically want a full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return records that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search: not when Max items capped it, not when Resume was used, not when the run was refused, and not when StockX's 1000 result limit truncated the scope. This returns, and bills, extra synthetic rows, so leave it off unless you need expiry tracking.

## `ignoreFieldsForChanges` (type: `array`):

Optional. Field names to leave out when deciding whether a record changed, at any depth (for example salesLast72Hours, or saleHistory). They are still returned in every row and never show up in changedFields. Changing this list does not cause a one-time wave of UPDATED rows: the saved baseline is compared with the same list. Only used when Incremental changes is on.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a page per record; other connectors get a best-effort write or digest. Each connector receives a condensed summary per record, not the full record; the complete record always stays in the dataset. Leave empty to skip; this never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which record pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on records written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "air jordan 1"
  ],
  "urls": [
    "https://stockx.com/search?s=jordan+1",
    "https://stockx.com/search?s=jordan+1&page=2",
    "https://stockx.com/search?s=jordan+1&sort=most-active",
    "https://stockx.com/category/sneakers",
    "https://stockx.com/category/sneakers?brand=nike&page=2",
    "https://stockx.com/brands/nike",
    "https://stockx.com/nike-dunk-low-retro-white-black-2021"
  ],
  "maxSalesPerProduct": 100,
  "currency": "USD",
  "category": "",
  "gender": "",
  "color": "",
  "activity": "",
  "shoeHeight": "",
  "market": "US",
  "sizeScale": "",
  "availableNow": false,
  "xpressShipOnly": false,
  "belowRetailOnly": false,
  "hasLiveAskOnly": false,
  "hasLiveBidOnly": false,
  "orderBy": "featured",
  "sortResultsBy": "site_order",
  "fetchDetails": true,
  "maxItems": 20,
  "maxPages": 0,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 50
}
```

# Actor output Schema

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

No description

## `sizes` (type: `string`):

No description

## `sales` (type: `string`):

No description

## `changes` (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 = {
    "mode": "search",
    "searchTerms": [
        "air jordan 1"
    ],
    "urls": [
        "https://stockx.com/search?s=jordan+1",
        "https://stockx.com/search?s=jordan+1&page=2",
        "https://stockx.com/search?s=jordan+1&sort=most-active",
        "https://stockx.com/category/sneakers",
        "https://stockx.com/category/sneakers?brand=nike&page=2",
        "https://stockx.com/brands/nike",
        "https://stockx.com/nike-dunk-low-retro-white-black-2021"
    ],
    "market": "US",
    "fetchDetails": true,
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": true
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "ignoreFieldsForChanges": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/stockx-market-data-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",
    "searchTerms": ["air jordan 1"],
    "urls": [
        "https://stockx.com/search?s=jordan+1",
        "https://stockx.com/search?s=jordan+1&page=2",
        "https://stockx.com/search?s=jordan+1&sort=most-active",
        "https://stockx.com/category/sneakers",
        "https://stockx.com/category/sneakers?brand=nike&page=2",
        "https://stockx.com/brands/nike",
        "https://stockx.com/nike-dunk-low-retro-white-black-2021",
    ],
    "market": "US",
    "fetchDetails": True,
    "maxItems": 20,
    "proxy": { "useApifyProxy": True },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "ignoreFieldsForChanges": [],
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/stockx-market-data-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 '{
  "mode": "search",
  "searchTerms": [
    "air jordan 1"
  ],
  "urls": [
    "https://stockx.com/search?s=jordan+1",
    "https://stockx.com/search?s=jordan+1&page=2",
    "https://stockx.com/search?s=jordan+1&sort=most-active",
    "https://stockx.com/category/sneakers",
    "https://stockx.com/category/sneakers?brand=nike&page=2",
    "https://stockx.com/brands/nike",
    "https://stockx.com/nike-dunk-low-retro-white-black-2021"
  ],
  "market": "US",
  "fetchDetails": true,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": []
}' |
apify call abotapi/stockx-market-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/stockx-market-data-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/a4NWpnzqCFh954HCI/builds/TcMakDO15xziPiFGS/openapi.json
