# Nike Product Extractor (`kawsar/nike-product-extractor`) Actor

Nike Product Extractor pulls Nike product listings, prices, colors, and images from any search keyword or Nike URL, so you can track prices, spot new drops, and feed a product catalog without copy pasting.

- **URL**: https://apify.com/kawsar/nike-product-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Nike Product Extractor

Extract Nike product data at scale. Type a keyword like `air max`, `pegasus`, or `dunk low`, and this actor returns every matching product from Nike search results, with the product name, style code, colorway, current and original price, discount, images, and a direct link to each product page. You can also paste a full Nike search or category URL and pull that whole listing.

Built for price monitoring, release tracking, competitor research, catalog building, and SEO work. No login, no browser extension, no manual copy pasting.

### Table of contents

- [Why use this actor](#why-use-this-actor)
- [Features](#features)
- [How it works](#how-it-works)
- [Input](#input)
- [Output](#output)
- [Use cases](#use-cases)
- [Integrations and export](#integrations-and-export)
- [Running the actor](#running-the-actor)
- [Tips for better results](#tips-for-better-results)
- [FAQ](#faq)
- [Limitations](#limitations)
- [Support](#support)

### Why use this actor

Collecting Nike product data by hand is slow. Prices change, colorways sell out, and new models drop without warning. This actor turns any Nike search into a clean, structured dataset in seconds, so you can track what matters instead of clicking through pages.

- Search by keyword or by Nike URL
- Up to roughly 200 products from a single search, in one run
- Structured fields ready for a spreadsheet, database, or API
- Runs on a schedule so your data stays current
- No account, cookies, or manual setup required

### Features

| Feature | Description |
|---------|-------------|
| Keyword search | Pass one or more keywords and get every matching Nike product. |
| URL scraping | Paste a Nike search or category URL to extract that listing. |
| Full pricing data | Current price, original price, discount percentage, and an on-sale flag. |
| Rich product detail | Name, subtitle, style code, product type, colorway, and color label. |
| Product images | Square and portrait image URLs for each colorway. |
| Direct links | A clean link to every product detail page. |
| Batch input | Queue multiple searches and URLs in a single run. |
| Deduplication | Repeated products within a search are removed automatically. |
| Configurable limits | Control how many products to keep and the request timeout. |

### How it works

1. You provide search keywords, Nike URLs, or both.
2. For each keyword, the actor builds the matching Nike search page and loads it.
3. It reads the product data embedded in the page and shapes it into clean records.
4. Each product is saved to the dataset, ready to view, export, or pipe into another tool.

Every search runs independently, so if one keyword fails, the rest of the run still finishes.

### Input

Configure the run from the Apify Console UI, or pass a JSON input through the API. All fields are optional on their own, but you need at least one keyword or one URL.

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQueries` | array of text | `["air max"]` | Nike search keywords, one search per keyword. Example: `air max`, `pegasus`, `dunk low`. |
| `startUrls` | array of URLs | none | Optional full Nike search or category URLs, for example `https://www.nike.com/w/mens-shoes`. |
| `maxItems` | integer | `100` | Maximum number of products to collect per run. Range 1 to 1000. |
| `requestTimeoutSecs` | integer | `30` | Per-request timeout in seconds. Range 5 to 120. |

#### Example input

Search by keyword:

```json
{
    "searchQueries": ["air max", "pegasus"],
    "maxItems": 100
}
```

Scrape a specific Nike listing page:

```json
{
    "startUrls": [
        { "url": "https://www.nike.com/w/mens-shoes" }
    ],
    "maxItems": 200
}
```

Combine both:

```json
{
    "searchQueries": ["jordan 1"],
    "startUrls": [
        { "url": "https://www.nike.com/w/sale-3yaep" }
    ],
    "maxItems": 500
}
```

### Output

Results are stored in the run's dataset. Each item is one product colorway.

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | The keyword or URL this product came from. |
| `productName` | string | Product name, for example "Nike Air Max 95 Big Bubble". |
| `subtitle` | string | Product subtitle, for example "Men's Shoes". |
| `productCode` | string | Nike style code, for example `IM9605-002`. |
| `productType` | string | Product category, for example `FOOTWEAR` or `APPAREL`. |
| `colorway` | string | Full color description of the colorway. |
| `colorLabel` | string | Simple color label, for example "Grey". |
| `currency` | string | Currency code for the prices, for example `USD`. |
| `currentPrice` | number | Current selling price. |
| `fullPrice` | number | Original list price before any discount. |
| `discountPercentage` | number | Discount percentage, `0` when not on sale. |
| `isOnSale` | boolean | `true` when the current price is below the full price. |
| `imageUrl` | string | Square product image URL. |
| `portraitImageUrl` | string | Portrait product image URL. |
| `badgeLabel` | string | Marketing badge if present, for example "Just In". |
| `productUrl` | string | Direct link to the Nike product page. |
| `scrapedAt` | string | ISO timestamp of when the product was scraped. |

#### Example output item

```json
{
    "searchQuery": "air max",
    "productName": "Nike Air Max 95 Big Bubble",
    "subtitle": "Men's Shoes",
    "productCode": "IM9605-002",
    "productType": "FOOTWEAR",
    "colorway": "Smoke Grey/Anthracite/Black/Racer Blue",
    "colorLabel": "Grey",
    "currency": "USD",
    "currentPrice": 190,
    "fullPrice": 190,
    "discountPercentage": 0,
    "isOnSale": false,
    "imageUrl": "https://static.nike.com/a/images/.../NIKE+AIR+MAX+95+BIG+BUBBLE.png",
    "portraitImageUrl": "https://static.nike.com/a/images/.../NIKE+AIR+MAX+95+BIG+BUBBLE.png",
    "badgeLabel": null,
    "productUrl": "https://www.nike.com/t/air-max-95-big-bubble-mens-shoes-2xNsHz6W/IM9605-002",
    "scrapedAt": "2026-08-25T10:24:01.902977+00:00"
}
```

### Use cases

- **Price monitoring.** Run the actor on a schedule and watch how prices and discounts move across a model line.
- **Release and restock tracking.** Catch new drops and returning colorways as soon as they show up in search.
- **Competitor and resale research.** Pull full catalogs to compare against your own pricing or the resale market.
- **Product catalog building.** Feed a store, affiliate site, or price comparison tool with fresh product data.
- **SEO and market research.** Gather names, colorways, and prices for keyword and trend analysis.
- **Deal and coupon sites.** Surface products that are on sale and rank them by discount.

### Integrations and export

Everything the actor collects can leave Apify in the format you need.

- Export to JSON, CSV, Excel, XML, or RSS from the dataset tab
- Send results to Google Sheets, Airtable, or a database
- Trigger webhooks when a run finishes
- Connect to Make, Zapier, and other automation tools
- Pull results programmatically through the Apify API and client libraries

Fetch the dataset through the API:

```
GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json
```

### Running the actor

#### From the Apify Console

1. Open the actor and go to the Input tab.
2. Add one or more keywords under `searchQueries`, or paste Nike URLs under `startUrls`.
3. Set `maxItems` if you want a smaller or larger result set.
4. Click Start and watch the log. Results appear in the Dataset tab.

#### On a schedule

Use the Schedules tab to run the actor every hour, day, or week. This keeps a rolling record of prices and new products with no manual work.

#### Through the API

Start a run and get results in one call using the Apify API or one of the official clients for Python and JavaScript. See the API tab of the actor for ready to copy snippets.

### Tips for better results

- Use specific keywords like `air max 90` or `pegasus 41` to narrow the results.
- Use broad keywords like `running` or `sale` to pull large catalogs.
- One keyword can return around 200 products, so a small `maxItems` is often enough.
- To scrape a full category, copy the URL straight from your browser after filtering on nike.com.
- Schedule short, frequent runs rather than one huge run if you are tracking price changes over time.

### FAQ

**Do I need a Nike account?**
No. The actor works with public Nike search and product pages.

**How many products can I get from one search?**
A single keyword search returns up to roughly 200 products in one run. Set `maxItems` to keep fewer if you want.

**Can I scrape a specific category or sale page?**
Yes. Paste the full Nike URL into `startUrls` and the actor reads that page.

**What regions and currencies are supported?**
The actor reads the prices and currency shown on the Nike pages it loads, which follow Nike's default US storefront.

**Can I get individual sizes or stock levels?**
This actor focuses on product listing data. Size and inventory detail per product is not included.

**Is my input private?**
Yes. Runs and datasets are tied to your Apify account and are not shared.

### Limitations

- Results reflect what Nike shows on its public search and category pages at run time.
- A single keyword search is capped at the products Nike returns for that search, around 200.
- Per-product size and stock data is out of scope for this actor.
- Very broad keywords may return unrelated products. Refine the keyword for cleaner results.

### Support

Found a bug or want a new field added? Open an issue on the actor page or contact the developer through Apify. Feature requests are welcome.

# Actor input Schema

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

Nike search keywords to look up, one product search per keyword. For example: air max, pegasus, dunk low.

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

Optional full Nike search or category URLs to extract products from, for example https://www.nike.com/w/mens-shoes. Use this when you already have a Nike listing page in mind.

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

Maximum number of products to collect per run.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchQueries": [
    "air max",
    "pegasus"
  ],
  "startUrls": [
    {
      "url": "https://www.nike.com/w?q=air%20max&vst=air%20max"
    }
  ],
  "maxItems": 100,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

Extract Nike product listings, prices, colors, and images from any Nike search keyword or listing URL.

# 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": [
        "air max"
    ],
    "startUrls": [
        {
            "url": "https://www.nike.com/w?q=air%20max&vst=air%20max"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/nike-product-extractor").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": ["air max"],
    "startUrls": [{ "url": "https://www.nike.com/w?q=air%20max&vst=air%20max" }],
}

# Run the Actor and wait for it to finish
run = client.actor("kawsar/nike-product-extractor").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": [
    "air max"
  ],
  "startUrls": [
    {
      "url": "https://www.nike.com/w?q=air%20max&vst=air%20max"
    }
  ]
}' |
apify call kawsar/nike-product-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kawsar/nike-product-extractor"
        }
    }
}

```

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/fxHvaaMDIRFG0yANn/builds/qWPJ4KdJQzUZc1BkI/openapi.json