# Nike Scraper – Products, Prices, Sizes & Stock (`rl1987/nike-api-scraper`) Actor

Scrape Nike.com sneakers, apparel and accessories — Air Force 1, Air Jordan, Air Max, Dunk, Pegasus, Nike Tech, ACG. One row per colorway: title, current and full price, discount, every size with GTIN and live per-size stock, images, product URL. No Nike account or API key needed.

- **URL**: https://apify.com/rl1987/nike-api-scraper.md
- **Developed by:** [R.L.](https://apify.com/rl1987) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 13 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.69 / 1,000 product (listing)s

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Nike Scraper — Scrape Nike.com Products, Prices, Sizes & Stock

**Nike Scraper** extracts product data from **Nike.com** at scale — listings, full product
details, prices, discounts, sizes, GTINs, images and **live stock availability** — and
exports it to **JSON, CSV, Excel, or an API**. It reads Nike's own product API directly, so
it's **fast, reliable, and complete** — no flaky HTML parsing, no headless browser.

Point it at a **category page, a search, a product URL, or a style code**, and get clean,
structured Nike product data in seconds. Great for **price monitoring, competitor research,
sneaker‑release tracking, dropshipping, market analysis, and building product catalogs.**

> Scrape Nike sneakers, apparel and accessories — Air Force 1, Air Jordan, Air Max, Dunk,
> Pegasus, Nike ACG and the entire Nike catalog — in any Nike marketplace and language.

***

### Why use this Nike Scraper?

- **No code required** — paste a Nike URL, click **Start**, download your data.
- **Fast & accurate** — pulls structured JSON from Nike's product API, not rendered HTML.
- **Rich data** — names, prices, discounts, every size + GTIN, per‑size stock, all images.
- **Live inventory** — see exactly which sizes are in stock right now.
- **Full pagination** — scrapes an entire category or search to the last product.
- **Any market** — choose the country/marketplace and language (US, UK, DE, …).
- **Transparent pay-per-event pricing** — you are charged for what a run delivers; the **Pricing** tab lists the events and their current prices.
- **Export anywhere** — JSON, CSV, Excel, XML, or pull it live via the Apify API.

***

### What can you do with Nike product data?

- **Price monitoring & repricing** — track Nike prices and discounts over time.
- **Competitor & market analysis** — benchmark assortment, pricing and availability.
- **Sneaker reselling & drop tracking** — catch launches, restocks and sold‑out sizes.
- **Dropshipping & catalog building** — import Nike products into your store.
- **Inventory/stock alerts** — monitor when specific sizes come back in stock.
- **Data science & trend research** — build datasets of Nike footwear and apparel.

***

### What data does the Nike Scraper extract?

**Listing (PLP) data** — product name, subtitle, color, current price, full price, discount,
employee price, currency, product type, "Just In"/sale badges, image, and product URL.

**Product detail (PDP) data** — everything above **plus** full description, brand, gender,
style code, **every size with its GTIN/barcode and live stock level**, color swatches (with
hex), gallery images, size‑chart URL, and launch/release info.

Each row is also stamped with `country`, `language`, `source`, `scrapedAt`, and the
originating `categoryName`.

***

### Which Nike products and lines can it scrape?

Anything that appears on a Nike.com listing or search page — footwear, apparel and
equipment. Give it a free-text search term, a category URL, a product URL or a bare style
code. Verified example inputs:

| What you want | Input to use |
| --- | --- |
| Air Force 1 | `searchTerms: ["air force 1"]` |
| Air Jordan (1, 4, 5, …) | `searchTerms: ["air jordan 1"]` |
| Air Max (90, 95, 270, …) | `searchTerms: ["air max 90"]` |
| Dunk / Dunk Low / SB Dunk | `searchTerms: ["dunk low"]` |
| Pegasus, Vomero, Structure (running) | `searchTerms: ["pegasus"]` |
| Nike Tech Fleece (apparel) | `searchTerms: ["tech fleece"]` |
| Nike ACG (outdoor) | `searchTerms: ["acg"]` |
| A whole category, paginated to the end | `categoryUrls: [{ "url": "https://www.nike.com/w/mens-shoes-nik1zy7ok" }]` |
| A Nike search-results page | `categoryUrls: [{ "url": "https://www.nike.com/w?q=air%20force%201" }]` |
| One exact colorway | `styleColors: ["CW2288-111"]` |

Every row carries the `categoryName` it came from (a search reports `Search: air force 1`),
so you can tell which query produced which product.

***

### How to scrape Nike.com (3 steps)

1. **Add an input.** Paste a Nike **category URL** (e.g. `https://www.nike.com/w/mens-shoes-nik1zy7ok`),
   a **search URL** (`https://www.nike.com/w?q=air%20force%201`), a **search term**, a **product
   URL**, or a **style code** (e.g. `CW2288-111`).
2. **Pick your options** — turn on `fetchProductDetails` for full PDP data, set a country, or
   cap the number of products. Defaults work out of the box.
3. **Run & export** — click **Start**, then download the dataset as JSON/CSV/Excel or fetch it
   through the API.

***

### What input does it take?

Supply **at least one** source: `categoryUrls`, `searchTerms`, `productUrls`, or `styleColors`.
Everything else is optional.

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `categoryUrls` | array of `{url}` | – | Nike **category or search** URLs (PLP). Each is paginated to the end. |
| `searchTerms` | array of string | – | Free‑text Nike searches, e.g. `"air force 1"`. |
| `productUrls` | array of `{url}` | – | Nike product (PDP) URLs — style code is read from the URL. |
| `styleColors` | array of string | – | Bare Nike style codes, e.g. `CW2288-111`. |
| `fetchProductDetails` | boolean | `false` | Also fetch full PDP detail for each listing product. |
| `fetchSizeAvailability` | boolean | `false` | Attach live per‑size stock to listing products. |
| `maxProductsPerCategory` | integer | `0` | Cap products per category/search (`0` = all). |
| `maxItems` | integer | `0` | Global cap on output rows (`0` = no cap). |
| `pageSize` | string | `24` | Listing page size — `24`, `50`, or `100`. |
| `country` | string | `US` | Marketplace — affects price, currency and stock. |
| `language` | string | `en` | Language for product copy. |
| `detailConcurrency` | integer | `5` | Parallel detail/availability requests. |
| `proxyConfiguration` | object | Residential | Proxy settings (RESIDENTIAL recommended). |

#### Example input

```jsonc
{
  "categoryUrls": [
    { "url": "https://www.nike.com/w/mens-shoes-nik1zy7ok" }
  ],
  "searchTerms": ["air force 1"],
  "productUrls": [
    { "url": "https://www.nike.com/t/air-force-1-07-mens-shoes-jBrhdX/CW2288-111" }
  ],
  "styleColors": ["DD0587-008"],
  "fetchProductDetails": true,
  "maxProductsPerCategory": 200,
  "pageSize": "50",
  "country": "US",
  "language": "en",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

***

### What does each row contain?

#### Listing (PLP) product

```jsonc
{
  "styleColor": "DD0587-008",
  "groupKey": "ZXK65P",
  "globalProductId": "4881385b-…",
  "internalPid": "1015928488",
  "merchProductId": "74f6059c-…",
  "title": "Air Jordan 5 \"Black Carolina\"",
  "subtitle": "Men's Shoes",
  "colorDescription": "Black/White/University Blue",
  "colorLabel": "Black",
  "currency": "USD",
  "currentPrice": 220,
  "fullPrice": 220,
  "employeePrice": 132,
  "discountPercentage": 0,
  "isOnSale": false,
  "productType": "FOOTWEAR",
  "productSubType": "STANDARD",
  "badgeLabel": "Just In",
  "featuredAttributes": ["JUST_IN"],
  "imageUrl": "https://static.nike.com/…/squarish.png",
  "url": "https://www.nike.com/t/air-jordan-5-black-carolina-mens-shoes-ZXK65P/DD0587-008",
  "categoryUrl": "https://www.nike.com/w/mens-shoes-nik1zy7ok"
}
```

#### Product detail (PDP) product — adds

```jsonc
{
  "styleColor": "CW2288-111",
  "styleCode": "CW2288",
  "colorCode": "111",
  "brand": "Nike",
  "fullTitle": "Nike Air Force 1 '07 Men's Shoes",
  "descriptionHeading": "Benefits",
  "description": "Comfortable, durable and timeless — …",
  "genders": ["MEN"],
  "msrp": 115,
  "discounted": false,
  "inStock": true,
  "availableSizes": ["6", "6.5", "7", "…"],
  "colors": [{ "type": "PRIMARY", "name": "White", "hex": "F0F4FF" }],
  "sizes": [
    {
      "size": "8",
      "localizedSize": "M 8 / W 9.5",
      "gtin": "00194501093...",
      "skuId": "…",
      "stockKeepingUnitId": "…",
      "available": true,
      "level": "HIGH"
    }
  ],
  "specifications": {
    "bestFor": [], "widths": [], "manufacturingCountriesOfOrigin": [],
    "athletes": ["CeeDee Lamb"], "techSpec": ""
  },
  "heroImageUrl": "https://secure-images.nike.com/is/image/DotCom/CW2288_111",
  "galleryImageUrls": ["…"],
  "sizeChartUrl": "https://www.nike.com/size-fit/unisex-footwear-mens-based",
  "launch": { "commerceStartDate": "…", "hardLaunch": false, "preOrder": false, "publishType": "FLOW" },
  "slug": "air-force-1-07-mens-shoes-jBrhbr"
}
```

***

### How much does it cost?

The current price of every event is on the **Pricing** tab of this Actor's page in Apify Store. That tab is generated from the Actor's own pricing record, so it is always current, and your plan's rung is applied automatically. A figure repeated here would be a second copy that drifts out of date.

You can cap what any single run may spend with **Max total charge**.

### How do I run it from my own code?

Run it from anywhere and get the results back as JSON:

```bash
curl -X POST "https://api.apify.com/v2/acts/rl1987~nike-api-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{ "categoryUrls": [{ "url": "https://www.nike.com/w/mens-shoes-nik1zy7ok" }], "maxProductsPerCategory": 100 }'
```

You can also run it on a **schedule** (e.g. daily price/stock checks) and integrate with
**Make, Zapier, n8n, Google Sheets**, or webhooks — all from the Apify platform.

***

### Can I use it from n8n?

Use the [`n8n-nodes-nike-scraper`](https://www.npmjs.com/package/n8n-nodes-nike-scraper) community node ([source](https://github.com/rl1987/n8n-nodes-nike-scraper)) to run this Actor directly from an n8n workflow.

### FAQ

**Is it legal to scrape Nike?**
Scraping publicly available data is generally permitted, but you are responsible for complying
with Nike's Terms of Service and applicable laws (including copyright and data‑protection
rules) in your jurisdiction. Use the data responsibly.

**Do I need a Nike account, an API key or any code?**
No. The endpoints it reads are anonymous — no Nike login, no cookie, no API key of any kind.
Fill in the visual input form and click Start; developers can drive the same run through the
Apify API or SDKs instead.

**Can I scrape other Nike countries and currencies?**
Yes — set `country` and `language` (e.g. `GB`/`en`, `DE`/`de`). Prices, currency and stock
follow the chosen marketplace, and the proxy exit IP is pinned to that country by default.

**Does it return sizes and stock availability?**
Yes. PDP rows include every size with its GTIN and a live stock level. For listing products,
enable `fetchSizeAvailability` to attach live per‑size stock.

**Can I run it on a schedule?**
Yes. Schedule it on Apify (e.g. a daily price and stock check on the same category or style
codes) and push the results on via webhooks or the Make, Zapier, n8n and Google Sheets
integrations.

**How do I keep the cost predictable?**
Three limits: `maxItems` caps total rows across the whole run, `maxProductsPerCategory` caps
each category or search, and the Actor stops billable work as soon as the run's maximum charge
is reached. Leaving `fetchProductDetails` off keeps every row at the cheaper listing rate.

**What happens if Nike blocks a request?**
Each call is retried up to five times with exponential backoff on a fresh residential exit IP.
If a product's detail or availability lookup still fails it is logged and skipped — you get the
listing row rather than a failed run.

**What about product reviews?**
Reviews (ratings/counts) are out of scope — Nike serves those from a separate service that
isn't part of the product/catalog API.

**Which proxies should I use?**
Residential proxies. Nike returns HTTP 403 to datacenter IPs, especially on the product detail
endpoint, so the Actor defaults to Apify **Residential** proxies.

***

### What do the Nike terms in the output mean?

- **styleColor** — Nike's identifier for one colorway, `<styleCode>-<colorCode>`, e.g.
  `CW2288-111`. It is the key the product detail lookup is built on.
- **Colorway** — one color variant of a style. `CW2288-111` (white) and `CW2288-001` (black)
  are two colorways of the same Air Force 1 '07 style, and **each is its own row**.
- **PLP / PDP** — product listing page (a category or search grid) and product detail page.
  PLP rows are the cheap card-level data; PDP rows add description, sizes, GTINs and stock.
- **groupKey** — the rollup key Nike uses to group a style's colorways; it is what the live
  availability lookup is keyed by.
- **GTIN** — the global barcode number of one size of one colorway, useful for matching Nike
  products to marketplace listings.
- **level** — Nike's coarse stock level for a size (e.g. `HIGH`), alongside the boolean
  `available`.

***

### How does it work?

The scraper talks to Nike's own consumer product API (`api.nike.com`) — the same endpoints
that power Nike.com — using three calls: the **product wall** for listings/search, the
**product feed** for full detail (sizes, GTINs, stock, images), and the **availability**
endpoint for live per‑size stock. It paginates automatically, streams results to the dataset
with bounded memory, and rotates residential proxy IPs for reliability.

***

### Good to know

- One Nike "style" can have several colorways — **each colorway is its own row.**
- `pageSize` must be `24`, `50`, or `100`.
- Listing rows don't include size stock unless you enable `fetchSizeAvailability` or
  `fetchProductDetails`; **PDP rows always include per‑size stock.**
- Built for scale: low, flat memory usage and automatic residential‑proxy rotation.

***

### Sneaker & streetwear resale toolkit

Part of the **Sneaker & streetwear resale toolkit** — resale-market pricing and product data across the major sneaker/streetwear marketplaces and brands:

- [StockX API Scraper](https://apify.com/rl1987/stockx-api-scraper) — Product listings, market data, and pricing from StockX.
- [GOAT API Scraper](https://apify.com/rl1987/goat-api-scraper) — Scrapes GOAT.com product listings by search query or category.
- [Supreme API Scraper](https://apify.com/rl1987/supreme-api-scraper) — Supreme catalogue: categories, full product detail, every colour/size variant.
- [Puma API Scraper](https://apify.com/rl1987/puma-api-scraper) — Scrapes PUMA.com product listing and detail via mobile app GraphQL API.

### Found this useful?

If this actor helped you, please **review the actor** — your feedback helps others discover it
and helps us keep improving it. A quick rating goes a long way!

***

*Not affiliated with, endorsed by, or sponsored by Nike, Inc. "Nike", "Air Force 1", "Air
Jordan", "Air Max" and related marks are trademarks of their respective owners and are used
here for descriptive purposes only.*

# Actor input Schema

## `categoryUrls` (type: `array`):

Nike listing pages to scrape — paginated through fully via the product wall API. Accepts BOTH:
• Category URLs, e.g. https://www.nike.com/w/mens-shoes-nik1zy7ok
• Search-results URLs, e.g. https://www.nike.com/w?q=air%20force%201 (the search query is auto-detected from the ?q= parameter).

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

Free-text search queries to scrape (equivalent to searching on nike.com). Example: "air force 1".

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

Individual product pages to fetch full detail for, e.g. https://www.nike.com/t/air-force-1-07-mens-shoes-jBrhdX/CW2288-111 . The styleColor is taken from the last path segment.

## `styleColors` (type: `array`):

Bare Nike styleColor codes to fetch full detail for, e.g. CW2288-111. A styleColor is <styleCode>-<colorCode>.

## `fetchProductDetails` (type: `boolean`):

For every product found on a listing/search, also fetch the full PDP detail (description, all sizes, GTINs, per-size stock, gallery images). Much slower — one extra API call per product. Supersedes "Fetch live per-size availability", because a detail record already includes per-size stock.

## `fetchSizeAvailability` (type: `boolean`):

Attach live per-size stock to listing rows — the in-stock flag, the list of available sizes, and a sizes array carrying each size's availability. One extra API call per product. Ignored when "Fetch full product details" is on: a detail record already carries all three of those fields from the product feed, so turning both on makes no extra calls and bills no extra events.

## `maxProductsPerCategory` (type: `integer`):

Cap how many product groupings to scrape per category/search (0 = no limit, scrape all pages).

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

Hard cap on total records pushed to the dataset across all inputs (0 = no limit).

## `pageSize` (type: `string`):

Products per listing API page. Nike only allows 24, 50 or 100.

## `country` (type: `string`):

Two-letter ISO marketplace code, e.g. US, GB, KR (affects prices, currency, availability).

## `language` (type: `string`):

Two-letter language code for product copy.

## `detailConcurrency` (type: `integer`):

How many detail/availability API calls to run in parallel.

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

Proxy settings. RESIDENTIAL proxies are strongly recommended — Nike returns HTTP 403 to datacenter IPs, especially on the product detail endpoint.

## Actor input object example

```json
{
  "categoryUrls": [
    {
      "url": "https://www.nike.com/w/mens-shoes-nik1zy7ok"
    }
  ],
  "searchTerms": [],
  "productUrls": [],
  "styleColors": [],
  "fetchProductDetails": false,
  "fetchSizeAvailability": false,
  "maxProductsPerCategory": 0,
  "maxItems": 0,
  "pageSize": "24",
  "country": "US",
  "language": "en",
  "detailConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "categoryUrls": [
        {
            "url": "https://www.nike.com/w/mens-shoes-nik1zy7ok"
        }
    ],
    "searchTerms": [],
    "productUrls": [],
    "styleColors": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("rl1987/nike-api-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 = {
    "categoryUrls": [{ "url": "https://www.nike.com/w/mens-shoes-nik1zy7ok" }],
    "searchTerms": [],
    "productUrls": [],
    "styleColors": [],
}

# Run the Actor and wait for it to finish
run = client.actor("rl1987/nike-api-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 '{
  "categoryUrls": [
    {
      "url": "https://www.nike.com/w/mens-shoes-nik1zy7ok"
    }
  ],
  "searchTerms": [],
  "productUrls": [],
  "styleColors": []
}' |
apify call rl1987/nike-api-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rl1987/nike-api-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/XheLXV7t6YLMYUiza/builds/KGUdDrelKU5IuTYI1/openapi.json