# 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
- **Stats:** 1 total users, 1 monthly users, 92.1% runs succeeded, 0 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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: Ask, Bid, Last Sale by Size

Pull live market data from **StockX**, the largest authenticated sneaker and streetwear
resale marketplace. Search by keyword, browse a category, or paste StockX URLs, and get back
the numbers a reseller actually prices against: **lowest ask, highest bid, last sale, the
bid/ask spread, how many asks are listed at each shipping speed, 72 hour and 90 day sales
volume, 12 month average price, price volatility and the premium over retail.**

Pick a size and every row becomes **that size's own order book**, which is the grain that
decides whether a trade is worth doing.

***

### Why this one

| | This actor | Typical StockX actor |
|---|---|---|
| Ask, bid and last sale | on **every** row, no surcharge | often behind a paid detail fetch |
| Per size ask, bid and last sale | **first class row grain**, and the full size table on every detailed row | usually a second, billed request per product, or absent |
| Per size sale history | individual completed sales with prices and timestamps, per size | usually absent, or an aggregate window only |
| Bid/ask spread | computed on the row | usually left for you to compute |
| Sales volume | 72 hours, 90 days and 12 months | usually 72 hours only, or none |
| Volatility and premium over retail | on every row | rare |
| Ask depth by shipping speed | standard, next day, expedited, standard express | rare |
| Filters | 16, all sent to StockX itself | usually 2 to 4 |
| Filter honesty | the run **reports which filters StockX actually applied** and warns when one is ignored | not checked |
| Ordering | 6 StockX orderings, each individually verified to reorder | often includes orderings that silently do nothing |
| Recurring monitoring | built in, with change types and expiry | rare |
| Resume | built in | rare |

**On the per size numbers.** There are two ways to get them and neither costs an extra
request per size. Set a size scale and every row on the result page IS that size, so 40
sizes across 40 products come back for the price of one page. Turn on full product details
and each row instead carries the WHOLE size table for its product, every size with its own
order book and its own sale history, in one small request per product.

**A note on size scales, because the numbers look wrong until you know it.** StockX reports a
size on the scale that product publishes, and the men's and women's scales are offset: a US
men's 10 is a US women's 11.5. So a men's 10 search legitimately returns `11.5W` for a
women's cut shoe, and a women's 8 search returns `6.5` for a men's cut one. It is the same
physical size. Every row therefore carries `requestedSize` (the size you asked for, in
StockX's own label) next to `size` (the size on that product's own scale) and
`sizeConversions` (the same size in six systems), so a mixed-scale column stays comparable.

***

### What one row looks like

```json
{
  "recordId": "019b334a-609c-724a-a3f3-c54a4e132b87",
  "rowType": "variant",
  "productId": "019b3346-4879-7c50-b34a-733667f8c741",
  "variantId": "019b334a-609c-724a-a3f3-c54a4e132b87",
  "title": "Nike Dunk Low Retro White Black Panda",
  "brand": "Nike",
  "model": "Nike Dunk Low Retro",
  "urlKey": "nike-dunk-low-retro-white-black-2021",
  "url": "https://stockx.com/nike-dunk-low-retro-white-black-2021",
  "size": "10",
  "sizeType": "us m",
  "requestedSize": "US M 10",
  "sizeConversions": [
    { "size": "US M 10", "type": "us m" },
    { "size": "UK 9", "type": "uk" },
    { "size": "EU 44", "type": "eu" },
    { "size": "CM 28", "type": "cm" },
    { "size": "KR 280", "type": "kr" },
    { "size": "US W 11.5", "type": "us w" }
  ],
  "lowestAsk": 172,
  "lowestAskUpdatedAt": "2026-09-05T05:09:43Z",
  "highestBid": 153,
  "highestBidUpdatedAt": "2026-09-02T05:24:31Z",
  "lastSale": 173,
  "bidAskSpread": 19,
  "standardAskCount": 106,
  "standardLowestAsk": 172,
  "expressNextDayAskCount": 32,
  "expressNextDayLowestAsk": 194,
  "salesLast72Hours": 38,
  "salesLast90Days": 1364,
  "averagePriceLast90Days": 223,
  "salesLast12Months": 3659,
  "averagePriceLast12Months": 249,
  "priceVolatility": 0.115084,
  "currency": "USD",
  "market": "US",
  "pricePremium": 0.821,
  "releaseDate": "2021-03-10",
  "gender": "men",
  "productCategory": "sneakers",
  "imageUrl": "https://images.stockx.com/images/Nike-Dunk-Low-Retro-White-Black-Product.jpg",
  "scrapedAt": "2026-09-05T09:12:00Z"
}
```

With **Fetch full product details** on, each row also carries `styleId` (the manufacturer
style code), `colorway`, `retailPrice`, `restockDate`, `sizeConversionTypes`, `images`, the
long product description, and the whole **size table**: `availableSizes` is every size the
product offers, and each entry carries that size's own `lowestAsk`, `highestBid`,
`lastSale`, `bidAskSpread`, `askCount`, 72 hour and 90 day volume, volatility, premium,
its size in six size systems, and `saleHistory`, a list of that size's individual completed
sales with a price and a timestamp on each. `saleHistoryPoints` counts how many recorded
sales the row carries in total.

```json
"availableSizes": [
  {
    "size": "10", "sizeType": "us m", "variantId": "...",
    "lowestAsk": 94, "highestBid": 78, "lastSale": 57, "bidAskSpread": 16,
    "askCount": 41, "salesLast72Hours": 3, "priceVolatility": 0.19,
    "saleHistory": [
      { "price": 57,  "soldAt": "2026-09-05T07:43:20.925Z" },
      { "price": 97,  "soldAt": "2026-08-31T17:18:40.924Z" }
    ]
  }
]
```

***

### Two ways to start

**Search mode.** Give one or more search terms (`air jordan 1`, `nike dunk low`,
`yeezy 350`). Each term is walked independently. Leave the terms empty and the run browses
the category you picked instead, so "every Nike sneaker under $150 with a live bid" is a
valid scope with no search term at all.

**URL mode.** Paste StockX URLs. All of these work:

| URL | What happens |
|---|---|
| `https://stockx.com/search?s=jordan+1` | walked like a keyword search |
| `https://stockx.com/category/sneakers` | walked like a category browse |
| `https://stockx.com/category/sneakers?page=3` | starts the walk at page 3 |
| `https://stockx.com/nike` | recognised as a brand page and walked |
| `https://stockx.com/nike-dunk-low-retro-white-black-2021` | that single product, in full |

A brand landing page and a product page share the same URL shape on StockX, and brand slugs
are hyphenated too (`aime-leon-dore`), so no string rule can separate them. The actor asks
StockX which one it rendered rather than guessing.

**The filters apply in both modes.** A filter already present in a pasted URL wins for that
URL only. A pasted product URL is the one exception: it always returns that single product.

***

### Input parameters

#### Filters, all sent to StockX itself

| Parameter | What it does |
|---|---|
| `category` | 15 StockX categories, top level (sneakers, apparel, collectibles) and sub level (lifestyle, performance, luxury, boots, cleats) |
| `brands` | one or more brand slugs, combined with OR |
| `models` | one or more model slugs (`dunk`, `air-force-1`, `campus-00s`), combined with OR |
| `productLines` | one or more product line slugs (`blazer`, `cortez`, `860v2`) |
| `gender` | men, women, kids, unisex |
| `color` | the 10 colours StockX indexes |
| `activity` | running, basketball, skateboarding, soccer, hiking, golf, football |
| `shoeHeight` | low, mid, high |
| `market` | US, GB, DE, FR, CA, AU or JP. StockX runs a separate order book per country, in its own currency, and the prices genuinely differ. Picking one pins the connection's exit country. |
| `sizeScale` + `size` | **turns on per size rows** |
| `minPriceUsd` / `maxPriceUsd` | sent as one price range |
| `availableNow` | only items with a live ask |
| `xpressShipOnly` | only items StockX already holds and can ship fast |
| `belowRetailOnly` | only items asking under retail |

#### Narrowings StockX has no filter for, applied to the rows the run reads

| Parameter | What it does |
|---|---|
| `minLastSaleUsd` | drop rows whose most recent sale was below this |
| `minSalesLast72Hours` | drop illiquid rows; the fastest way to find what is actually trading |
| `hasLiveAskOnly` | drop rows with no ask |
| `hasLiveBidOnly` | drop rows with no bid |

#### Ordering

| Parameter | What it does |
|---|---|
| `orderBy` | asks StockX to order the whole catalogue: featured, most active, release date, lowest ask, highest bid, last sale. This changes **which** items you get. |
| `sortResultsBy` | rearranges the rows this run collected, after they are read |

Every `orderBy` value was checked against StockX one at a time and kept only when the
returned order actually changed. StockX also accepts an ascending/descending switch and
ignores it, so this actor does not offer one rather than shipping a control that does
nothing.

#### Output and limits

| Parameter | Default | What it does |
|---|---|---|
| `fetchDetails` | off | fetch each item's product page for the style code, colourway, retail price, release and restock dates, the full size run and the image set. Charged once per record. |
| `maxItems` | 20 | the single cap on the run. 0 means unlimited. |
| `maxPages` | 0 (unlimited) | optional safety bound per search term or URL |

#### Resume and recurring updates

| Parameter | What it does |
|---|---|
| `resumeFromRunId` | continue ONE interrupted run without returning or billing what it already collected |
| `incrementalMode` | for scheduled runs of the same search: return only what changed |
| `stateKey` | name a monitoring campaign, or deliberately share one |
| `emitUnchanged` | also return (and bill) rows that did not change |
| `emitExpired` | also return (and bill) rows that disappeared |

In incremental mode each row carries `changeType` (`NEW`, `UPDATED`, `REAPPEARED`,
`UNCHANGED`, `EXPIRED`), `changedFields`, `firstSeenAt` and `lastSeenAt`. **A price move
counts as a change**: on a resale marketplace that is the signal, not noise. An ask that is
re-listed at the same amount does not, so a quiet market does not bill you a diff with no
difference in it.

`EXPIRED` is only produced after a run has scanned the tracked search all the way to the
end. A run that was capped, resumed, refused, page limited, or truncated by StockX's own
1000 result ceiling never marks anything expired, because it did not see enough of the
catalogue to know.

***

### Honesty about what StockX returns

**StockX returns at most 1000 results per search or category.** When a scope hits that
ceiling the run says so explicitly and tells you to narrow it. It never reports a truncated
scope as a complete one.

**Filters are checked, not assumed.** StockX echoes back the filter set it resolved on every
result page. The run prints that echo (`StockX applied: category=sneakers, color=black`) and
warns loudly if a filter it sent was not applied, because a filter that fails open still
returns a full page of results and a large total: neither the row count nor the total can
tell you it was ignored.

**A refused run fails, it does not return zero.** "We returned nothing" and "we could not
read anything" are tracked as two different things, and only their conjunction exits
successfully. A connection problem ends the run with a message saying so, never with a green
run and an empty dataset.

**Promoted placements are dropped.** Result pages carry sponsored cards. They are never
emitted, so you are never billed for an advert.

***

### 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, default
  50\. 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.

***

### What you are charged for

The Store page shows the current rates. What each charge means:

- **Actor start**, once per run.
- **Market record**, per row returned. With a size scale set, one row is one size.
- **Full product details**, once per record, and only when `fetchDetails` is on.

The details surcharge is charged **after** a record is successfully returned, never per
request and never per retry, so the surcharge count can never exceed the number of rows you
received. A run that returns nothing charges nothing beyond the start event.

***

### Example inputs

**The order book for one size, across a brand**

```json
{
  "mode": "search",
  "searchTerms": ["nike dunk"],
  "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
}
```

**Daily monitoring of one search**

```json
{
  "mode": "search",
  "searchTerms": ["travis scott jordan 1"],
  "incrementalMode": true,
  "stateKey": "travis-scott-watch",
  "maxItems": 0
}
```

**Paste URLs**

```json
{
  "mode": "url",
  "urls": [
    "https://stockx.com/search?s=jordan+1",
    "https://stockx.com/nike",
    "https://stockx.com/nike-dunk-low-retro-white-black-2021"
  ],
  "fetchDetails": true,
  "maxItems": 50
}
```

***

### Notes

- Prices are quoted in ONE market's currency, and every row states which:
  `market` and `currency`. The default is the US market in US dollars. StockX
  decides the market from the connection's exit country, so if no exit is
  available in the market you asked for, the run says so loudly and the rows
  still state what they were actually quoted in.
- `pricePremium` is StockX's own ratio of market price to retail, so `0.821` means the item
  trades at about 82 percent above retail.
- `priceVolatility` is StockX's own 12 month volatility figure.
- Ask counts by shipping speed overlap: an item held by StockX is counted in both the
  express buckets and the standard one.
- Sponsored cards on result pages are dropped, so a page of 48 cards can yield fewer than 48
  rows.

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

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

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

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

## `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. Ask, bid and last sale moves ARE reported as UPDATED: on a resale marketplace they are the signal, not noise. 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.

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

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

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

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "air jordan 1"
  ],
  "urls": [
    "https://stockx.com/nike-dunk-low-retro-white-black-2021"
  ],
  "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,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `sizes` (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/nike-dunk-low-retro-white-black-2021"
    ],
    "market": "US",
    "fetchDetails": true,
    "maxItems": 20,
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "proxy": {
        "useApifyProxy": true
    }
};

// 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/nike-dunk-low-retro-white-black-2021"],
    "market": "US",
    "fetchDetails": True,
    "maxItems": 20,
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "proxy": { "useApifyProxy": True },
}

# 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/nike-dunk-low-retro-white-black-2021"
  ],
  "market": "US",
  "fetchDetails": true,
  "maxItems": 20,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  }
}' |
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/57NwGPQyGQDWUA2fb/openapi.json