# Adidas Product Scraper (`scraptivo/adidas-scraper`) Actor

Collect Adidas product listings and optional full product details from any supported Adidas country storefront. Enter search terms, category URLs, or product IDs and export prices, images, sizes, availability, and descriptions.

- **URL**: https://apify.com/scraptivo/adidas-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 $1.20 / 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

**Adidas Product Scraper** collects Adidas product listings and optional full product details from any supported Adidas country storefront and turns them into structured data for price tracking, catalog building, and competitive research. Provide search terms, category URLs, or product IDs, run the Actor, and export product names, prices, images, sizes, availability, and descriptions to JSON, CSV, Excel, or your preferred integration. Use it to monitor pricing, build assortment feeds, and schedule recurring collection across up to 33 markets. Product results are billed at $1.50 per 1,000, with optional full product details at the same rate.

### What can you automate with Adidas Product Scraper?

- **Build product catalogs** — pull every listing from a search query, category page, or a list of product IDs into one clean dataset.
- **Track prices and availability** — capture current and original price, stock status, and review counts across listings and enriched product pages.
- **Collect sizes and variations** — export size-level availability, SKU variations, and colour variants when details are enabled.
- **Monitor any Adidas market** — switch the country input to collect data from Germany, the US, the UK, France, and 29 more storefronts.
- **Schedule recurring collection** — run daily or weekly to catch assortment and price changes over time.
- **Export to your pipeline** — hand off JSON, CSV, or Excel to a PIM, spreadsheet, or database through the Apify API or webhooks.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| E-commerce and retail analysts | Compare Adidas assortment and pricing by category or keyword across markets |
| Price-monitoring teams | Schedule runs and track list-price changes and availability over time |
| PIM and feed operators | Keep product catalogs aligned with the live Adidas catalog in structured JSON |
| Market researchers | Map product lines, colourways, and sizes across multiple country storefronts |
| Automation builders | Trigger runs from the API or webhooks for recurring data pipelines |

### What data can you collect from Adidas?

| Data group | Example fields | How it helps |
|---|---|---|
| Product identity | `productId`, `title`, `subtitle`, `url`, `modelNumber`, `category` | Stable keys and titles for deduplication and catalog feeds |
| Pricing and availability | `currentPrice`, `originalPrice`, `isSoldOut`, `availabilityStatus`, `currency` | Price tracking and stock monitoring |
| Visuals and variants | `imageUrl`, `hoverImageUrl`, `colourVariations`, `variations`, `sizes` | Assortment and size-availability analysis |
| Signals and context | `ratingCount`, `badges`, `country`, `source`, `descriptionText` | Review signals and source tracking per market |

Not every field is present on every row; detail-level fields such as `descriptionText`, `sizes`, and `variations` are populated when product details are enabled and the page returns them.

### How to use Adidas Product Scraper

1. Open the Actor on Apify.
2. Enter a search query, a category URL, or product IDs — at least one source is required.
3. Set the country storefront and choose a `maxItems` limit.
4. Optionally enable product details for descriptions, sizes, and variations.
5. Run the Actor, then export the dataset to JSON, CSV, Excel, or connect it to your pipeline.

```json
{
  "country": "de",
  "searchQueries": ["volleyball schuhe"],
  "startUrls": [{ "url": "https://www.adidas.de/manner-sneakers" }],
  "includeProductDetails": true,
  "maxItems": 100,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Example workflow

#### Build a weekly price and availability report for one category

1. Run the Actor on a fixed category URL every Monday.
2. Enable `includeProductDetails` to capture sizes and stock status.
3. Keep only rows with a price change or a sold-out flag in your downstream step.
4. Deduplicate on `productId` plus `country`, then push the result to a spreadsheet or CRM.

### Automate and integrate your results

- **Schedule** runs daily or weekly from the Apify Schedules tab, or create one schedule per search query or category URL.
- **Webhooks** can notify Slack, Zapier, or your warehouse when a run succeeds.
- **Connect** results to Google Sheets, Make, Zapier, a CRM, or cloud storage.
- **Deduplicate** downstream using the stable `productId` + `country` pair; the Actor also skips duplicate `productId` values within a single run.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---|---:|---|---|
| `country` | string | No | `de` | Adidas storefront country code (`de`, `com`, `uk`, `fr`, and 29 others) |
| `searchQueries` | array | No\* | — | Search terms such as `volleyball schuhe` or `samba` |
| `startUrls` | array | No\* | — | Category, search, or product URLs (URL filters are preserved) |
| `productIds` | array | No\* | — | Direct product IDs such as `IH8244` |
| `filters` | object | No | — | Global listing filters such as `{"v_size_de_de": "43_1_3"}` |
| `includeProductDetails` | boolean | No | `false` | Whether to fetch full product-page details |
| `maxItems` | integer | No | `10` | Maximum number of products to collect |
| `concurrency` | integer | No | — | Parallel workers for the run |
| `proxyConfiguration` | object | No | — | Proxy settings; residential is recommended |

\*Provide at least one of `searchQueries`, `startUrls`, or `productIds`.

### Output example

```json
{
  "productId": "KJ1277",
  "title": "CRAZYFLIGHT 7 Schuh",
  "subtitle": "Frauen Performance",
  "url": "https://www.adidas.de/crazyflight-7-schuh/KJ1277.html",
  "modelNumber": "ONK40",
  "category": "Performance",
  "imageUrl": "https://assets.adidas.com/images/.../CRAZYFLIGHT_7_Schuh_Weiss_KJ1277_HM1.jpg",
  "originalPrice": 150,
  "currentPrice": 150,
  "colourVariations": ["KJ1277", "KI7938", "KJ9563"],
  "ratingCount": 11,
  "country": "de",
  "source": "search:volleyball schuhe",
  "isSoldOut": false
}
```

### How much does it cost to scrape Adidas?

Adidas Product Scraper uses pay-per-event pricing. You are billed per result you receive, not for pages crawled.

- **`product`** — $1.50 per 1,000 product rows written to the dataset.
- **`product-details`** — $1.50 per 1,000 products successfully enriched when `includeProductDetails` is enabled.

A listing-only run charges only the `product` event. With details enabled, a row charges `product` plus `product-details` when enrichment succeeds. Apify subscription-plan discounts apply automatically. A small one-time `apify-actor-start` event ($0.00005) is also billed per run.

### Reliability and responsible use

- A residential proxy is recommended and enabled by default for reliable collection.
- Detail fields are conditional; some pages may not return sizes, descriptions, or variations.
- Collection is intended for public product data within your lawful-use scope; you remain responsible for complying with the site's terms.

### Frequently asked questions

#### Can I collect product details like sizes and descriptions?

Yes. Enable `includeProductDetails` to add full product-page fields such as descriptions, sizes, and variations. Enriched rows are billed under a separate `product-details` event.

#### Can I scrape a specific Adidas country?

Yes. Set the `country` input to match the storefront you want — `de` for adidas.de, `com` for adidas.com, `uk` for adidas.co.uk, and 29 other codes.

#### Can I start from a filtered category URL?

Yes. Paste the category URL into `startUrls`; query parameters such as size, colour, and sport filters are preserved.

#### What counts as one result?

Each product row written to the dataset counts as one `product` result, regardless of whether it came from search, a category URL, or a product ID.

#### Why are some fields empty?

Detail-level fields depend on the page returning them. A residential proxy improves reliability; match the proxy country to your `country` input for the best results.

#### How do I avoid duplicate records?

The Actor skips duplicate `productId` values within a single run. For cross-run deduplication, key your pipeline on `productId` plus `country`.

### Related Scraptivo automations

- [Amazon Search Scraper](https://apify.com/scraptivo/amazon-scraper) — collect Amazon product and price data for competitor monitoring.
- [eBay Product Scraper](https://apify.com/scraptivo/ebay-scraper) — collect eBay listings, prices, and seller data.
- [Zalando Product Scraper](https://apify.com/scraptivo/zalando-scraper) — collect Zalando product listings and details.
- [Best Buy Product Scraper](https://apify.com/scraptivo/best-buy-scraper) — collect Best Buy US and Canada product data.
- [Target.com Product Scraper](https://apify.com/scraptivo/target-scraper) — collect Target.com products and reviews.

### Support and custom workflows

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

# Actor input Schema

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

Adidas storefront country/market code (e.g. de, com, uk, fr). Determines which adidas.\* domain is scraped.

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

Product search terms (e.g. "volleyball schuhe", "samba"). Each query is scraped from the Adidas search results page.

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

Adidas category, search, or product URLs. Filters in the URL are preserved. Examples: https://www.adidas.de/manner-sneakers, https://www.adidas.de/search?q=volleyball+schuhe

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

Direct Adidas product IDs (e.g. IH8244, JR0890). Skips listing discovery.

## `filters` (type: `object`):

Adidas PLP filter query parameters applied to all listing requests. Example: {"v\_size\_de\_de": "43\_1\_3"}. Use filter keys from the Adidas website URL when a filter is selected.

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

When enabled, fetches full product detail page data (description, sizes, availability, variations). Each product is still charged as product (listing data). Successfully enriched products also incur a product-details pay-per-event charge.

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

Maximum number of products to scrape (0 = unlimited)

## `concurrency` (type: `integer`):

Number of parallel workers for product processing (1–20). Higher values are faster but use more proxy bandwidth.

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

Proxy settings for anti-bot protection. Residential proxies are strongly recommended for Adidas.

## Actor input object example

```json
{
  "country": "de",
  "searchQueries": [
    "volleyball schuhe"
  ],
  "startUrls": [
    {
      "url": "https://www.adidas.de/manner-sneakers"
    }
  ],
  "productIds": [],
  "filters": {},
  "includeProductDetails": false,
  "maxItems": 10,
  "concurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing scraped Adidas product records

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

Run statistics including record count and timestamps

# 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 schuhe"
    ],
    "startUrls": [
        {
            "url": "https://www.adidas.de/manner-sneakers"
        }
    ],
    "productIds": [],
    "filters": {},
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/adidas-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 schuhe"],
    "startUrls": [{ "url": "https://www.adidas.de/manner-sneakers" }],
    "productIds": [],
    "filters": {},
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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