# Steam Store Scraper (`unfenced-group/steam-store-scraper`) Actor

Scrape Steam games: metadata, multi-country prices, reviews and more.

- **URL**: https://apify.com/unfenced-group/steam-store-scraper.md
- **Developed by:** [Unfenced Group](https://apify.com/unfenced-group) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.79 / 1,000 games

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/platform/actors/running/actors-in-store#pay-per-event

## 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

## Steam Store Scraper 🎮

Scrape any game on the **Steam** store: full metadata, **prices in every currency**, review sentiment, Metacritic scores, genres, media and more. HTTP-only, fast, and the cheapest dedicated Steam scraper on Apify.

Search by keyword, browse top sellers or specials, or pass app IDs and URLs directly. Pull each game's price across as many storefronts as you want **in a single run** — no other Steam actor does this.

### What you get

- **55+ fields per game** — the deepest Steam dataset on Apify
- **Multi-country pricing in one run** — 44 storefronts, 30+ currencies, per game
- **Review intelligence** — score band, sentiment label, total/positive/negative counts, positive %
- **Metacritic score**, Steam recommendations, age ratings across 9 boards (ESRB, PEGI, USK, CERO…)
- **Genres, categories, platforms, controller support, supported languages**
- **Media** — screenshots and trailer video URLs
- **Descriptions** as HTML, plain text and clean **Markdown** (LLM-ready)
- **Optional SteamSpy enrichment** — owner estimates, concurrent players, playtime, community tags
- **Filters** — platform, price status (free/paid/on-sale), price range, Metacritic, review score, positive %, genre, release window

### Pricing

Pay per result. **$0.99 per 1,000 games** (FREE/BRONZE), dropping to **$0.69 per 1,000** on higher tiers. No per-run start fee. You only pay for results — compute and proxy costs are absorbed by us.

### How to use

Provide any combination of inputs. The actor de-duplicates and scrapes up to your `maxResults` limit.

#### Search by keyword

```json
{
  "searchTerms": ["elden ring", "hades"],
  "maxResults": 20,
  "country": "us"
}
````

#### Prices across many countries in one run

```json
{
  "searchTerms": ["baldur's gate 3"],
  "countries": ["us", "gb", "de", "jp", "br"],
  "maxResults": 10
}
```

Each game's `prices` array carries the local price for every selected country, plus a `priceByCountry` map and the `lowestPriceValue`.

#### Browse a storefront section

```json
{
  "browseSection": "specials",
  "priceFilter": "onSale",
  "maxResults": 50,
  "country": "us"
}
```

#### Scrape specific games directly

```json
{
  "startUrls": ["https://store.steampowered.com/app/1245620/ELDEN_RING/"],
  "appIds": ["1145360"],
  "countries": ["us", "gb"],
  "includeSteamSpy": true
}
```

#### Daily on-sale feed (good for a scheduled run)

```json
{
  "browseSection": "specials",
  "priceFilter": "onSale",
  "minMetacritic": 80,
  "maxResults": 100,
  "country": "us"
}
```

### Input reference

| Field | Type | Description |
|---|---|---|
| `searchTerms` | array | Keywords to search the Steam store |
| `browseSection` | select | `topSellers`, `newReleases`, `specials`, `comingSoon` |
| `startUrls` | array | Steam app URLs (app IDs auto-extracted) |
| `appIds` | array | Steam numeric app IDs |
| `maxResults` | integer | Max games to scrape (default 5) |
| `country` | select | Single storefront for local pricing |
| `countries` | select\[] | Multiple storefronts — prices in one run |
| `allCountries` | boolean | Fetch every storefront's price (44 currencies) |
| `language` | select | Content language for name/description |
| `includeReviews` | boolean | Add review score and sentiment (default true) |
| `includeDescription` | boolean | Add HTML/text/Markdown descriptions (default true) |
| `includeMedia` | boolean | Add screenshots and videos (default true) |
| `includeSteamSpy` | boolean | Add owners/CCU/playtime/tags (default false) |
| `platforms` | select\[] | Filter: Windows/macOS/Linux |
| `priceFilter` | select | Filter: all / free / paid / on sale |
| `minPrice` / `maxPrice` | integer | Filter: price range |
| `minMetacritic` | integer | Filter: minimum Metacritic |
| `minReviewScore` | integer | Filter: Steam review band 0–9 |
| `minPositivePercent` | integer | Filter: minimum positive review share |
| `genres` | select\[] | Filter: genres |
| `releasedAfter` / `releasedBefore` | string | Filter: release window (YYYY-MM-DD) |

### Output

Each item is one game. Fields that are always present:

| Field | Type | Description |
|---|---|---|
| `appId` | number | Steam app ID |
| `name` | string | Game title |
| `type` | string | `game`, `dlc`, `demo`, etc. |
| `url` | string | Steam store page |
| `isFree` | boolean | Free-to-play |
| `comingSoon` | boolean | Unreleased |
| `releaseDate` | string | Release date |
| `requiredAge` | number | Minimum age |
| `developers` / `publishers` | array | Studios |
| `genres` / `categories` | array | Genres and feature categories |
| `platforms` | array | windows / mac / linux |
| `controllerSupport` | string | Controller level |
| `currency` | string | Primary-country currency |
| `initialPrice` / `finalPrice` | number | Price before/after discount |
| `discountPercent` | number | Discount on primary store |
| `isOnSale` | boolean | On sale in primary store |
| `priceUnavailable` | boolean | True when a paid game exposes no standalone Steam price (edition-only listings) |
| `prices` | array | Per-country price blocks |
| `priceByCountry` | object | Country → final price map |
| `countriesPriced` | number | How many storefronts priced |
| `isOnSaleAnywhere` | boolean | On sale in any selected store |
| `lowestPriceValue` | number | Cheapest selected-store price |
| `metacriticScore` | number | Metacritic score |
| `recommendationsTotal` | number | Steam recommendations |
| `ageRatings` | array | Per-board ratings (ESRB, PEGI…) |
| `headerImage` / `capsuleImage` / `background` | string | Artwork |
| `website` | string | Official site |
| `supportedLanguagesRaw` | string | Supported languages |
| `supportedLanguages` | array | Parsed clean list of supported languages |
| `dlcCount` / `dlcAppIds` | number/array | DLC |
| `fullgame` | object | Parent game (for DLC) |
| `scrapedAt` | string | ISO timestamp |

With `includeReviews`: `reviewScore`, `reviewScoreDesc`, `totalReviews`, `totalPositive`, `totalNegative`, `positivePercent`.

With `includeDescription`: `shortDescription`, `descriptionHtml`, `descriptionText`, `descriptionMarkdown`.

With `includeMedia`: `screenshots`, `movies`.

With `includeSteamSpy`: `owners`, `ccu`, `averagePlaytimeForever`, `averagePlaytime2Weeks`, `steamTags`.

#### Example output (trimmed)

```json
{
  "appId": 1245620,
  "name": "ELDEN RING",
  "type": "game",
  "url": "https://store.steampowered.com/app/1245620/",
  "isFree": false,
  "releaseDate": "Feb 24, 2022",
  "developers": ["FromSoftware Inc."],
  "publishers": ["FromSoftware Inc.", "Bandai Namco Entertainment"],
  "genres": ["Action", "RPG"],
  "platforms": ["windows"],
  "currency": "USD",
  "finalPrice": 59.99,
  "discountPercent": 0,
  "prices": [
    { "country": "us", "currency": "USD", "finalPrice": 59.99, "discountPercent": 0 },
    { "country": "gb", "currency": "GBP", "finalPrice": 49.99, "discountPercent": 0 },
    { "country": "jp", "currency": "JPY", "finalPrice": 9020, "discountPercent": 0 }
  ],
  "lowestPriceValue": 49.99,
  "metacriticScore": 94,
  "reviewScoreDesc": "Very Positive",
  "totalReviews": 1139652,
  "positivePercent": 93.1
}
```

### Notes

- Prices come straight from Steam's storefront API in each country's local currency.
- A small number of regions bill in USD (e.g. Turkey, Argentina) — the `currency` field always reflects what Steam actually returns.
- Browse sections are small by design (Steam's featured feed returns roughly 10–30 games per section). For large result sets, use `searchTerms`, which paginates through the full catalogue.
- Review stats are aggregate only. No individual reviewer data is collected.

### Related scrapers

Other scrapers in our **Game & App Stores** collection:

- [PlayStation Store Scraper](https://apify.com/unfenced-group/playstation-store-scraper)
- [Nintendo eShop Scraper](https://apify.com/unfenced-group/nintendo-eshop-scraper)
- [Xbox Store Scraper](https://apify.com/unfenced-group/xbox-store-scraper)
- [iOS App Store Scraper](https://apify.com/unfenced-group/ios-app-store-scraper)

***

### Need a custom scraper?

**[Unfenced Group](https://www.unfencedgroup.nl)** builds Apify actors for any website — for free.

If the site you need isn't in our portfolio yet, just ask. We scope, build, and publish it at no cost to you. You only pay for results — we absorb the compute and proxy costs ourselves. Same pay-per-result pricing, same quality, same standards as every actor in this portfolio.

**Get in touch:** [www.unfencedgroup.nl](https://www.unfencedgroup.nl)

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search the Steam store (e.g. "elden ring", "roguelike"). Each term is searched and the matching games are scraped.

## `browseSection` (type: `string`):

Instead of (or in addition to) keywords, pull games from a Steam storefront section.

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

Direct Steam app URLs (e.g. https://store.steampowered.com/app/1245620/). App IDs are extracted automatically.

## `appIds` (type: `array`):

Steam numeric app IDs to scrape directly (e.g. 1245620).

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

Maximum number of games to scrape.

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

Storefront whose local currency prices are returned. Used when no multi-country selection is made.

## `countries` (type: `array`):

Select several storefronts to get each game's price in every chosen currency in a single run. The first selected country is the primary store.

## `allCountries` (type: `boolean`):

Fetch every supported storefront's price for each game in one run (44 currencies). Overrides the country selections.

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

Language for game name, description and supported-languages text.

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

Add aggregate review score, sentiment label, total/positive/negative counts and positive %.

## `includeDescription` (type: `boolean`):

Add short + full description as HTML, plain text and clean Markdown (LLM-ready).

## `includeMedia` (type: `boolean`):

Add screenshots and trailer/video URLs.

## `includeSteamSpy` (type: `boolean`):

Add owner estimate, concurrent players (CCU), average playtime and community tags from SteamSpy.

## `platforms` (type: `array`):

Keep only games supporting any selected OS.

## `priceFilter` (type: `string`):

Keep only games matching this price status.

## `minPrice` (type: `integer`):

Minimum price (in the primary currency's major units) based on the lowest selected-country price.

## `maxPrice` (type: `integer`):

Maximum price (in the primary currency's major units) based on the lowest selected-country price.

## `minMetacritic` (type: `integer`):

Keep only games with a Metacritic score at or above this value. Games without a score are kept.

## `minReviewScore` (type: `integer`):

Steam review score band (0=none … 9=Overwhelmingly Positive). Requires reviews enabled.

## `minPositivePercent` (type: `integer`):

Keep only games whose positive review share is at or above this percentage. Requires reviews enabled.

## `genres` (type: `array`):

Keep only games matching any of these genres (substring match, case-insensitive).

## `releasedAfter` (type: `string`):

Keep only games released on/after this date (YYYY-MM-DD). Undated games are kept.

## `releasedBefore` (type: `string`):

Keep only games released on/before this date (YYYY-MM-DD). Undated games are kept.

## Actor input object example

```json
{
  "searchTerms": [
    "elden ring",
    "hades"
  ],
  "browseSection": "none",
  "startUrls": [
    "https://store.steampowered.com/app/1245620/ELDEN_RING/"
  ],
  "appIds": [
    "1245620",
    "1145360"
  ],
  "maxResults": 5,
  "country": "us",
  "allCountries": false,
  "language": "en",
  "includeReviews": true,
  "includeDescription": true,
  "includeMedia": true,
  "includeSteamSpy": false,
  "priceFilter": "all"
}
```

# 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 = {
    "searchTerms": [
        "elden ring"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("unfenced-group/steam-store-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 = { "searchTerms": ["elden ring"] }

# Run the Actor and wait for it to finish
run = client.actor("unfenced-group/steam-store-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 '{
  "searchTerms": [
    "elden ring"
  ]
}' |
apify call unfenced-group/steam-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Store Scraper",
        "description": "Scrape Steam games: metadata, multi-country prices, reviews and more.",
        "version": "0.0",
        "x-build-id": "i5Aq47ewxmMlREGlx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/unfenced-group~steam-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-unfenced-group-steam-store-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/unfenced-group~steam-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-unfenced-group-steam-store-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/unfenced-group~steam-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-unfenced-group-steam-store-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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search the Steam store (e.g. \"elden ring\", \"roguelike\"). Each term is searched and the matching games are scraped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "browseSection": {
                        "title": "Browse section",
                        "enum": [
                            "none",
                            "topSellers",
                            "newReleases",
                            "specials",
                            "comingSoon"
                        ],
                        "type": "string",
                        "description": "Instead of (or in addition to) keywords, pull games from a Steam storefront section.",
                        "default": "none"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct Steam app URLs (e.g. https://store.steampowered.com/app/1245620/). App IDs are extracted automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appIds": {
                        "title": "App IDs",
                        "type": "array",
                        "description": "Steam numeric app IDs to scrape directly (e.g. 1245620).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of games to scrape.",
                        "default": 5
                    },
                    "country": {
                        "title": "Country (single)",
                        "enum": [
                            "us",
                            "gb",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "nl",
                            "se",
                            "dk",
                            "fi",
                            "cz",
                            "ro",
                            "bg",
                            "pl",
                            "no",
                            "ch",
                            "ua",
                            "ru",
                            "tr",
                            "br",
                            "mx",
                            "ar",
                            "cl",
                            "co",
                            "pe",
                            "ca",
                            "jp",
                            "kr",
                            "cn",
                            "tw",
                            "hk",
                            "sg",
                            "th",
                            "vn",
                            "id",
                            "my",
                            "ph",
                            "in",
                            "au",
                            "nz",
                            "za",
                            "ae",
                            "sa",
                            "il"
                        ],
                        "type": "string",
                        "description": "Storefront whose local currency prices are returned. Used when no multi-country selection is made.",
                        "default": "us"
                    },
                    "countries": {
                        "title": "Countries (multiple — prices in one run)",
                        "type": "array",
                        "description": "Select several storefronts to get each game's price in every chosen currency in a single run. The first selected country is the primary store.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "us",
                                "gb",
                                "de",
                                "fr",
                                "it",
                                "es",
                                "nl",
                                "se",
                                "dk",
                                "fi",
                                "cz",
                                "ro",
                                "bg",
                                "pl",
                                "no",
                                "ch",
                                "ua",
                                "ru",
                                "tr",
                                "br",
                                "mx",
                                "ar",
                                "cl",
                                "co",
                                "pe",
                                "ca",
                                "jp",
                                "kr",
                                "cn",
                                "tw",
                                "hk",
                                "sg",
                                "th",
                                "vn",
                                "id",
                                "my",
                                "ph",
                                "in",
                                "au",
                                "nz",
                                "za",
                                "ae",
                                "sa",
                                "il"
                            ],
                            "enumTitles": [
                                "🇺🇸 United States (USD)",
                                "🇬🇧 United Kingdom (GBP)",
                                "🇩🇪 Germany (EUR)",
                                "🇫🇷 France (EUR)",
                                "🇮🇹 Italy (EUR)",
                                "🇪🇸 Spain (EUR)",
                                "🇳🇱 Netherlands (EUR)",
                                "🇸🇪 Sweden (EUR)",
                                "🇩🇰 Denmark (EUR)",
                                "🇫🇮 Finland (EUR)",
                                "🇨🇿 Czechia (EUR)",
                                "🇷🇴 Romania (EUR)",
                                "🇧🇬 Bulgaria (EUR)",
                                "🇵🇱 Poland (PLN)",
                                "🇳🇴 Norway (NOK)",
                                "🇨🇭 Switzerland (CHF)",
                                "🇺🇦 Ukraine (UAH)",
                                "🇷🇺 Russia (RUB)",
                                "🇹🇷 Turkey (USD)",
                                "🇧🇷 Brazil (BRL)",
                                "🇲🇽 Mexico (MXN)",
                                "🇦🇷 Argentina (USD)",
                                "🇨🇱 Chile (CLP)",
                                "🇨🇴 Colombia (COP)",
                                "🇵🇪 Peru (PEN)",
                                "🇨🇦 Canada (CAD)",
                                "🇯🇵 Japan (JPY)",
                                "🇰🇷 South Korea (KRW)",
                                "🇨🇳 China (CNY)",
                                "🇹🇼 Taiwan (TWD)",
                                "🇭🇰 Hong Kong (HKD)",
                                "🇸🇬 Singapore (SGD)",
                                "🇹🇭 Thailand (THB)",
                                "🇻🇳 Vietnam (VND)",
                                "🇮🇩 Indonesia (IDR)",
                                "🇲🇾 Malaysia (MYR)",
                                "🇵🇭 Philippines (PHP)",
                                "🇮🇳 India (INR)",
                                "🇦🇺 Australia (AUD)",
                                "🇳🇿 New Zealand (NZD)",
                                "🇿🇦 South Africa (ZAR)",
                                "🇦🇪 UAE (AED)",
                                "🇸🇦 Saudi Arabia (SAR)",
                                "🇮🇱 Israel (ILS)"
                            ]
                        }
                    },
                    "allCountries": {
                        "title": "All countries",
                        "type": "boolean",
                        "description": "Fetch every supported storefront's price for each game in one run (44 currencies). Overrides the country selections.",
                        "default": false
                    },
                    "language": {
                        "title": "Content language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "pt",
                            "pl",
                            "ru",
                            "ja",
                            "ko",
                            "zh",
                            "tr",
                            "sv"
                        ],
                        "type": "string",
                        "description": "Language for game name, description and supported-languages text.",
                        "default": "en"
                    },
                    "includeReviews": {
                        "title": "Include review stats",
                        "type": "boolean",
                        "description": "Add aggregate review score, sentiment label, total/positive/negative counts and positive %.",
                        "default": true
                    },
                    "includeDescription": {
                        "title": "Include descriptions",
                        "type": "boolean",
                        "description": "Add short + full description as HTML, plain text and clean Markdown (LLM-ready).",
                        "default": true
                    },
                    "includeMedia": {
                        "title": "Include media",
                        "type": "boolean",
                        "description": "Add screenshots and trailer/video URLs.",
                        "default": true
                    },
                    "includeSteamSpy": {
                        "title": "Include SteamSpy data",
                        "type": "boolean",
                        "description": "Add owner estimate, concurrent players (CCU), average playtime and community tags from SteamSpy.",
                        "default": false
                    },
                    "platforms": {
                        "title": "Filter: platforms",
                        "type": "array",
                        "description": "Keep only games supporting any selected OS.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "windows",
                                "mac",
                                "linux"
                            ],
                            "enumTitles": [
                                "Windows",
                                "macOS",
                                "Linux"
                            ]
                        }
                    },
                    "priceFilter": {
                        "title": "Filter: price status",
                        "enum": [
                            "all",
                            "free",
                            "paid",
                            "onSale"
                        ],
                        "type": "string",
                        "description": "Keep only games matching this price status.",
                        "default": "all"
                    },
                    "minPrice": {
                        "title": "Filter: min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price (in the primary currency's major units) based on the lowest selected-country price."
                    },
                    "maxPrice": {
                        "title": "Filter: max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price (in the primary currency's major units) based on the lowest selected-country price."
                    },
                    "minMetacritic": {
                        "title": "Filter: min Metacritic",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Keep only games with a Metacritic score at or above this value. Games without a score are kept."
                    },
                    "minReviewScore": {
                        "title": "Filter: min review score (0-9)",
                        "minimum": 0,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Steam review score band (0=none … 9=Overwhelmingly Positive). Requires reviews enabled."
                    },
                    "minPositivePercent": {
                        "title": "Filter: min positive %",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Keep only games whose positive review share is at or above this percentage. Requires reviews enabled."
                    },
                    "genres": {
                        "title": "Filter: genres",
                        "type": "array",
                        "description": "Keep only games matching any of these genres (substring match, case-insensitive).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Action",
                                "Adventure",
                                "Casual",
                                "Indie",
                                "Massively Multiplayer",
                                "Racing",
                                "RPG",
                                "Simulation",
                                "Sports",
                                "Strategy",
                                "Early Access",
                                "Free To Play"
                            ],
                            "enumTitles": [
                                "Action",
                                "Adventure",
                                "Casual",
                                "Indie",
                                "Massively Multiplayer",
                                "Racing",
                                "RPG",
                                "Simulation",
                                "Sports",
                                "Strategy",
                                "Early Access",
                                "Free To Play"
                            ]
                        }
                    },
                    "releasedAfter": {
                        "title": "Filter: released after",
                        "type": "string",
                        "description": "Keep only games released on/after this date (YYYY-MM-DD). Undated games are kept."
                    },
                    "releasedBefore": {
                        "title": "Filter: released before",
                        "type": "string",
                        "description": "Keep only games released on/before this date (YYYY-MM-DD). Undated games are kept."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
