# Nike Scraper (`scraptivo/nike-scraper`) Actor

Nike.com product listings from search queries or category URLs across 20+ marketplaces, with optional size availability, ratings, and customer reviews.

- **URL**: https://apify.com/scraptivo/nike-scraper.md
- **Developed by:** [Scraptivo](https://apify.com/scraptivo) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.97 / 1,000 product scrapeds

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** collects product listings from [Nike.com](https://www.nike.com) and turns them into structured data for competitive research, e-commerce intelligence, and review analytics. Provide search queries or category URLs across 20+ marketplaces, then export titles, style codes, prices, discounts, colors, and images — with optional size availability, rating summaries, and customer reviews — to JSON, CSV, Excel, or your integration. Use it to monitor pricing, compare assortment, and analyze fit and comfort feedback. Pricing starts at **$1.00 per 1,000 products**, with optional details and reviews billed separately.

### What can you automate with Nike Scraper?

- **Build product catalogs** — from search terms or category URLs across 20+ Nike marketplaces.
- **Monitor prices and discounts** — capture current price, initial price, and discount percentage per SKU.
- **Track size availability** — enable product details for sizes, GTINs, and stock levels in one object.
- **Collect customer reviews** — attach title, text, rating, username, and fit/comfort dimensions to each product.
- **Apply Nike facet filters** — use `attributeId` values discovered on the first listing page.
- **Export structured data** — feed pricing and merchandising tools, dashboards, and automated pipelines.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Competitive intelligence teams | Comparing Nike pricing, badges, and assortment across categories. |
| E-commerce and merchandising teams | Feeding product and review data into pricing and merchandising tools. |
| Market researchers | Analyzing product lines and pricing across multiple country stores. |
| Review analysts | Aggregating fit, comfort, and recommendation feedback at scale. |

### What data can you collect from Nike.com?

| Data group | Example fields | How it helps |
|---|---|---|
| Product identity | `title`, `subtitle`, `productCode`, `styleCode`, `url` | Identify and deduplicate records with the stable `styleCode`. |
| Pricing | `currentPrice`, `initialPrice`, `discountPercentage`, `currency` | Track live price and markdowns. |
| Color and media | `colorLabel`, `colorHex`, `colorDescription`, `imageUrl` | Preview product and colorway. |
| Badges | `badgeLabel`, `featuredAttributes` | Spot "Just In" or sustainable-material flags. |
| Availability | `details` with sizes, GTINs, `availableSizeCount`, rating summaries | Enrich records when product details are enabled. |
| Reviews | `reviews` list with rating, text, username, date, and dimensions | Analyze feedback when reviews are enabled. |
| Provenance | `marketplace`, `language`, `seed` | Trace the country store and source query or URL. |

The `details` object and `reviews` list appear only when **Include Product Details** and **Include Reviews** are enabled respectively. Listing-level data is always returned.

### How to use Nike Scraper

1. Open the [Nike Scraper](https://apify.com/scraptivo/nike-scraper) on Apify.
2. Enter `searchQueries` and/or Nike category (`/w/`) or product (`/t/`) URLs in `startUrls`.
3. Choose a `marketplace` and `language`, and optionally add `filters`.
4. Optionally enable **Include Product Details** and **Include Reviews**, and cap reviews with `maxReviewsPerProduct`.
5. Run the Actor and export the dataset to JSON, CSV, or Excel, or connect it to your workflow.

```json
{
    "searchQueries": ["volleyball"],
    "marketplace": "DE",
    "language": "de",
    "includeProductDetails": true,
    "includeReviews": true,
    "maxReviewsPerProduct": 10,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

### Example workflow

#### Monitor a product line's pricing across marketplaces

1. Schedule a daily or weekly run with your `searchQueries` and a fixed `marketplace`.
2. Compare `currentPrice`, `initialPrice`, and `discountPercentage` over time for each `styleCode`.
3. Enable **Include Product Details** periodically to capture size availability and GTINs.
4. Deduplicate on `styleCode`, then push changes to your pricing dashboard.

### Automate and integrate your results

- **Schedules** — set daily or weekly runs per query and marketplace for price and assortment monitoring.
- **Webhooks** — trigger a webhook on run completion to push fresh products into your CRM, Google Sheets, or pricing tool.
- **Exports and API** — download JSON, CSV, or Excel from the Console, or call the Actor from the API. One cURL example:

```shell
curl "https://api.apify.com/v2/acts/scraptivo/nike-scraper/runs?token=YOUR-APIFY-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["volleyball"],
    "marketplace": "DE",
    "language": "de",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
  }'
```

- **Deduplication** — use the stable `styleCode` (or `productCode`) as the key when merging results across runs.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---:|---|---|---|
| `searchQueries` | Array of strings | No\* | — | Nike search terms (e.g. "volleyball", "air max"). |
| `startUrls` | Array of URLs | No\* | — | Nike category (`/w/`) or product (`/t/`) URLs. |
| `filters` | Array of objects | No | — | Nike facet filters using `attributeId` from the `available-filters` key-value store record. |
| `marketplace` | String | No | `DE` | Nike country code (DE, US, GB, FR, and 17 more). |
| `language` | String | No | `de` | Store language code for the selected marketplace. |
| `includeProductDetails` | Boolean | No | `false` | Fetch size availability and rating summary per product. Charged as `product-details`. |
| `includeReviews` | Boolean | No | `false` | Fetch individual reviews. Charged as `review` per review. |
| `maxReviewsPerProduct` | Integer | No | `0` | Maximum reviews per product when reviews are enabled (`0` = all). |
| `detailConcurrency` | Integer | No | `10` | Parallel workers for details and reviews (1–50). |
| `maxItems` | Integer | No | `0` | Maximum product records (`0` = unlimited). |
| `proxyConfiguration` | Proxy object | No | Residential Apify proxy | Proxy settings. Residential proxies are used by default. |

\* Provide at least one `searchQueries` entry or `startUrls` entry.

### Output example

Each dataset item is one product. With details and reviews enabled, a record looks like this:

```json
{
    "title": "Nike Volleyball Hoodie",
    "subtitle": "Men's Fleece Pullover",
    "productCode": "DV1234-010",
    "styleCode": "DV1234-010",
    "colorLabel": "Black",
    "colorHex": "#111111",
    "currency": "EUR",
    "currentPrice": 69.99,
    "initialPrice": 99.99,
    "discountPercentage": 30,
    "imageUrl": "https://static.nike.com/example.jpg",
    "url": "https://www.nike.com/de/t/volleyball-hoodie-DV1234-010",
    "badgeLabel": "Just In",
    "featuredAttributes": ["Sustainable Materials"],
    "marketplace": "DE",
    "language": "de",
    "seed": "volleyball",
    "reviewCount": 128,
    "details": {
        "sizes": ["S", "M", "L", "XL"],
        "gtinAvailability": [{ "size": "M", "gtin": "19600000000000" }]
    },
    "reviews": [
        { "title": "Great fit", "rating": 5, "text": "True to size and comfortable.", "username": "runner42", "dateCreated": "2026-08-01" }
    ]
}
```

### How much does it cost to scrape Nike.com?

The Actor uses pay-per-event pricing. Platform usage is not charged separately:

| Event | Price (per 1,000) |
|---|---|
| `product` — each product listing row | **$1.00** |
| `product-details` — each product with size availability and rating summary | **$1.50** |
| `review` — each individual review embedded in a product | **$1.50** |

Apify plan discounts apply automatically. For the `product` event: Bronze **$0.99**, Silver **$0.98**, Gold **$0.97** per 1,000. For `product-details` and `review`: Bronze **$1.40**, Silver **$1.30**, Gold **$1.20** per 1,000. Listing-only runs cost just **$1.00 per 1,000 products**.

### Reliability and responsible use

- **Proxy requirement** — the Actor defaults to the Apify residential proxy, which is recommended for consistent Nike results.
- **Conditional fields** — `details` and `reviews` appear only when their toggles are enabled; some fields are nullable on the platform.
- **Public data** — the Actor collects publicly visible product and review information from Nike.com.
- **Responsible use** — only use the data in ways that comply with Nike.com's terms of service and applicable law.

### Frequently asked questions

#### Can I scrape Nike.com by keyword and by category URL?

Yes. Use `searchQueries` for search terms or `startUrls` for Nike category (`/w/`) and product (`/t/`) URLs. You can combine both.

#### Can I schedule the Nike Scraper to run automatically?

Yes. Use the **Scheduler** tab in Apify Console to run daily or weekly per query and marketplace.

#### What counts as one result?

A product row counts as one `product` event ($1.00 per 1,000). Enabling details adds a `product-details` event per product, and each review adds a `review` event.

#### Why are some fields empty?

The `details` and `reviews` fields appear only when their toggles are enabled. Nike also leaves some fields unset for certain products.

#### How do I avoid duplicate records?

Dedupe on the stable `styleCode` (or `productCode`) when merging results across runs.

#### Do I need a proxy?

The Actor works out of the box with the default Apify residential proxy, which is recommended for consistent results.

### Related Scraptivo automations

- **[H\&M Scraper](https://apify.com/scraptivo/h-and-m-scraper)** — collect H\&M product catalogs with pricing and composition details.
- **[Walmart Scraper](https://apify.com/scraptivo/walmart-scraper)** — collect Walmart product listings with optional details and reviews.
- **[Alibaba Scraper](https://apify.com/scraptivo/alibaba-scraper)** — collect Alibaba.com product listings with supplier and review data.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, sample URL, required fields, and expected volume so we can assess the request.

# Actor input Schema

## `searchQueries` (type: `array`):

Nike search terms to scrape (e.g. volleyball, air max). Use either searchQueries or startUrls.

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

Nike category (/w/) or product (/t/) URLs. Use either searchQueries or startUrls.

## `filters` (type: `array`):

Nike facet filters to apply. Each item needs an attributeId from the available-filters key-value store record written on the first listing page. Example: {"attributeId": "0f64ecc7-d624-4e91-b171-b83a03dd8550", "label": "Herren"}.

## `marketplace` (type: `string`):

Nike marketplace country code

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

Nike language code for the selected marketplace

## `includeProductDetails` (type: `boolean`):

Fetch size availability and rating summary per product. Charged as product-details events.

## `includeReviews` (type: `boolean`):

Fetch individual product reviews. Charged as review events (one per review).

## `maxReviewsPerProduct` (type: `integer`):

Maximum reviews to fetch per product when includeReviews is enabled (0 = all reviews).

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

Number of parallel workers for product details and reviews (proxy rotates per request).

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

Maximum number of product listing records to scrape (0 = unlimited). Does not cap optional details/reviews for products already discovered.

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

Proxy settings for anti-bot protection

## Actor input object example

```json
{
  "searchQueries": [
    "volleyball"
  ],
  "startUrls": [
    {
      "url": "https://www.nike.com/de/w/herren-schuhe-nik1zy7ok"
    }
  ],
  "filters": [],
  "marketplace": "DE",
  "language": "de",
  "includeProductDetails": false,
  "includeReviews": false,
  "maxReviewsPerProduct": 0,
  "detailConcurrency": 10,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Scraped Nike products, details, and reviews

## `runStats` (type: `string`):

Aggregate scrape statistics for this run

## `availableFilters` (type: `string`):

Facet filters discovered on the first listing page

# 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 = {
    "searchQueries": [
        "volleyball"
    ],
    "startUrls": [
        {
            "url": "https://www.nike.com/de/w/herren-schuhe-nik1zy7ok"
        }
    ],
    "filters": [],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/nike-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 = {
    "searchQueries": ["volleyball"],
    "startUrls": [{ "url": "https://www.nike.com/de/w/herren-schuhe-nik1zy7ok" }],
    "filters": [],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scraptivo/nike-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 '{
  "searchQueries": [
    "volleyball"
  ],
  "startUrls": [
    {
      "url": "https://www.nike.com/de/w/herren-schuhe-nik1zy7ok"
    }
  ],
  "filters": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraptivo/nike-scraper --silent --output-dataset

```

## MCP server setup

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