# Decathlon Scraper \[$0.50/1k💰] | Prices | Stock | Reviews (`ahmed_jasarevic/decathlon-scraper`) Actor

Decathlon.com product data: prices, variants with per-size stock, specs, ratings and customer reviews — for price monitoring, inventory tracking and market research.

- **URL**: https://apify.com/ahmed\_jasarevic/decathlon-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.45 / 1,000 reviews

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

## Decathlon Scraper — US Store Products, Prices, Stock & Reviews Data

Extract **Decathlon.com (US store) product data**: prices, variants with per-size stock quantities, availability, ratings, ratings distributions, specs and customer reviews — from product URLs, category/collection sweeps, search queries or the full catalog (`products.json`). Built for price monitoring, inventory tracking and sports-retail market research.

### Main Use Cases

- **Decathlon price monitoring** — track product prices and compare-at (sale) prices over time.
- **Inventory & stock tracking** — per-variant stock quantities (`inventoryQuantity`) to catch restocks or sell-through.
- **Competitor & market research** — categories, collections, prices and ratings across the US Decathlon store.
- **Review mining** — full customer reviews in a separate Reviews dataset (one row per review) with ratings, dates and countries.
- **Full-catalog sweeps** — page through the entire `products.json` catalog to build a complete product database.

### How It Works

Decathlon.com runs on Shopify, so every product, collection and search page exposes structured JSON (`products.json`) behind the scenes. The Actor walks those JSON endpoints with a CheerioCrawler — no browser rendering, so runs are fast and cheap. Proxy is always on (required to avoid HTTP 429 rate-limit failures). Product pages give you specs and reviews; the fast path (no `includeDetails`) never even loads product pages.

### Scrape Decathlon.com Without an Official API

Decathlon publishes **no official product data API** — product, price, stock and review data only exists on the website and its Shopify JSON blobs. This Actor turns that into structured JSON/CSV/Excel. It targets the **US store (decathlon.com)** specifically, with per-variant stock quantities and a separate reviews dataset most scrapers don't offer. Free Apify users get a **10-product preview per run**.

### Input

| Field | Type | Required | Default | Notes |
|-------|------|----------|---------|-------|
| `startUrls` | array | No | — | Direct product page URLs (`https://www.decathlon.com/products/forclaz-mens-mt500-down-puffer-jacket`) |
| `categoryUrls` | array | No | — | Category/collection URLs to sweep — all products in the collection are scraped (`https://www.decathlon.com/collections/camping-tents-2-3-person`) |
| `searchQueries` | array | No | — | Search terms (`"hiking shoes"`, `"yoga mat"`); matching products are scraped |
| `fullCatalog` | boolean | No | `false` | Page through the entire product catalog (`products.json`) and scrape every product |
| `maxItems` | integer | No | `100` | Maximum products to scrape (free users capped at 10) |
| `includeDetails` | boolean | No | `false` | Scrape each product page for technical specs and long-form details (extra request per product; off = fast mode) |
| `includeReviews` | boolean | No | `false` | Scrape customer reviews; written to a **separate Reviews dataset** (one row per review; off = fast mode) |
| `proxy` | proxy | No | — | Always ON (required to avoid 429s from Decathlon/Shopify) |

Example input:

```json
{
  "searchQueries": ["hiking shoes"],
  "maxItems": 50,
  "includeDetails": true,
  "includeReviews": true
}
```

### Output

Two datasets are produced:

**Default dataset** — one row per product:

```json
{
  "title": "Forclaz Men's MT500 Down Puffer Jacket",
  "vendor": "Forclaz",
  "productType": "Jackets",
  "handle": "forclaz-mens-mt500-down-puffer-jacket",
  "priceMin": 119.99,
  "priceMax": 119.99,
  "compareAtPrice": null,
  "currency": "USD",
  "inStock": true,
  "availability": "available",
  "ratingCount": 512,
  "averageRating": 4.6,
  "ratingsDistribution": { "1": 4, "2": 8, "3": 32, "4": 128, "5": 340 },
  "variants": [
    {
      "sku": "8548143",
      "title": "S / ECRU",
      "price": 119.99,
      "inventoryQuantity": 5,
      "available": true
    }
  ],
  "url": "https://www.decathlon.com/products/forclaz-mens-mt500-down-puffer-jacket"
}
```

**Reviews dataset** (only with `includeReviews: true`) — one row per review:

```json
{
  "productTitle": "Forclaz Men's MT500 Down Puffer Jacket",
  "productId": "4198712459275",
  "handle": "forclaz-mens-mt500-down-puffer-jacket",
  "rating": 5,
  "title": "Warm and light",
  "comment": "Perfect for winter hiking...",
  "author": "John D.",
  "date": "2025-07-12",
  "country": "US",
  "language": "en",
  "buyer": true,
  "url": "https://www.decathlon.com/products/forclaz-mens-mt500-down-puffer-jacket"
}
```

### Monitor Decathlon Prices & Stock Over Time

Schedule daily or weekly runs with identical inputs to build a price/stock history: watch for `compareAtPrice` (sale) events, SKU-level restocks and rating changes. Recurring runs on the same categories also improve Apify Store recommendation signals for this Actor.

### Integrations & Automation

- **Apify API** — run and pull results programmatically.
- **Scheduling** — daily price/stock watch (see above).
- **Export** — JSON, CSV, Excel, HTML; review rows flow straight into a separate dataset for easy BI joins.
- **Webhooks** — trigger downstream pipelines on run completion.

### Related Actors

- [Decathlon Scraper (studio-amba)](https://apify.com/studio-amba/decathlon-scraper) — multi-country Decathlon scraper for 40+ countries ($0.005/result)
- [Decathlon Scraper (solidcode)](https://apify.com/solidcode/decathlon-scraper) — 11 EU country stores ($0.0034/result)
- [Decathlon Product Scraper (stealth\_mode)](https://apify.com/stealth_mode/decathlon-product-search-scraper) — Decathlon product search alternative
- [Decathlon US Scraper (crawlerbros)](https://apify.com/crawlerbros/decathlon-scraper) — US-focused Decathlon alternative
- [Decathlon España Scraper (abotapi)](https://apify.com/abotapi/decathlon-es-scraper) — Spain store alternative

### FAQ

#### Why use this Actor instead of the official Decathlon API?

There is no official public Decathlon product API. Decathlon.com is a Shopify store, so product, price, stock and review data is served as structured JSON behind the website — this Actor reads those endpoints directly and returns clean, typed records.

#### Does it cover international Decathlon stores?

No — this Actor targets the **US store (decathlon.com)** only. For other countries, see studio-amba (40+ countries) or solidcode (11 EU stores) in Related Actors.

#### What are alternatives to this Actor?

Other Apify actors: studio-amba ($0.005/result, 40+ countries), solidcode ($0.0034/result, EU stores), stealth\_mode, crawlerbros and abotapi. This Actor distinguishes itself with per-variant `inventoryQuantity` stock data, a **separate one-row-per-review dataset**, `fullCatalog` (`products.json`) sweeps and fast JSON-only crawling.

#### How can I scrape every Decathlon product?

Set `fullCatalog: true` (with `maxItems` raised). The actor pages through the entire `products.json` catalog. For niche collections, use `categoryUrls` instead.

#### Does it include product variants and stock?

Yes — the `variants` array returns SKU, variant title, price and `inventoryQuantity` per variant, so you can track size-level availability exactly.

#### How can I get product reviews?

Enable `includeReviews: true`. Reviews are written to the separate Reviews dataset, one row per review, with rating, title, comment, author, date, country, language and buyer status.

### For AI Agents & LLM Apps

**Purpose:** returns Decathlon.com (US) product records — price (min/max + compare-at), per-variant stock (`inventoryQuantity`), availability, ratings distribution and optional specs — plus an optional separate Reviews dataset (one row per review).

Minimal input (fast mode, no product pages):

```json
{ "searchQueries": ["hiking shoes"], "maxItems": 20 }
```

Reviews variant (adds product-page requests; reviews go to a second dataset):

```json
{ "searchQueries": ["yoga mat"], "maxItems": 10, "includeReviews": true }
```

Output fields (default dataset): `title, vendor, productType, handle, priceMin, priceMax, compareAtPrice, currency, inStock, availability, ratingCount, averageRating, ratingsDistribution, variants[] (sku, title, price, inventoryQuantity, available), images, options, tags, description, url`. Reviews dataset: `productTitle, productId, handle, rating, title, comment, author, date, country, language, buyer, url`.

Behaviors an agent should know:

- Review rows land in a **second dataset** (named `reviews`), not the default one — fetch both when `includeReviews: true`.
- `maxItems` free-tier cap is 10 products per run; raise it for paid runs. `fullCatalog: true` overrides URL/search inputs.
- Proxy is always on and priced in; tiny runs can cost more per item than big sweeps.
- Billing: compute-based (platform usage), no per-product fee.

### Legal & Compliance Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Decathlon. It reads publicly available product, price and review pages on decathlon.com — it does not bypass logins, paywalls or CAPTCHAs. You are responsible for complying with Decathlon's Terms of Service and applicable law (e.g. GDPR for reviews containing personal data) when using the results.

### SEO Keywords

decathlon scraper, decathlon product data, decathlon price monitoring, decathlon stock tracker, decathlon reviews api, decathlon.com scraper, decathlon us store, sports retail data, decathlon full catalog, decathlon products.json, decathlon collection scraper, decathlon search scraper, hiking shoes data, camping equipment data, decathlon price history, decathlon sku stock, decathlon ratings distribution, outdoor gear data, sports ecommerce scraping, decathlon variant data

# Actor input Schema

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

Direct Decathlon product page URLs to scrape (e.g. https://www.decathlon.com/products/forclaz-mens-mt500-down-puffer-jacket).

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

Decathlon category or collection page URLs to sweep (e.g. https://www.decathlon.com/collections/camping-tents-2-3-person). All products in the collection are scraped.

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

Search terms to look up on Decathlon (e.g. "hiking shoes", "yoga mat"). Matching products are scraped.

## `fullCatalog` (type: `boolean`):

When enabled, the actor pages through the entire Decathlon product catalog (products.json) and scrapes every product.

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

Maximum number of products to scrape. Free users are capped at 10.

## `includeDetails` (type: `boolean`):

Scrape each product page for technical specs and long-form detail data. Off = fast mode (products.json only, no extra request per product). Reserved for future pay-per-event billing.

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

Scrape each product page for customer reviews. Reviews are written to a separate Reviews dataset (one row per review). Off = fast mode. Reserved for future pay-per-event billing.

## `proxy` (type: `object`):

Select proxies to be used by your crawler. Proxy is always ON (required to avoid HTTP 429 rate-limit failures from Decathlon/Shopify).

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.decathlon.com/products/forclaz-mens-mt500-down-puffer-jacket"
    }
  ],
  "searchQueries": [
    "hiking shoes"
  ],
  "fullCatalog": false,
  "maxItems": 100,
  "includeDetails": false,
  "includeReviews": false,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `reviews` (type: `string`):

One row per customer review (only when Include reviews is enabled).

# 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 = {
    "startUrls": [
        {
            "url": "https://www.decathlon.com/products/forclaz-mens-mt500-down-puffer-jacket"
        }
    ],
    "searchQueries": [
        "hiking shoes"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/decathlon-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 = {
    "startUrls": [{ "url": "https://www.decathlon.com/products/forclaz-mens-mt500-down-puffer-jacket" }],
    "searchQueries": ["hiking shoes"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/decathlon-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 '{
  "startUrls": [
    {
      "url": "https://www.decathlon.com/products/forclaz-mens-mt500-down-puffer-jacket"
    }
  ],
  "searchQueries": [
    "hiking shoes"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call ahmed_jasarevic/decathlon-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/decathlon-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/pnkULJIrVe3bgseFh/builds/38ajALF1EBagfM15Z/openapi.json