# StockX Scraper — Search & Market Data (`memo23/stockx-search-scraper`) Actor

Scrape StockX search & category pages with live market data — lowest ask, highest bid, last sale, sales counts & volatility on every product. Sneakers, apparel, electronics, collectibles, trading cards, watches. Search by keyword or paste any StockX URL. JSON/CSV export.

- **URL**: https://apify.com/memo23/stockx-search-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 — Search & Browse with Live Market Data

Scrape StockX search results and category pages into structured product rows with a full market snapshot per product: lowest ask, highest bid, last sale, sales counts, average prices, and price volatility. Enter a keyword or paste any StockX search/category URL, and export JSON or CSV in seconds.

Track resale prices across sneakers, apparel, electronics, collectibles, trading cards, watches, and handbags — without touching a browser.

![How StockX Search Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-stockx.png)

### Why Use This Scraper?

- **Full market snapshot on every row** — lowest ask, highest bid, last sale, 72-hour sales count, annual sales count, average prices, and volatility come with every product, straight from the search page.
- **Fast** — 40 products per page, pages fetched in parallel; 100 products typically land in under 10 seconds.
- **Simple input** — a keyword like `jordan 4` is enough. Or paste any StockX search or category URL, filters included.
- **Ranking preserved** — every row carries its `position` and `page`, so you can reconstruct exactly how StockX ordered the results.
- **Sponsored placements flagged** — paid tiles are marked with `isSponsored` so your analysis isn't skewed by ads.
- **JSON, CSV, Excel** — standard Apify dataset export in every format.

### Overview

This actor is built for resellers, arbitrage traders, market researchers, and data teams who need StockX pricing signals at scale. It scrapes StockX **search results and category browse pages** and produces **one dataset row per product**.

Each row combines catalog data (title, colorway, brand, model, category, release date, image, description) with the live market state StockX embeds in its result pages (lowest ask, highest bid, last sale, ask counts, sales statistics).

This is a **search/browse-level scraper**. It does not open individual product pages, so per-size variant pricing, bid/ask depth tables, and individual sale transactions are out of scope (see FAQ).

### Supported Inputs

#### Search queries

Plain keywords in the `search` field — each becomes a StockX search:

- `jordan 1`
- `travis scott`
- `pokemon 151`
- `rolex submariner`

#### Brands and categories

- `brands` — brand names or slugs (`nike`, `adidas`, `Aime Leon Dore`); each becomes `stockx.com/brands/{slug}`
- `categories` — `sneakers`, `shoes`, `apparel`, `accessories`, `electronics`, `collectibles`, `trading-cards`, `watches`, `handbags`

#### Structured filters

Applied to every search query, brand, and category in the run:

- `sort` — `featured`, `most-active` (trending), `recent_asks`, `recent_bids`, `release_date` (newest first), `last_sale`
- `priceMin` / `priceMax` — lowest-ask price range in USD
- `belowRetail` — only products currently selling below retail
- `availableNow` — only products with at least one active ask

#### URL types

Paste full URLs into `startUrls`:

- **Search URLs** — `https://stockx.com/search?s=yeezy`
- **Category pages** — `https://stockx.com/sneakers`, `https://stockx.com/apparel`, `https://stockx.com/electronics`, `https://stockx.com/collectibles`, `https://stockx.com/trading-cards`, `https://stockx.com/watches`, `https://stockx.com/handbags`
- **Brand pages** — `https://stockx.com/brands/nike`
- **Filtered category URLs** — apply filters on stockx.com, then copy the URL; the filter parameters are kept.

#### Copy-pasteable startUrls

```json
{
    "startUrls": [
        { "url": "https://stockx.com/search?s=nike dunk" },
        { "url": "https://stockx.com/sneakers" }
    ],
    "maxItems": 200
}
```

#### Unsupported inputs

- **Product detail URLs** (e.g. `https://stockx.com/air-jordan-1-retro-high-og-cool-grey`) — this actor works at the search/browse level only.
- **Seller/account pages, portfolio pages** — behind login, out of scope.

### Use Cases

| Who | What they do with it |
|---|---|
| Resellers & arbitrage traders | Monitor lowest ask vs last sale spreads across whole categories to spot flip opportunities |
| Sneaker & collectibles investors | Track sales velocity (72-hour and annual counts) and volatility before buying in |
| E-commerce & pricing teams | Benchmark retail prices against live resale market values |
| Market researchers & analysts | Build datasets of resale prices, premiums, and release calendars per brand |
| Data & AI teams | Feed structured resale market data into models, dashboards, and agents |

### How It Works

1. **Resolve inputs** — each keyword becomes a StockX search URL; pasted search/category URLs are validated and passed through.
2. **Fetch page 1** — one HTTP request discovers the result count and page count (up to 25 pages × 40 products per query).
3. **Parse embedded market data** — each page embeds the full product + market payload; the actor extracts it directly, no rendering.
4. **Walk remaining pages in parallel** — a sliding-window fetch pool works through pages 2..N.
5. **Dedupe and push** — one row per unique product, capped at `maxItems`.

### Input Configuration

#### Input fields

| Field | Type | Default | Description |
|---|---|---|---|
| `search` | array | `["jordan 1"]` | Keyword searches. Each query is scraped as `stockx.com/search?s={query}`. |
| `brands` | array | — | Brand names or slugs, e.g. `nike`, `Aime Leon Dore`. Each becomes `stockx.com/brands/{slug}`. |
| `categories` | array | — | Category slugs: `sneakers`, `shoes`, `apparel`, `accessories`, `electronics`, `collectibles`, `trading-cards`, `watches`, `handbags`. |
| `startUrls` | array | — | Full StockX search or category/brand URLs. Mix freely with `search`. |
| `sort` | string | `featured` | Result ordering: `featured`, `most-active`, `recent_asks`, `recent_bids`, `release_date`, `last_sale`. |
| `priceMin` / `priceMax` | integer | — | Lowest-ask price range filter (USD). |
| `belowRetail` | boolean | `false` | Only products currently selling below their retail price. |
| `availableNow` | boolean | `false` | Only products with at least one active ask. |
| `maxItems` | integer | `1000` | Hard cap on products collected across all queries and URLs. |
| `maxConcurrency` | integer | `5` | Listing pages fetched in parallel. |
| `maxRequestRetries` | integer | `5` | Retries before a failed page is given up. |

#### Common scenarios

**Keyword search, first 100 products:**

```json
{
    "search": ["nike dunk"],
    "maxItems": 100
}
```

**Whole category snapshot (top 1,000 by StockX ranking):**

```json
{
    "startUrls": [{ "url": "https://stockx.com/trading-cards" }],
    "maxItems": 1000
}
```

**Several queries in one run:**

```json
{
    "search": ["jordan 4", "yeezy 350", "new balance 990"],
    "maxItems": 500
}
```

**Newest Nike releases between $100 and $300:**

```json
{
    "brands": ["nike"],
    "sort": "release_date",
    "priceMin": 100,
    "priceMax": 300,
    "maxItems": 200
}
```

**Below-retail flip shortlist for a whole category:**

```json
{
    "categories": ["sneakers"],
    "belowRetail": true,
    "sort": "most-active",
    "maxItems": 500
}
```

### Output Overview

One dataset row per product. Each row has three groups of fields:

1. **Catalog** — title, colorway name, brand, model, gender, category, release date, description, image URL, product URL.
2. **Market snapshot** — lowest ask, highest bid, last sale, ask counts, Xpress-Ship availability, sales counts (72-hour, 90-day, annual), average prices, volatility, price premium.
3. **Provenance** — `position` and `page` (StockX ranking), `sourceUrl`, `isSponsored`, `scrapedAt`.

Prices are plain numbers in the currency StockX serves to US traffic (USD).

### Output Samples

Real row (shortened), from a `"jordan 1"` search:

```json
{
    "productId": "019cfdb4-3545-7b24-8773-11f7411145fb",
    "title": "Jordan 1 Retro Low OG SP Travis Scott Sail Tropical Pink",
    "name": "Travis Scott Sail Tropical Pink",
    "urlKey": "air-jordan-1-retro-low-og-sp-travis-scott-sail-tropical-pink",
    "productUrl": "https://stockx.com/air-jordan-1-retro-low-og-sp-travis-scott-sail-tropical-pink",
    "brand": "Jordan",
    "model": "Jordan 1 Retro Low OG SP",
    "gender": "men",
    "condition": "New",
    "productCategory": "sneakers",
    "primaryCategory": "Air Jordan",
    "releaseDate": "2026-05-29",
    "image": "https://images.stockx.com/images/Air-Jordan-1-Retro-Low-OG-SP-Travis-Scott-Sail-Tropical-Pink.jpg",
    "variantCount": 25,
    "lowestAsk": 267,
    "lowestAskUpdatedAt": "2026-09-09T06:15:54Z",
    "highestBid": 439,
    "highestBidUpdatedAt": "2026-09-06T01:35:31Z",
    "lastSale": 478,
    "asksCount": 1572,
    "xpressShipAvailable": true,
    "salesLast72Hours": 183,
    "annualAveragePrice": 407,
    "annualSalesCount": 16862,
    "annualVolatility": 0.189869,
    "annualPricePremium": 2.078,
    "last90DaysAveragePrice": 371,
    "last90DaysSalesCount": 9624,
    "isSponsored": false,
    "position": 1,
    "page": 1,
    "sourceUrl": "https://stockx.com/search?s=jordan%201",
    "scrapedAt": "2026-09-10T11:06:54.535Z"
}
```

A `description` field with the full product write-up (typically 1-2 paragraphs) is also included; it's omitted above for brevity.

### Key Output Fields

#### Product Core

- `productId`, `title`, `name` (colorway), `urlKey`, `productUrl`, `brand`, `model`, `gender`, `condition`

#### Categorization

- `productCategory`, `primaryCategory`, `browseVerticals[]`, `listingType`, `releaseDate`

#### Market Prices

- `lowestAsk`, `highestBid`, `lastSale`, `annualAveragePrice`, `last90DaysAveragePrice`, `annualPricePremium`

#### Market Activity

- `salesLast72Hours`, `annualSalesCount`, `last90DaysSalesCount`, `asksCount`, `annualVolatility`, `xpressShipAvailable`

#### Provenance

- `position`, `page`, `sourceUrl`, `isSponsored`, `scrapedAt`

### FAQ

#### Which StockX URLs are supported?

Search URLs (`/search?s=...`), category pages (`/sneakers`, `/apparel`, `/electronics`, `/collectibles`, `/trading-cards`, `/watches`, `/handbags`), and brand pages (`/brands/{slug}`), including any filter parameters. Product detail URLs are **not** supported.

#### Does this return per-size prices or individual sale transactions?

No. Those live on product detail pages, which are outside this actor's scope. You get the product-level market snapshot: lowest ask, highest bid, last sale, sales counts, averages, and volatility. `variantCount` tells you how many size variants exist.

#### Why is a single query capped at 1,000 products?

StockX caps any single search/browse query at 25 pages × 40 products. To go deeper into a large category, split it into multiple runs using the built-in filters — `priceMin`/`priceMax` bands, individual `brands`, `sort` orders — or multiple filtered start URLs.

#### What currency are the prices in?

USD — the actor requests US-market pages. Multi-currency output isn't currently supported.

#### Are all market fields always populated?

Almost always, but very new or inactive products can have `null` for `lowestAsk`, `highestBid`, or `lastSale` when no asks/bids/sales exist yet.

#### Can I mix keywords and URLs in one run?

Yes — `search` queries and `startUrls` are merged, deduplicated by product, and counted against the same `maxItems`.

#### Can I scrape private or login-gated content?

No. The actor only accesses publicly available pages. Accounts, portfolios, and anything behind the StockX login wall are out of scope.

#### What about rate limits and blocks?

The actor uses browser-grade TLS fingerprints with automatic retry and fingerprint rotation. Failed pages are retried up to `maxRequestRetries` times and skipped rather than failing the run.

### Support

Found a bug or have a feature request? Open an issue on the actor's [Issues tab](https://apify.com/memo23/stockx-search-scraper/issues) or email me at muhamed.didovic@gmail.com.

### Additional Services

Need a custom export shape, scheduled monitoring, or a different marketplace covered? I do tailored work — drop me a line at muhamed.didovic@gmail.com.

### Explore More Scrapers

If you found this useful, you might also like:

- [**Chrono24 Scraper**](https://apify.com/memo23/chrono24-scraper) — luxury watch listings and prices from the biggest watch marketplace
- [**eBay Search Scraper**](https://apify.com/memo23/ebay-search-scraper-ppe) — active and sold listings with prices across 17 eBay markets
- [**Vinted Scraper**](https://apify.com/memo23/apify-vinted-scraper) — second-hand fashion listings, prices, and sellers
- [**Zalando Scraper**](https://apify.com/memo23/zalando-scraper) — fashion retail products and prices

Full list at [apify.com/memo23](https://apify.com/memo23).

### 🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/stockx-search-scraper`).

**Purpose:** scrapes StockX search results and category pages; one row per product with a live market snapshot (lowest ask, highest bid, last sale, sales counts, volatility) — no product-page visits needed.

**Minimal input:**

```json
{ "search": ["jordan 4"], "maxItems": 20 }
```

**Filtered input:**

```json
{ "brands": ["nike"], "sort": "release_date", "priceMin": 100, "priceMax": 300, "belowRetail": false, "maxItems": 50 }
```

Other targeting inputs: `categories` (`sneakers`, `apparel`, `trading-cards`, ...), `availableNow` (boolean), `sort` one of `featured | most-active | recent_asks | recent_bids | release_date | last_sale`.

**Output:** one dataset row per product — `productId`, `title`, `name`, `urlKey`, `productUrl`, `brand`, `model`, `gender`, `condition`, `productCategory`, `primaryCategory`, `browseVerticals[]`, `releaseDate`, `description`, `image`, `variantCount`, `lowestAsk`, `highestBid`, `lastSale`, `asksCount`, `xpressShipAvailable`, `salesLast72Hours`, `annualAveragePrice`, `annualSalesCount`, `annualVolatility`, `annualPricePremium`, `last90DaysAveragePrice`, `last90DaysSalesCount`, `isSponsored`, `position`, `page`, `sourceUrl`, `scrapedAt`.

**Behaviors an agent should know:**

- Always set `maxItems` — an uncapped run returns up to 1,000 products per query/URL (40 per page, max 25 pages; that's StockX's own cap).
- `search` queries and `startUrls` are merged into one run and deduplicated by product.
- Product detail URLs are rejected; only search/category/brand listing URLs work.
- Billing: charged per dataset item (result) plus a small actor-start fee; failed or retried pages are never charged.
- Prices are USD product-level values; per-size pricing and individual sale transactions are not available.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by StockX LLC or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available StockX search and category pages — no authenticated endpoints, paid features, or content behind the stockx.com login wall. Users are responsible for ensuring their use complies with stockx.com's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organization.

***

### SEO Keywords

stockx scraper, scrape stockx, stockx API, stockx.com scraper, Apify stockx, sneaker price scraper, resale price tracker, sneaker market data, stockx price monitoring, lowest ask scraper, last sale data, sneaker resell data, trading card prices, collectibles market data, streetwear resale data, sneaker arbitrage tool, resale market intelligence, stockx data export, sneaker analytics, watch resale prices

# Actor input Schema

## `search` (type: `array`):

Keyword searches, e.g. `jordan 4`, `travis scott`, `pokemon 151`. Each query is scraped as `stockx.com/search?s={query}`.

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

Brand names or slugs, e.g. `nike`, `adidas`, `Aime Leon Dore`, `alexander-mcqueen`. Each becomes `stockx.com/brands/{slug}` and returns up to 1,000 products.

## `categories` (type: `array`):

Category slugs: `sneakers`, `shoes`, `apparel`, `accessories`, `electronics`, `collectibles`, `trading-cards`, `watches`, `handbags`. Each becomes a StockX category browse page and returns up to 1,000 products.

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

Full StockX listing URLs — search URLs (`https://stockx.com/search?s=yeezy`) or category/brand browse URLs (`https://stockx.com/sneakers`, `https://stockx.com/apparel`, `https://stockx.com/brands/nike`). Category URLs keep any filter parameters you add in the browser. Product detail URLs are not supported.

## `sort` (type: `string`):

Result ordering, same options as on stockx.com: `featured` (default), `most-active` (trending), `recent_asks`, `recent_bids`, `release_date` (newest first), `last_sale`.

## `priceMin` (type: `integer`):

Only products whose lowest ask is at or above this value (USD). Example: `200`.

## `priceMax` (type: `integer`):

Only products whose lowest ask is at or below this value (USD). Example: `500`.

## `belowRetail` (type: `boolean`):

Only products currently selling below their retail price — ready-made flip shortlist.

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

Only products with at least one active ask (skips products nobody is selling right now).

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

Hard cap on the number of products collected across all queries and URLs. Each result is one product with its full market snapshot.

## `maxConcurrency` (type: `integer`):

Maximum number of listing pages fetched in parallel.

## `maxRequestRetries` (type: `integer`):

Number of retries before a failed page is given up.

## Actor input object example

```json
{
  "search": [
    "jordan 1"
  ],
  "sort": "featured",
  "belowRetail": false,
  "availableNow": false,
  "maxItems": 1000,
  "maxConcurrency": 5,
  "maxRequestRetries": 5
}
```

# Actor output Schema

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

Every scraped product row in the default dataset.

# 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 = {
    "search": [
        "jordan 1"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/stockx-search-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 = { "search": ["jordan 1"] }

# Run the Actor and wait for it to finish
run = client.actor("memo23/stockx-search-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 '{
  "search": [
    "jordan 1"
  ]
}' |
apify call memo23/stockx-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/stockx-search-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/O9qUzgT1U0lcreKL4/builds/G3Ly4EeKWtScN1oed/openapi.json