# Decathlon Scraper — Sports & Outdoor Products, Prices & Reviews (`studio-amba/decathlon-scraper`) Actor

Scrape products, prices, specs, reviews, and stock from Decathlon — Europe's #1 sports retailer. Supports 40+ countries.

- **URL**: https://apify.com/studio-amba/decathlon-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Decathlon Scraper

Extract products, prices, specs, reviews, and stock availability from [Decathlon](https://www.decathlon.be) — Europe's #1 sports and outdoor retailer with 1,700+ stores across 40+ countries — into structured JSON ready for price monitoring, market research, and competitive analysis.

### What is Decathlon Scraper?

**Decathlon Scraper** lets you extract structured product data from Decathlon's online store across 9 European countries, giving you instant access to prices, stock levels, reviews, and detailed specifications — all without manual browsing or copy-pasting.

- **Monitor competitor pricing:** track prices and discounts across Decathlon's massive catalog to benchmark against your own products or spot deals before your competitors do
- **Build product databases:** extract full catalogs by category or search query to feed comparison shopping sites, affiliate portals, or internal product intelligence tools
- **Track stock availability:** monitor whether specific products are in stock across different Decathlon country stores — ideal for resellers, dropshippers, and procurement teams
- **Analyze customer sentiment:** aggregate ratings and review counts across product lines to understand which products perform best and where quality issues emerge
- **Compare prices across countries:** the same product often has different prices on decathlon.be, decathlon.fr, decathlon.de, etc. — run country-specific scrapes to find the best deals
- **Monitor Decathlon's private labels:** track Quechua, BTWIN, Domyos, Kipsta, Forclaz, and other house brands that aren't sold anywhere else

Decathlon has **no public API** and blocks automated access with Cloudflare protection. This scraper handles all anti-bot measures for you. No other Apify actor covers Decathlon across multiple countries.

### What data does Decathlon Scraper extract?

🏷️ **Product name** — full product title as displayed on the site
🏢 **Brand** — Quechua, BTWIN, Domyos, Kipsta, Forclaz, Kalenji, and more
💰 **Price** — current selling price in local currency
💸 **Original price** — pre-discount price (when on sale)
🔖 **Discount** — percentage or amount off
💱 **Currency** — EUR, GBP, or PLN depending on country
📦 **In stock** — boolean availability status
⭐ **Rating** — average customer rating (out of 5)
💬 **Review count** — total number of customer reviews
🔢 **Product ID, EAN & SKU** — unique identifiers for matching across systems
🖼️ **Images** — main image URL + full array of all product photos
📋 **Specifications** — structured key-value pairs (weight, material, waterproof rating, etc.)
📂 **Category** — full category breadcrumb path
📝 **Description** — complete product description text
🔗 **URL** — direct link to the product page
🕐 **Scraped at** — ISO timestamp of when the data was collected

### How to scrape Decathlon products

The input is flexible: search by keyword, provide category URLs, or pass individual product page URLs. Configure through the Apify Console UI or programmatically via the API.

#### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | — | Category or product page URLs to scrape. Supports any Decathlon country domain. |
| `searchQuery` | string | — | Product keyword to search for, e.g. `"tent"`, `"running shoes"`, `"yoga mat"`. |
| `country` | string | `"be"` | Country store to target: `be`, `fr`, `nl`, `de`, `es`, `it`, `pl`, `pt`, `co.uk`. |
| `maxResults` | integer | `100` | Maximum number of products to return (1 -- 10,000). |
| `proxyConfiguration` | object | Residential | Proxy settings. **Residential proxies strongly recommended** — Decathlon uses Cloudflare. |

#### Supported countries

| Country | Domain | Currency |
|---------|--------|----------|
| Belgium | decathlon.be | EUR |
| France | decathlon.fr | EUR |
| Netherlands | decathlon.nl | EUR |
| Germany | decathlon.de | EUR |
| Spain | decathlon.es | EUR |
| Italy | decathlon.it | EUR |
| Poland | decathlon.pl | PLN |
| Portugal | decathlon.pt | EUR |
| United Kingdom | decathlon.co.uk | GBP |

#### Tips for best results

- **Use `searchQuery` for broad discovery:** searching "hiking jacket" across the Belgian store gives you every matching product without needing to know the exact category URL
- **Use `startUrls` for targeted scraping:** if you want all products in a specific category (e.g. road bike tires), paste the category page URL for faster, more focused results
- **Start small:** test with `maxResults: 10` to verify your setup before running large extractions
- **One country per run:** each run targets a single country domain — run separate jobs for cross-country price comparisons
- **Residential proxies are essential:** Decathlon's Cloudflare protection is aggressive. Datacenter proxies will be blocked. Always use residential proxies for reliable results.

### Output

Results are stored in a **dataset** that you can download in JSON, CSV, Excel, XML, or HTML format directly from the Apify Console.

#### JSON example

```json
{
    "name": "Quechua MH500 Waterdichte wandeljas - heren",
    "brand": "Quechua",
    "price": 79.99,
    "currency": "EUR",
    "url": "https://www.decathlon.be/nl/p/waterdichte-wandeljas-voor-heren-mh500/_/R-p-325469",
    "scrapedAt": "2026-04-04T09:30:00.000Z",
    "productId": "325469",
    "originalPrice": 99.99,
    "discount": "-20%",
    "ean": "3608439427138",
    "sku": "4727183",
    "inStock": true,
    "rating": 4.6,
    "reviewCount": 1847,
    "imageUrl": "https://contents.mediadecathlon.com/p2345678/k$abc123/mh500-heren-jacket.jpg",
    "imageUrls": [
        "https://contents.mediadecathlon.com/p2345678/k$abc123/mh500-heren-jacket.jpg",
        "https://contents.mediadecathlon.com/p2345678/k$def456/mh500-heren-jacket-back.jpg",
        "https://contents.mediadecathlon.com/p2345678/k$ghi789/mh500-heren-jacket-detail.jpg"
    ],
    "specs": {
        "Weight": "475 g",
        "Material": "100% Polyester",
        "Waterproof rating": "10,000 mm",
        "Breathability": "10,000 g/m²/24h",
        "Number of pockets": "3",
        "Hood": "Adjustable and removable"
    },
    "category": "Hiking > Hiking Jackets > Men's Waterproof Jackets",
    "description": "This waterproof hiking jacket is designed for day hikes in the mountains. 2-layer waterproof and breathable fabric keeps you dry in heavy rain while staying comfortable during intense effort."
}
````

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

Decathlon Scraper uses **Playwright browser automation** to handle Cloudflare protection, which uses more resources than simple HTTP scrapers. Here's what to expect:

| Scenario | Est. cost | Time |
|----------|-----------|------|
| 50 products from a search query | ~$0.50 | ~2 min |
| 500 products from a category | ~$2.00 | ~10 min |
| 1,000 products across categories | ~$4.00 | ~20 min |

**Pricing breakdown:**

- Per result: ~$0.004
- Estimated cost per 1,000 results: ~$2.00 (platform fees + residential proxy bandwidth)

### Can I integrate Decathlon Scraper with other apps?

Yes. Decathlon Scraper connects with any tool through [Apify integrations](https://apify.com/integrations):

- **Google Sheets** — automatically export product data to a spreadsheet for price tracking
- **Slack / Email** — get notified when prices drop or products come back in stock
- **Zapier / Make** — trigger workflows when new data is ready
- **Airtable** — build a searchable product database with images and specs
- **REST API** — call the scraper programmatically from any language
- **Webhooks** — get notified when a run finishes to trigger downstream processing

### Can I use Decathlon Scraper as an API?

Yes. Use the [Apify API](https://docs.apify.com/api/v2) to run Decathlon Scraper programmatically from any application.

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("studio-amba/decathlon-scraper").call(run_input={
    "searchQuery": "running shoes",
    "country": "be",
    "maxResults": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['brand']} {item['name']} — {item['currency']} {item['price']}")
```

**JavaScript:**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('studio-amba/decathlon-scraper').call({
    searchQuery: 'running shoes',
    country: 'be',
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`${item.brand} ${item.name} — ${item.currency} ${item.price}`);
});
```

Check the [API tab](https://apify.com/studio-amba/decathlon-scraper/api) for full documentation.

### FAQ

#### What is Decathlon?

Decathlon is Europe's largest sporting goods retailer, headquartered in France. They design and sell affordable sports equipment under their own brands (Quechua for hiking, BTWIN for cycling, Domyos for fitness, Kipsta for team sports, Forclaz for trekking, Kalenji for running, and many more). With 1,700+ stores across 40+ countries, Decathlon is the go-to destination for sports gear in Europe.

#### How does Decathlon Scraper work?

The scraper uses Playwright browser automation to navigate Decathlon's website, bypass Cloudflare protection, and extract product data from search results, category pages, or individual product pages. It renders pages just like a real browser would, ensuring all dynamic content is captured.

#### Can I scrape Decathlon from different countries?

Yes. Set the `country` input to target any of the 9 supported European domains: Belgium, France, Netherlands, Germany, Spain, Italy, Poland, Portugal, and the UK. Each country has its own product catalog, pricing, and currency.

#### Can I track price changes over time?

Yes. Schedule the scraper to run daily or weekly via the Apify Console. Each run creates a new dataset. Use the Apify API or integrations to compare datasets over time and detect price drops, new discounts, or stock changes.

#### What are Decathlon's private label brands?

Decathlon designs most of its products in-house under sport-specific brands: **Quechua** (hiking/camping), **BTWIN/Van Rysel/Triban** (cycling), **Domyos** (fitness), **Kipsta** (team sports), **Forclaz** (trekking), **Kalenji** (running), **Nabaiji** (swimming), **Solognac** (hunting), and **Caperlan** (fishing), among others.

#### Is it legal to scrape Decathlon?

This scraper extracts publicly available product data that Decathlon displays to all visitors — product names, prices, specifications, and reviews. The data is factual and commercial in nature. As with any scraping tool, use the data responsibly and in compliance with applicable laws.

### Limitations

- **Cloudflare protection** — Decathlon uses aggressive anti-bot measures. Residential proxies are required for reliable scraping. Some requests may still be blocked during peak traffic.
- **Product availability varies by country** — not all products are listed on every country domain. Specs and descriptions may differ between markets.
- **No customer review text** — the scraper extracts aggregate ratings and review counts, but not individual review text.
- **Dynamic pricing** — Decathlon frequently changes prices and runs promotions. Prices reflect the moment of scraping and may change shortly after.
- **One country per run** — cross-country comparisons require separate runs for each country domain.

### Other sports & outdoor scrapers

Combine Decathlon Scraper with these actors for comprehensive sports retail market coverage:

- 🏃 [Intersport Scraper](https://apify.com/studio-amba/intersport-scraper) — Europe's largest sporting goods retail group
- 🏔️ [AS Adventure Scraper](https://apify.com/studio-amba/asadventure-scraper) — Belgium's premium outdoor retailer
- 🧗 [Bergfreunde Scraper](https://apify.com/studio-amba/bergfreunde-scraper) — Europe's top online climbing & outdoor shop
- 🛒 [Bol.com Scraper](https://apify.com/studio-amba/bol-scraper) — Benelux's largest online marketplace (sports category)

### Your feedback

Found a bug or have a feature request? Please open an issue on the [Issues tab](https://apify.com/studio-amba/decathlon-scraper/issues). We actively maintain this scraper and respond to all reports.

# Actor input Schema

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

Decathlon category or product pages to scrape. Example: https://www.decathlon.be/nl/alle-sporten/fietsen/binnenbanden

## `searchQuery` (type: `string`):

Search for products by keyword (e.g., 'tent', 'running shoes', 'fiets'). Uses Decathlon's search. Overrides start URLs if provided.

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

Which Decathlon country site to scrape.

## `maxResults` (type: `integer`):

Maximum number of products to return.

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

Proxy settings. Residential proxies strongly recommended — Decathlon uses Cloudflare protection.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.decathlon.be/nl/alle-sporten/fietsen/binnenbanden"
    }
  ],
  "country": "be",
  "maxResults": 100,
  "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 = {
    "startUrls": [
        {
            "url": "https://www.decathlon.be/nl/alle-sporten/fietsen/binnenbanden"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/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.be/nl/alle-sporten/fietsen/binnenbanden" }] }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/decathlon-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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.be/nl/alle-sporten/fietsen/binnenbanden"
    }
  ]
}' |
apify call studio-amba/decathlon-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=studio-amba/decathlon-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Decathlon Scraper — Sports & Outdoor Products, Prices & Reviews",
        "description": "Scrape products, prices, specs, reviews, and stock from Decathlon — Europe's #1 sports retailer. Supports 40+ countries.",
        "version": "0.1",
        "x-build-id": "O9dUtP4ZES6AVJ46x"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~decathlon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-decathlon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/studio-amba~decathlon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-decathlon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/studio-amba~decathlon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-decathlon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Decathlon category or product pages to scrape. Example: https://www.decathlon.be/nl/alle-sporten/fietsen/binnenbanden",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by keyword (e.g., 'tent', 'running shoes', 'fiets'). Uses Decathlon's search. Overrides start URLs if provided."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "be",
                            "fr",
                            "nl",
                            "de",
                            "es",
                            "it",
                            "pl",
                            "pt",
                            "co.uk"
                        ],
                        "type": "string",
                        "description": "Which Decathlon country site to scrape.",
                        "default": "be"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies strongly recommended — Decathlon uses Cloudflare protection.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
