# StockX Scraper — Real-Time Sneaker & Resale Data (`b2b_leads/stockx-real-time-data-scraper`) Actor

Live StockX resale market intelligence: keyword listing search, full product details, seller profiles, sold comps, and URL collection for sneakers, streetwear and collectibles. Checkbox features — enable only what you need. Structured JSON streamed to your dataset in real time.

- **URL**: https://apify.com/b2b\_leads/stockx-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.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?

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 Real-Time Data

**Live StockX resale market intelligence: sneaker and streetwear listing search, full product details, seller profiles, sold comps, and URL collection. Checkbox features — enable only what you need. Structured JSON streamed to your dataset in real time.**

> **Paid-only / free-tier notice:** This Actor is designed for paying Apify users. Free (non-paying) Apify plans are limited to **2 results per run** — see the [Delivery](#delivery) section and input schema for details. Upgrade your Apify plan for unlimited sneaker and streetwear data exports.

***

### Audience

- **Vintage & thrift resellers** cross-listing on Poshmark, eBay, Depop, Mercari, and Grailed
- **Consignment owners** tracking competitor inventory and repricing
- **Resale arbitrageurs** sourcing undervalued sneakers, streetwear, and collectibles
- **Fashion researchers** and pricing teams
- **AI agents** using Apify MCP for real-time market data queries

***

### Use Cases

- **Undervalued inventory discovery:** Find underpriced sneakers, deadstock streetwear, vintage single-stitch, designer denim, gorpcore, and Y2K pieces on StockX before they sell out.
- **Sold comps / sell-through:** Track completed sales for real market comps, resale margins, and sell-through analysis.
- **Closet / brand monitoring:** Watch specific seller inventories or brand catalogs for new drops and price changes.
- **Slack / Discord deal alerts:** Real-time webhooks for new listings, price drops, and sold items.
- **Multi-platform pricing sync:** Align your listings across Poshmark, eBay, Depop, Mercari, and Grailed using unified StockX market data.

***

### Features

| Feature | Default | Description |
|---------|---------|-------------|
| **Listing Search** | ✅ On | Live keyword search across StockX — sneakers, streetwear, and collectibles. Prefilled with demo queries. |
| **Listing Details** | ❌ Off | Full product records from StockX URLs or product IDs. |
| **Seller Listings** | ❌ Off | Brand/seller inventory tracking — track competitor stock and source in bulk. |
| **Seller Profile** | ❌ Off | Seller stats: rating, items sold, follower count, verification, and bio details. |
| **Sold Item Comps / History** | ❌ Off | Completed sales for market comps, resale margins, and sell-through analysis. |
| **Scrape By URL** | ❌ Off | Paste any StockX URL — product page, search, brand, or category. |

#### Listing Search Filters

- **Brand filter:** Limit results to a brand (e.g. Nike, Adidas, Balenciaga, Yeezy).
- **Size filter:** e.g. US 9, US 10, EU 42.
- **Min/Max price:** Filter by asking price range in USD.
- **Sort order:** Newest, Most active, Lowest ask, Highest bid, Deadstock sold.

#### Enrichment

When **"Enrich with full listing details"** is enabled, each search result stays **one row** (`featureType: listing_search`, `detailsFetched: true`) but is enriched with:

- Full description
- Product traits (size, color, material, style tags)
- Full image gallery
- Market statistics (last sale, bids/asks, sales in last 72 hours)

When disabled, you get fast search cards with price, title, brand, size, and market data.

**Every discovered product is always saved — never filtered out.**

***

### Input Schema

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `enableListingSearch` | boolean | `true` | Live keyword search across StockX. |
| `searchKeywords` | string\[] | `["nike air jordan 1", "yeezy boost 350", "new balance 550"]` | One or more search terms. |
| `searchMaxResults` | integer | `10` | Max products per keyword (1–200). |
| `searchSort` | string | `"newest"` | Sort order: `newest`, `most-active`, `lowest_ask`, `highest_bid`, `deadstock_sold`. |
| `searchBrand` | string | `""` | Brand filter (optional). |
| `searchSize` | string | `""` | Size filter (optional). |
| `searchMinPrice` | integer | — | Min price in USD (optional). |
| `searchMaxPrice` | integer | — | Max price in USD (optional). |
| `searchFetchFullDetails` | boolean | `false` | Enrich search results with full product details. |
| `enableListingDetails` | boolean | `false` | Fetch full product data by URL or ID. |
| `productIds` | string\[] | `[]` | StockX product IDs or URLs. |
| `productUrls` | string\[] | `[]` | Full StockX product URLs. |
| `enableSellerListings` | boolean | `false` | Track seller/brand inventory. |
| `sellerUsernames` | string\[] | `["nike"]` | Seller usernames or brand names. |
| `sellerMaxListings` | integer | `30` | Max listings per seller (1–500). |
| `enableSellerProfile` | boolean | `false` | Extract seller stats. |
| `enableSoldHistory` | boolean | `false` | Collect sold items for comps. |
| `soldMaxItems` | integer | `30` | Max sold items per seller (1–500). |
| `enableScrapeByUrl` | boolean | `false` | Process any StockX URL. |
| `scrapeUrls` | string\[] | `[]` | StockX URLs to process. |
| `webhookUrl` | string | `""` | Optional webhook URL for real-time alerts. |
| `webhookFormat` | string | `"json"` | `json` or `slack`. |
| `proxyConfiguration` | object | Residential US | Apify proxy settings. |

#### Practical StockX Search Examples

- `"nike air jordan 1"` — Classic sneaker search
- `"yeezy boost 350"` — Yeezy sneakers
- `"new balance 550"` — New Balance retro
- `"nike dunk"` — Nike Dunk college colors
- `"balenciaga triple s"` — Designer sneakers
- `"stussy"` — Streetwear brand
- Search with brand filter: leave `searchBrand` as "Nike" and keywords like "air max"
- Size-specific: `"air jordan"` + `searchSize: "US 10"`

***

### Output Schema

Every row includes these core fields:

| Field | Type | Description |
|-------|------|-------------|
| `featureType` | string | `listing_search`, `listing_details`, `seller_listings`, `seller_profile`, `sold_history`, or `scrape_by_url` |
| `scrapedAt` | string | ISO-8601 timestamp |
| `url` | string | Source URL |
| `item_id` | string|null | Product ID |
| `item_url` | string|null | Product URL |
| `title` | string|null | Product title |
| `description` | string|null | Product description |
| `main_image_url` | string|null | Main product image |
| `additional_image_urls` | string\[] | Image gallery |
| `status` | string|null | `available`, `sold`, or null |
| `current_price` | number|null | Current asking price |
| `original_price` | number|null | Retail/MSRP price |
| `currency` | string|null | Currency (default: USD) |
| `discount_percentage` | number|null | Markdown % vs. original price |
| `price_drop_amount` | number|null | Price drop in dollars |
| `brand` | string|null | Brand name |
| `brand_id` | string|null | Brand ID |
| `size` | string|null | Product size (e.g. US 9, EU 42) |
| `condition` | string|null | Product condition |
| `category` | string|null | Category (e.g. sneakers, apparel) |
| `department` | string|null | Department |
| `subcategory` | string|null | Subcategory |
| `color` | string|null | Primary color |
| `colors` | string\[] | All colors |
| `style_tags` | string\[] | Style tags (vintage, y2k, streetwear, etc.) |
| `material` | string|null | Material/fabric |
| `productCategory` | string|null | Product category type |
| `traits` | string\[] | Product traits |
| `gender` | string|null | Gender (Men, Women, Unisex) |
| `releaseDate` | string|null | Release date |
| `manufacturingDate` | string|null | Manufacturing date |
| `last_sale_price` | number|null | Last sale price |
| `last_sale_date` | string|null | Last sale date |
| `sales_last_72_hours` | number|null | Sales in last 72 hours |
| `highest_bid` | number|null | Highest bid |
| `lowest_ask` | number|null | Lowest asking price |
| `bids_count` | number|null | Number of bids |
| `asks_count` | number|null | Number of asks |
| `likes_count` | number|null | Likes/engagement |
| `is_sold` | boolean|null | Is sold |
| `seller_username` | string|null | Seller username |
| `seller_id` | string|null | Seller ID |
| `seller_display_name` | string|null | Seller display name |
| `seller_avatar_url` | string|null | Seller avatar |
| `seller_rating` | number|null | Seller rating |
| `seller_items_sold` | number|null | Seller items sold |
| `seller_location` | string|null | Seller location |
| `seller_verified` | boolean|null | Seller verified |
| `seller_last_active` | string|null | Seller last active |
| `sizeChart` | array|null | Size chart data |
| `position` | number|null | Position in search results |
| `detailsFetched` | boolean|null | True when full details were merged into this search row |

***

### Webhooks

Configure a webhook URL to receive real-time alerts for every record. Each record is always saved to the dataset — the webhook is an **additional** push.

#### Formats

- **JSON:** Full record object — ideal for Zapier, Make, n8n, or custom pricing bots.
- **Slack:** Formatted Slack message with product title, price, brand, size, condition, seller, and link.

#### Setup

1. In Apify Console, add your webhook URL to the `webhookUrl` input field.
2. Select `webhookFormat`: `json` for full records, `slack` for Slack-friendly messages.
3. Each new dataset row is POSTed to your URL (15s timeout, fire-and-forget).

***

### MCP / AI Agent Usage

Connect this Actor to your AI agent via Apify MCP:

```
What is the average sold price for a Nike Air Jordan 1 on StockX?
Find underpriced Yeezy Boost 350 listings under $200.
Show me the lowest ask for New Balance 550 in US 9.
Who are the top Nike sellers on StockX?
What sneakers sold in the last 72 hours?
```

***

### Delivery

- **Listing Search (default):** 10 results per keyword, ready within seconds of starting.
- **Streaming:** every record is saved to the dataset the moment it is collected, so the first results appear in your dataset before the run finishes.
- **Enrichment:** adds a little extra time per listing to fold full product details into the same row — opt-in only.
- **Memory:** 2048 MB default (the run keeps a live catalog session open), configurable up to 8192 MB.
- **Timeout:** 10,000 seconds (about 2.7 hours).

> **First run tip:** leave the cached run memory at the default 2048 MB. Smaller allocations can end the run early on large inventories.

#### Free Tier

Free (non-paying) Apify plans are limited to **2 results per run**. This is intentional — it lets you validate the data quality before committing to a paid plan.

- **Limit mode (default):** 2 items, then stop with a clear upgrade message.
- **Block mode (configurable via Console env vars):** 0 items, upgrade message shown before collection.

Upgrade to a paid Apify plan for unlimited sneaker and streetwear data exports.

***

### Proxy Setup

- **Apify Platform:** Residential proxy recommended (US default).
- **Local testing:** add your own residential proxy values to `.env` (see `.env.example`).

Proxy credentials are never shown in logs, output, or README.

***

### FAQ

**Q: How fresh is the data?**
A: Data is collected in real-time during the run. Search results reflect the current StockX catalog at the moment of collection.

**Q: What's the difference between Listing Search and Listing Details?**
A: Listing Search finds products by keyword. Listing Details fetches the full record for specific products you already know about (by URL or ID).

**Q: Can I track specific sellers?**
A: Yes — enable Seller Listings and Seller Profile, then add seller usernames or brand names to `sellerUsernames`.

**Q: Does this work for sold items?**
A: Yes — enable Sold Item Comps / History to collect completed sales for market comps and sell-through analysis.

**Q: How do I get deal alerts?**
A: Set up a webhook URL (Slack, Discord, Zapier, Make, n8n, or a custom bot). Every saved record is also sent to your webhook in real time.

**Q: What proxy should I use?**
A: Residential proxies are recommended for the most reliable results. On Apify, the built-in Residential proxy is preconfigured (US by default) — leave it enabled for best results. For local testing, add your own proxy values to `.env` (see `.env.example`).

**Q: Is the free tier really only 2 results?**
A: Yes — free (non-paying) Apify plans are capped at 2 results per run. This is a platform-level limit, not a scraper limitation. Upgrade to a paid plan for unlimited exports.

**Q: I got fewer results than I asked for. Why?**
A: StockX only shows a limited inventory for very specific search terms — narrow keywords (a full product name) return fewer products than broad ones (a brand plus a silhouette). Occasional empty runs can also happen when the marketplace is rate-limiting; simply run the Actor again.

**Q: Why is my first keyword slower than the next ones?**
A: The run opens one catalog session and reuses it for every keyword. The first request pays that setup cost — the rest stream in as the session stays warm.

***

### Output Views

Filter your dataset by feature type:

- `overview` — Core fields across all features
- `search` — Listing Search results (one row per product)
- `details` — Listing Details (specific IDs/URLs only)
- `seller_listings` — Seller/brand inventory
- `seller_profile` — Seller profiles
- `sold_history` — Sold item comps
- `scrape_by_url` — URL scrape results

***

### Build & Run

```bash
## Install dependencies
npm install

## Build
npm run build

## Typecheck
npm run typecheck

## Local run (reads local.input.json + .env)
npm run start:local

## Dev run
npm run start:dev
```

***

### Apify Console Setup

1. **Build tag:** `latest` — the first build takes a few minutes because the base image is large.
2. **Memory:** keep the default **2048 MB**. The run keeps a live catalog session open, so a smaller allocation can end the run early.
3. **PPE event name:** `result` (configure in Actor → Monetization).
4. **Proxy:** Residential, US default — leave the prefilled  proxy settings enabled for best results.
5. **Free-tier env vars (recommended):**
   - `FREE_TIER_MODE=limit` (or `block`)
   - `FREE_TIER_MAX_ITEMS=2`
6. **Test run:** enable Listing Search and click Start — 10 search cards per keyword should land in the dataset within the first minute.

***

### Privacy & Data Handling

This Actor collects only publicly available product and market data from StockX. No login credentials, no personal data, and nothing from signed-in accounts is collected. All data is structured catalog intelligence suitable for market research and pricing analysis.

***

### File Layout

```
.actor/
  actor.json           # Apify actor configuration
  input_schema.json    # Input UI schema
  output_schema.json   # Output schema
  dataset_schema.json  # Dataset field definitions
Dockerfile             # Container build
package.json           # Dependencies
tsconfig.json          # TypeScript config
scripts/
  apify-entrypoint.mjs # Apify entry point
src/
  main.ts              # Actor entry point
  localMain.ts         # Local testing entry
  normalizeInput.ts    # Input normalization
  runner.ts            # Feature orchestration
  types.ts             # TypeScript types
  features/
    listingSearch.ts   # Keyword search
    listingDetails.ts  # Product details by ID/URL
    sellerListings.ts  # Seller/brand inventory
    sellerProfile.ts   # Seller profiles
    soldHistory.ts     # Sold item comps
    scrapeByUrl.ts     # URL auto-detect
  utils/
    stockxClient.ts    # Data collection
    mapping.ts         # Data transformations
    actorLog.ts        # User-facing log messages
    concurrency.ts     # Parallel processing
    paywall.ts         # Free-tier gating
    ppeCharge.ts       # Pay-per-event charging
    proxy.ts           # Proxy configuration
    runState.ts        # State management
    spendingLimit.ts   # Spend limit tracking
    webhook.ts         # Webhook delivery
```

***

*Built for resale intelligence. Structured JSON, real-time streaming, and checkbox-driven features — so you only pay for what you need.*

# Actor input Schema

## `enableListingSearch` (type: `boolean`):

Search StockX by keyword for sneakers, streetwear, and collectibles. On by default — prefilled so you can click Start immediately.

## `searchKeywords` (type: `array`):

One or more search terms (e.g. nike air jordan 1, yeezy boost 350, new balance 550). Required when Listing Search is on.

## `searchMaxResults` (type: `integer`):

Maximum products to return for each keyword (1–200). Default 10 — perfect for instant demo runs.

## `searchSort` (type: `string`):

How to order search results. "Newest" is ideal for tracking fresh drops.

## `searchBrand` (type: `string`):

Keep only results matching a brand (e.g. Nike, Adidas, Balenciaga, Yeezy).

## `searchMinPrice` (type: `integer`):

Minimum asking price in USD.

## `searchMaxPrice` (type: `integer`):

Maximum asking price — pair with "Lowest ask" sort to catch underpriced deals fast.

## `searchFetchFullDetails` (type: `boolean`):

When on, each search result stays ONE row (featureType listing\_search, detailsFetched=true) but is enriched with description, product traits, full image gallery, and market statistics. Adds a little extra time per listing. When off, you get fast search cards with price, title, brand, size, and market data. Every discovered item is always saved — never filtered out.

## `enableListingDetails` (type: `boolean`):

Fetch the full record for specific StockX products by URL or product ID.

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

StockX product URLs, e.g. https://stockx.com/nike-air-jordan-1

## `enableSellerListings` (type: `boolean`):

Collect listings from specific sellers or brands on StockX.

## `sellerUsernames` (type: `array`):

StockX seller usernames or brand names to track.

## `sellerMaxListings` (type: `integer`):

Maximum listings to collect per seller (1–500).

## `enableSellerProfile` (type: `boolean`):

Extract seller stats: rating, items sold, follower count, verification, and bio details.

## `enableSoldHistory` (type: `boolean`):

Collect completed sales for real market comps, resale margins, and sell-through analysis.

## `soldMaxItems` (type: `integer`):

Maximum sold listings to collect per seller (1–500).

## `enableScrapeByUrl` (type: `boolean`):

Paste any StockX URL — product page, search results, brand page, or category.

## `scrapeUrls` (type: `array`):

Any StockX product, search, brand, or category URL.

## `webhookUrl` (type: `string`):

Optional. Every record is always saved to the run dataset — this webhook is an ADDITIONAL real-time push. Each new row is also POSTed to this URL (Slack, Discord, Zapier, Make, n8n, custom pricing bot).

## `webhookFormat` (type: `string`):

json = full record object; slack = Slack-friendly message payload.

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

Residential proxy recommended. US default for StockX.

## Actor input object example

```json
{
  "enableListingSearch": true,
  "searchKeywords": [
    "nike air jordan 1",
    "yeezy boost 350",
    "new balance 550"
  ],
  "searchMaxResults": 10,
  "searchSort": "newest",
  "searchBrand": "",
  "searchFetchFullDetails": false,
  "enableListingDetails": false,
  "productIds": [],
  "enableSellerListings": false,
  "sellerUsernames": [
    "nike"
  ],
  "sellerMaxListings": 30,
  "enableSellerProfile": false,
  "enableSoldHistory": false,
  "soldMaxItems": 30,
  "enableScrapeByUrl": false,
  "scrapeUrls": [
    "https://stockx.com/search?q=nike+air+jordan"
  ],
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Full dataset for this run (every featureType).

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

Core fields across features, including detailsFetched for search rows.

## `search` (type: `string`):

featureType=listing\_search only. One product = one row; full details are merged when "Enrich with full listing details" is enabled.

## `details` (type: `string`):

featureType=listing\_details — only from the Listing Details feature (specific IDs/URLs), not from search enrichment.

## `seller_listings` (type: `string`):

No description

## `seller_profile` (type: `string`):

No description

## `sold_history` (type: `string`):

No description

## `scrape_by_url` (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 = {
    "enableListingSearch": true,
    "searchKeywords": [
        "nike air jordan 1",
        "yeezy boost 350",
        "new balance 550"
    ],
    "searchMaxResults": 10,
    "searchSort": "newest",
    "searchFetchFullDetails": false,
    "enableListingDetails": false,
    "productIds": [],
    "enableSellerListings": false,
    "sellerUsernames": [
        "nike"
    ],
    "sellerMaxListings": 30,
    "enableSellerProfile": false,
    "enableSoldHistory": false,
    "soldMaxItems": 30,
    "enableScrapeByUrl": false,
    "scrapeUrls": [
        "https://stockx.com/search?q=nike+air+jordan"
    ],
    "webhookFormat": "json",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/stockx-real-time-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 = {
    "enableListingSearch": True,
    "searchKeywords": [
        "nike air jordan 1",
        "yeezy boost 350",
        "new balance 550",
    ],
    "searchMaxResults": 10,
    "searchSort": "newest",
    "searchFetchFullDetails": False,
    "enableListingDetails": False,
    "productIds": [],
    "enableSellerListings": False,
    "sellerUsernames": ["nike"],
    "sellerMaxListings": 30,
    "enableSellerProfile": False,
    "enableSoldHistory": False,
    "soldMaxItems": 30,
    "enableScrapeByUrl": False,
    "scrapeUrls": ["https://stockx.com/search?q=nike+air+jordan"],
    "webhookFormat": "json",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/stockx-real-time-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 '{
  "enableListingSearch": true,
  "searchKeywords": [
    "nike air jordan 1",
    "yeezy boost 350",
    "new balance 550"
  ],
  "searchMaxResults": 10,
  "searchSort": "newest",
  "searchFetchFullDetails": false,
  "enableListingDetails": false,
  "productIds": [],
  "enableSellerListings": false,
  "sellerUsernames": [
    "nike"
  ],
  "sellerMaxListings": 30,
  "enableSellerProfile": false,
  "enableSoldHistory": false,
  "soldMaxItems": 30,
  "enableScrapeByUrl": false,
  "scrapeUrls": [
    "https://stockx.com/search?q=nike+air+jordan"
  ],
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/stockx-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/stockx-real-time-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/oU8JNYycM7nJnwNkC/builds/1kc360ptFPMx0sFdp/openapi.json