# JD Sports Scraper (`crawlerbros/jd-sports-scraper`) Actor

Scrape JD Sports UK (jdsports.co.uk) -- search or browse sneakers, streetwear, and sportswear by category or brand. Get title, brand, price, sale price, colour, sizes in stock, images, and full product detail. No login required.

- **URL**: https://apify.com/crawlerbros/jd-sports-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## JD Sports Scraper

Scrape [JD Sports UK](https://www.jdsports.co.uk) — sneakers, streetwear, and sportswear from Nike, adidas, Jordan, New Balance, ASICS, and 40+ other brands. Search by keyword, browse by category or brand, or fetch full detail for specific product URLs. Get price, sale price and discount, colour, per-size stock, images, and a full product description. No login, cookies, or paid proxy required.

### What this actor does

- **Four modes:** `search`, `category`, `brand`, `url`
- **Full category tree:** Footwear (trainers, running, classic, hi-tops, boots, sandals, and more), Clothing, Accessories, and Sale — for Men, Women, and Kids
- **44 brands** available as a dropdown filter or dedicated browse mode
- **Live pricing:** current price, pre-discount "was" price, and computed discount %
- **Per-size stock:** UK shoe sizes / clothing sizes with in-stock / out-of-stock status (opt-in — adds one request per product)
- **Filters:** price range, sale-only, colour, brand, gender/department, size-in-stock
- **Empty fields are omitted** — every record only contains data JD Sports actually returned

### Output per product

| Field | Description |
|---|---|
| `productId` | JD Sports internal product code (PLU) |
| `title` | Product name |
| `brand` | Brand name |
| `colour` | Colourway |
| `gender` | `men` / `women` / `kids`, derived from the category breadcrumb |
| `category`, `categoryPath` | Category breadcrumb, e.g. `Men / Mens Footwear / Trainers` |
| `price` | Current price (GBP) |
| `wasPrice` | Pre-discount price, only present when the item is on sale |
| `discountPercent` | Computed `% off`, only present when on sale |
| `onSale` | `true` if currently discounted |
| `currency` | Always `GBP` (JD Sports UK) |
| `description` | Full product description (mode=`url` or `fetchFullDetail`) |
| `articleCode` | Manufacturer article/style code, e.g. `DB3021` (detail only) |
| `images` | Full image gallery URLs (detail only; listing pages return a single `imageUrl`) |
| `imageUrl` | Listing-page thumbnail (search/category/brand modes, unless `fetchFullDetail` is set) |
| `sizes` | Array of `{size, inStock, upc, sku}` — only when sizes were fetched |
| `sizesAvailable` | Flat array of in-stock sizes only |
| `availability` | `In Stock` / `Out of Stock` (detail only) |
| `productUrl`, `sourceUrl` | Canonical JD Sports product page URL |
| `recordType` | Always `"product"` |
| `scrapedAt` | UTC ISO timestamp |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search` | `search` / `category` / `brand` / `url` |
| `searchQuery` | string | `air max` | Free-text query (mode=`search`) |
| `category` | select | `footwear-trainers` | Category slug (mode=`category`); combined with `gender` |
| `brand` | select | `nike` | Brand slug (mode=`brand`) |
| `gender` | select | – | `men` / `women` / `kids` — scopes `category`/`brand`, hints `search` |
| `productUrls` | array | – | Full product page URLs (mode=`url`) |
| `sortBy` | select | `recommended` | `recommended` / `latest` / `name-a-z` / `name-z-a` / `price-low-high` / `price-high-low` |
| `minPrice` / `maxPrice` | integer | – | Price range filter (GBP, current price) |
| `onSaleOnly` | boolean | `false` | Only emit discounted products |
| `colour` | select | – | Colour filter (21 options) |
| `brandFilter` | select | – | Narrow `search`/`category` results to one brand |
| `genderFilter` | select | – | Narrow `search`/`brand` results to one department |
| `size` | string | – | Only emit products with this size currently in stock (adds one request per product) |
| `fetchFullDetail` | boolean | `false` | Fetch full detail (description, image gallery, article code, sizes) for every result, not just listing-page fields |
| `maxItems` | integer | `24` | Hard cap on emitted records (1–2000) |
| `proxyConfiguration` | object | AUTO | Apify proxy config; the free AUTO datacenter group is used as an automatic fallback if a run is rate-limited — no paid proxy is required |

#### Example: search by keyword

```json
{ "mode": "search", "searchQuery": "air max 90", "maxItems": 20 }
````

#### Example: browse Men's trainers on sale, sorted by price

```json
{
  "mode": "category",
  "category": "footwear-trainers",
  "gender": "men",
  "onSaleOnly": true,
  "sortBy": "price-low-high",
  "maxItems": 40
}
```

#### Example: browse a brand, filtered by size in stock

```json
{ "mode": "brand", "brand": "adidas", "gender": "men", "size": "9", "maxItems": 20 }
```

#### Example: fetch full detail for specific products

```json
{
  "mode": "url",
  "productUrls": [
    "https://www.jdsports.co.uk/product/black-adidas-originals-handball-spezial/16227358/"
  ]
}
```

### Use cases

- **Price monitoring** — track sale prices and discount % across sneaker drops
- **Assortment / catalog research** — pull a brand's or category's full live JD Sports range
- **Stock alerts** — poll `size` availability for a specific shoe size
- **Competitor / market intelligence** — benchmark pricing against other sneaker retailers
- **Deal aggregation** — feed `onSaleOnly` results into a deals feed

### Data source & limitations

Data comes directly from JD Sports UK's server-rendered pages (`jdsports.co.uk`) — no login, cookies, or paid proxy required. Category/search/brand listing pages embed a full JSON product payload per page (72 products); product detail pages carry standard `schema.org/Product` JSON-LD plus a stock endpoint for per-size availability.

- **Ratings/reviews** are not included: JD Sports loads its review widget via a third-party script that requires JS execution and isn't reliably reachable from a plain HTTP fetch — rather than fabricate a rating, the field is omitted entirely.
- **Kids category coverage** is narrower than Men/Women — JD Sports structures its Kids catalog differently (fewer sub-categories are exposed as distinct URLs). `footwear-trainers`, `footwear-football-boots`, `footwear-all`, `clothing-all`, `accessories-all`, `accessories-sale`, and `sale-all` are available for Kids; sub-categories like `footwear-classic-trainers` are not.
- **Currency** is always GBP, matching JD Sports UK.
- Fetching `sizes`/`availability` (via `size` filter or `fetchFullDetail`) makes one extra request per product — use a modest `maxItems` when enabling it on large runs.

### FAQ

**Do I need a JD Sports account or cookies?**  No — every field is publicly visible without logging in.

**Why do some products have no `wasPrice`?**  Only currently-discounted products carry a `wasPrice`; full-price products only have `price`.

**What sizes does the `size` filter use?**  Whatever JD Sports lists on the product page — UK shoe sizes (e.g. `9`, `9.5`) or clothing letter sizes (e.g. `M`, `L`), matched exactly.

**Can I get every image, not just the thumbnail?**  Yes — set `fetchFullDetail: true`, or use `mode: "url"` with specific product URLs, to get the full gallery in `images`.

**How current is the data?**  Live — every run fetches the current JD Sports site directly; there is no caching layer.

# Actor input Schema

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

What to fetch: search by keyword, browse a category, browse a brand, or fetch specific product URLs.

## `searchQuery` (type: `string`):

Free-text search, e.g. `air max`, `adidas samba`, `nike dunk low`.

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

Product category to browse. Combined with `gender` below (not every category exists for every gender -- Kids has a reduced set).

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

Brand to browse all products for.

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

Scopes `category` and `brand` modes (and hints `search` results) to Men, Women, or Kids. Leave unset for `brand` mode to browse all genders, or for `search` to search globally.

## `productUrls` (type: `array`):

Full jdsports.co.uk product page URLs, e.g. `https://www.jdsports.co.uk/product/black-adidas-originals-handball-spezial/16227358/`.

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

Sort order for search/category/brand listings.

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

Drop products priced below this (current price).

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

Drop products priced above this (current price).

## `onSaleOnly` (type: `boolean`):

Only emit products currently discounted.

## `colour` (type: `string`):

Only emit products of this colour.

## `brandFilter` (type: `string`):

Narrow `search` or `category` results to a single brand without switching to mode=brand.

## `genderFilter` (type: `string`):

Narrow `search` or `brand` results to one department after the fact.

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

Only emit products that have this UK size currently in stock (e.g. `9`, `7.5`, `M`, `L`). Requires an extra request per product to check live stock -- slower, use with a modest `maxItems`.

## `fetchFullDetail` (type: `boolean`):

For search/category/brand modes: fetch each product's full detail page (description, full image gallery, article code, per-size stock) instead of just listing-page fields. Slower -- one extra request per product.

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

Hard cap on emitted records.

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

JD Sports' listing/product/stock pages are reachable directly from Apify datacenter IPs; the free AUTO proxy group is used automatically as a fallback if a run hits rate limiting. No paid proxy group is required.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "air max",
  "category": "footwear-trainers",
  "brand": "nike",
  "productUrls": [],
  "sortBy": "recommended",
  "onSaleOnly": false,
  "fetchFullDetail": false,
  "maxItems": 24,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped JD Sports products.

# 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",
    "searchQuery": "air max",
    "category": "footwear-trainers",
    "brand": "nike",
    "productUrls": [],
    "sortBy": "recommended",
    "onSaleOnly": false,
    "fetchFullDetail": false,
    "maxItems": 24,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/jd-sports-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",
    "searchQuery": "air max",
    "category": "footwear-trainers",
    "brand": "nike",
    "productUrls": [],
    "sortBy": "recommended",
    "onSaleOnly": False,
    "fetchFullDetail": False,
    "maxItems": 24,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/jd-sports-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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",
  "searchQuery": "air max",
  "category": "footwear-trainers",
  "brand": "nike",
  "productUrls": [],
  "sortBy": "recommended",
  "onSaleOnly": false,
  "fetchFullDetail": false,
  "maxItems": 24,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/jd-sports-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/jd-sports-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JD Sports Scraper",
        "description": "Scrape JD Sports UK (jdsports.co.uk) -- search or browse sneakers, streetwear, and sportswear by category or brand. Get title, brand, price, sale price, colour, sizes in stock, images, and full product detail. No login required.",
        "version": "1.0",
        "x-build-id": "HhbwF9bb89rHVAHYt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~jd-sports-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-jd-sports-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~jd-sports-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-jd-sports-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~jd-sports-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-jd-sports-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "category",
                            "brand",
                            "url"
                        ],
                        "type": "string",
                        "description": "What to fetch: search by keyword, browse a category, browse a brand, or fetch specific product URLs.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text search, e.g. `air max`, `adidas samba`, `nike dunk low`.",
                        "default": "air max"
                    },
                    "category": {
                        "title": "Category (mode=category)",
                        "enum": [
                            "footwear-all",
                            "footwear-trainers",
                            "footwear-classic-trainers",
                            "footwear-running-shoes",
                            "footwear-hi-tops",
                            "footwear-boots-and-shoes",
                            "footwear-canvas-and-plimsolls",
                            "footwear-flip-flops-and-sandals",
                            "footwear-football-boots",
                            "footwear-trail-footwear",
                            "footwear-training-footwear",
                            "footwear-fitness-footwear",
                            "footwear-latest",
                            "footwear-sale",
                            "clothing-all",
                            "clothing-hoodies",
                            "clothing-jackets",
                            "clothing-tracksuits",
                            "clothing-track-pants",
                            "clothing-t-shirts",
                            "clothing-shorts",
                            "clothing-sweatshirts",
                            "clothing-polo-shirts",
                            "clothing-leggings",
                            "clothing-tops",
                            "clothing-latest",
                            "clothing-sale",
                            "accessories-all",
                            "accessories-caps",
                            "accessories-bags-and-gymsacks",
                            "accessories-socks",
                            "accessories-sale",
                            "sale-all"
                        ],
                        "type": "string",
                        "description": "Product category to browse. Combined with `gender` below (not every category exists for every gender -- Kids has a reduced set).",
                        "default": "footwear-trainers"
                    },
                    "brand": {
                        "title": "Brand (mode=brand)",
                        "enum": [
                            "adidas",
                            "nike",
                            "jordan",
                            "new-balance",
                            "asics",
                            "puma",
                            "reebok",
                            "converse",
                            "vans",
                            "fila",
                            "under-armour",
                            "the-north-face",
                            "berghaus",
                            "hoka",
                            "on-running",
                            "salomon",
                            "timberland",
                            "ugg",
                            "crocs",
                            "birkenstock",
                            "lacoste",
                            "champion",
                            "kappa",
                            "umbro",
                            "columbia",
                            "dc-shoes",
                            "kickers",
                            "montirex",
                            "mizuno",
                            "saucony",
                            "castore",
                            "boss",
                            "tommy-hilfiger",
                            "calvin-klein-underwear",
                            "polo-ralph-lauren",
                            "fred-perry",
                            "levis",
                            "havaianas",
                            "merrell",
                            "arcteryx",
                            "altra",
                            "speedo",
                            "new-era",
                            "eastpak"
                        ],
                        "type": "string",
                        "description": "Brand to browse all products for.",
                        "default": "nike"
                    },
                    "gender": {
                        "title": "Gender / department",
                        "enum": [
                            "men",
                            "women",
                            "kids"
                        ],
                        "type": "string",
                        "description": "Scopes `category` and `brand` modes (and hints `search` results) to Men, Women, or Kids. Leave unset for `brand` mode to browse all genders, or for `search` to search globally."
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=url)",
                        "type": "array",
                        "description": "Full jdsports.co.uk product page URLs, e.g. `https://www.jdsports.co.uk/product/black-adidas-originals-handball-spezial/16227358/`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "recommended",
                            "latest",
                            "name-a-z",
                            "name-z-a",
                            "price-low-high",
                            "price-high-low"
                        ],
                        "type": "string",
                        "description": "Sort order for search/category/brand listings.",
                        "default": "recommended"
                    },
                    "minPrice": {
                        "title": "Min price (GBP)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop products priced below this (current price)."
                    },
                    "maxPrice": {
                        "title": "Max price (GBP)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop products priced above this (current price)."
                    },
                    "onSaleOnly": {
                        "title": "Sale items only",
                        "type": "boolean",
                        "description": "Only emit products currently discounted.",
                        "default": false
                    },
                    "colour": {
                        "title": "Colour filter",
                        "enum": [
                            "beige",
                            "black",
                            "blue",
                            "brown",
                            "burgundy",
                            "cream",
                            "dark-blue",
                            "gold",
                            "green",
                            "grey",
                            "multi",
                            "multicolor",
                            "off-white",
                            "orange",
                            "pink",
                            "purple",
                            "red",
                            "silver",
                            "turquoise",
                            "white",
                            "yellow"
                        ],
                        "type": "string",
                        "description": "Only emit products of this colour."
                    },
                    "brandFilter": {
                        "title": "Brand filter (search/category modes)",
                        "enum": [
                            "adidas",
                            "nike",
                            "jordan",
                            "new-balance",
                            "asics",
                            "puma",
                            "reebok",
                            "converse",
                            "vans",
                            "fila",
                            "under-armour",
                            "the-north-face",
                            "berghaus",
                            "hoka",
                            "on-running",
                            "salomon",
                            "timberland",
                            "ugg",
                            "crocs",
                            "birkenstock",
                            "lacoste",
                            "champion",
                            "kappa",
                            "umbro",
                            "columbia",
                            "dc-shoes",
                            "kickers",
                            "montirex",
                            "mizuno",
                            "saucony",
                            "castore",
                            "boss",
                            "tommy-hilfiger",
                            "calvin-klein-underwear",
                            "polo-ralph-lauren",
                            "fred-perry",
                            "levis",
                            "havaianas",
                            "merrell",
                            "arcteryx",
                            "altra",
                            "speedo",
                            "new-era",
                            "eastpak"
                        ],
                        "type": "string",
                        "description": "Narrow `search` or `category` results to a single brand without switching to mode=brand."
                    },
                    "genderFilter": {
                        "title": "Gender filter (search/brand modes)",
                        "enum": [
                            "men",
                            "women",
                            "kids"
                        ],
                        "type": "string",
                        "description": "Narrow `search` or `brand` results to one department after the fact."
                    },
                    "size": {
                        "title": "Size in stock",
                        "type": "string",
                        "description": "Only emit products that have this UK size currently in stock (e.g. `9`, `7.5`, `M`, `L`). Requires an extra request per product to check live stock -- slower, use with a modest `maxItems`."
                    },
                    "fetchFullDetail": {
                        "title": "Fetch full product detail",
                        "type": "boolean",
                        "description": "For search/category/brand modes: fetch each product's full detail page (description, full image gallery, article code, per-size stock) instead of just listing-page fields. Slower -- one extra request per product.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 24
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "JD Sports' listing/product/stock pages are reachable directly from Apify datacenter IPs; the free AUTO proxy group is used automatically as a fallback if a run hits rate limiting. No paid proxy group is required.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
