# Xbox Store Scraper (`unfenced-group/xbox-store-scraper`) Actor

Scrape Xbox / Microsoft Store games with localized pricing in 51 countries, ratings, Game Pass inclusion, editions and capabilities. No API key.

- **URL**: https://apify.com/unfenced-group/xbox-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

## Xbox Store Scraper

Scrape the Xbox / Microsoft Store into clean, structured game data — localized pricing in any currency, ratings, Game Pass inclusion, editions, capabilities and full descriptions. Search by keyword, paste store URLs, or price the same game across up to 51 country storefronts in a single run. No API key required.

---

### Why this scraper?

#### 🌍 51 storefronts, one run
Price any game across 51 country regions at once — United States, United Kingdom, Japan, Brazil, Turkey, India and 46 more — each in its own local currency. No competitor offers multi-country pricing in a single run.

#### 💷 Real local prices
Every region returns the genuine local price, currency, MSRP and discount — 44 distinct currencies from USD and EUR to JPY, BRL, TRY and KRW.

#### 🎮 Game Pass & subscription detection
See at a glance which games are included with Xbox Game Pass, plus 4K, HDR, cloud gaming, Play Anywhere and Smart Delivery support.

#### 🔎 Search, URLs or filters
Find games by keyword, scrape specific store pages directly, or filter by price, rating, genre, platform, release date and more.

#### 📊 50+ fields per game
Pricing, ratings, content ratings across every board (ESRB, PEGI, USK, CERO, GRB and more), editions, add-ons, capabilities, player counts, accessibility, languages, system requirements, media and badges.

---

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQuery` | string | `""` | Keyword(s) to search the Xbox Store for. |
| `country` | string | `en-US` | Single storefront region (local currency). Ignored if `countries` is set. |
| `countries` | array | `[]` | Multiple storefronts in one run — per-country price array per game. |
| `allCountries` | boolean | `false` | Price every supported storefront (51 regions) in one run. |
| `maxResults` | integer | `50` | Maximum number of games to return. |
| `startUrls` | array | `[]` | Xbox Store game or search URLs to scrape directly. |
| `priceFilter` | string | `all` | `all`, `free`, `paid`, or `onSale`. |
| `minPrice` / `maxPrice` | integer | — | Price bounds in the first region's local currency. |
| `gamePassOnly` | boolean | `false` | Only games included with Game Pass. |
| `fourKOnly` | boolean | `false` | Only games supporting 4K Ultra HD. |
| `cloudGamingOnly` | boolean | `false` | Only games playable via Xbox Cloud Gaming. |
| `playAnywhereOnly` | boolean | `false` | Only Xbox Play Anywhere titles. |
| `optimizedSeriesOnly` | boolean | `false` | Only games optimized for Series X\|S. |
| `platforms` | array | `[]` | Filter by platform: Series X\|S, Xbox One, PC, Cloud. |
| `genres` | array | `[]` | Filter by category (e.g. Racing & flying, Shooter). |
| `minRating` | number | — | Minimum average user rating (0–5). |
| `releasedAfter` / `releasedBefore` | string | — | Release date bounds (YYYY-MM-DD). |
| `includeMedia` | boolean | `true` | Include image gallery and trailer URLs. |
| `includeDescription` | boolean | `true` | Include full description, accessibility and PC system requirements. |

---

### Output schema

#### Always present

| Field | Type | Description |
|---|---|---|
| `productId` | string | Microsoft Store product ID (the 12-character "big ID"). |
| `title` | string | Game title. |
| `productType` | string | Product kind (e.g. Game, Bundle, Durable). |
| `productFamily` | string | Product family (e.g. Games). |
| `url` | string | Xbox Store product page URL. |
| `publisherName` | string | Publisher name. |
| `developerName` | string | Developer name (null when Microsoft does not list one). |
| `releaseDate` | string | Release date (ISO 8601). |
| `categories` | array | Store categories / genres. |
| `availableOn` | array | Platforms: XboxSeriesX, XboxOne, PC, XCloud. |
| `platforms` | array | Alias of `availableOn`. |
| `currency` | string | Currency of the headline price (first region). |
| `listPrice` | number | Current price in the headline region. |
| `msrp` | number | Manufacturer's suggested retail price. |
| `discountPercentage` | number | Discount percent versus MSRP (0 if not on sale). |
| `isOnSale` | boolean | Whether the headline price is discounted. |
| `isFree` | boolean | Whether the game is free. |
| `saleEndDate` | string | Sale end date (null if not on sale). |
| `prices` | array | Per-country price objects (locale, market, country, listPrice, msrp, currency, discountPercentage, isOnSale, isFree, saleEndDate). |
| `priceByCountry` | object | Map of market code → price summary. |
| `countriesPriced` | array | Market codes that returned a price. |
| `isOnSaleAnywhere` | boolean | Whether the game is on sale in any requested region. |
| `averageRating` | number | Average user rating (0–5). |
| `ratingCount` | number | Number of user ratings. |
| `contentRating` | string | Primary age rating (e.g. EVERYONE, PEGI 18). |
| `contentRatingBoard` | string | Rating board for the primary rating. |
| `contentRatingDescription` | string | Human-readable rating description. |
| `contentRatingImage` | string | Rating badge image URL. |
| `contentRatingDescriptors` | array | Content descriptors (e.g. Violence). |
| `contentRatingInteractive` | array | Interactive elements (e.g. In-Game Purchases). |
| `contentRatings` | array | Ratings across every board (ESRB, PEGI, USK, CERO, GRB, etc.). |
| `gamePassProductIds` | array | Game Pass plan IDs the game is included with. |
| `includedWithGamePass` | boolean | Whether the game is on Game Pass. |
| `optimalGamePassId` | string | The cheapest Game Pass plan that includes the game. |
| `capabilities` | array | Human-readable capability labels. |
| `capabilityMap` | object | Raw capability key → label map. |
| `supports4K` | boolean | 4K Ultra HD support. |
| `supportsHDR` | boolean | HDR support. |
| `supports120fps` | boolean | 120 fps support. |
| `supportsRayTracing` | boolean | Ray tracing support. |
| `crossPlatform` | boolean | Cross-platform multiplayer / co-op. |
| `smartDelivery` | boolean | Smart Delivery (one purchase across console generations). |
| `optimizedForSeriesXS` | boolean | Optimized for Xbox Series X\|S. |
| `playAnywhere` | boolean | Xbox Play Anywhere (console + PC, one purchase). |
| `cloudGaming` | boolean | Playable via Xbox Cloud Gaming. |
| `touchControls` | boolean | Touch control support for cloud play. |
| `onlineMultiplayerMax` | number | Maximum online multiplayer players (null if not listed). |
| `onlineCoopMax` | number | Maximum online co-op players (null if not listed). |
| `localMultiplayerMax` | number | Maximum local multiplayer players (null if not listed). |
| `localCoopMax` | number | Maximum local co-op players (null if not listed). |
| `editions` | array | Product IDs of all editions of the game. |
| `editionsCount` | number | Number of editions. |
| `hasAddOns` | boolean | Whether the game has add-ons / DLC. |
| `bundledProductIds` | array | Product IDs bundled with this product. |
| `languagesSupported` | array | Supported language codes. |
| `shortDescription` | string | One-line tagline. |
| `coverImage` | string | Primary cover / box art URL. |
| `badges` | array | Store badges (Game Pass, Optimized, Smart Delivery, etc.). |
| `scrapedAt` | string | Timestamp the record was scraped (ISO 8601). |

#### With `includeMedia: true`

| Field | Type | Description |
|---|---|---|
| `images` | object | Image gallery by role (boxArt, poster, superHeroArt, screenshots, etc.). |
| `videos` | array | Trailer and preview video URLs. |

#### With `includeDescription: true`

| Field | Type | Description |
|---|---|---|
| `description` | string | Full game description. |
| `systemRequirements` | object | PC minimum and recommended requirements. |
| `accessibilityFeatures` | object | Accessibility capabilities (audio, gameplay, input, visual). |
| `installSizeBytes` | number | Install size in bytes. |
| `installSizeReadable` | string | Install size in GB. |

#### Example record

```json
{
  "productId": "9NKX70BBCDRN",
  "title": "Forza Horizon 5 Standard Edition",
  "productType": "Game",
  "url": "https://www.xbox.com/en-US/games/store/forza-horizon-5-standard-edition/9NKX70BBCDRN",
  "publisherName": "Xbox Game Studios",
  "developerName": "Playground Games",
  "releaseDate": "2021-11-09T05:00:00.0000000Z",
  "categories": ["Racing & flying"],
  "availableOn": ["XboxOne", "XboxSeriesX", "PC", "XCloud"],
  "currency": "USD",
  "listPrice": 59.99,
  "msrp": 59.99,
  "discountPercentage": 0,
  "isOnSale": false,
  "isFree": false,
  "prices": [
    { "locale": "en-US", "market": "US", "country": "United States", "listPrice": 59.99, "msrp": 59.99, "currency": "USD", "discountPercentage": 0, "isOnSale": false, "isFree": false },
    { "locale": "ja-JP", "market": "JP", "country": "Japan", "listPrice": 7590, "msrp": 7590, "currency": "JPY", "discountPercentage": 0, "isOnSale": false, "isFree": false }
  ],
  "countriesPriced": ["US", "JP"],
  "isOnSaleAnywhere": false,
  "averageRating": 3.6,
  "ratingCount": 33564,
  "contentRating": "EVERYONE",
  "contentRatingBoard": "ESRB",
  "contentRatings": [
    { "board": "ESRB", "rating": "ESRB:E", "descriptors": [], "interactiveElements": ["ESRB:UseInt", "ESRB:InGamPur"] },
    { "board": "PEGI", "rating": "PEGI:3", "descriptors": [], "interactiveElements": [] }
  ],
  "gamePassProductIds": ["CFQ7TTC0K6L8", "CFQ7TTC0KGQ8", "CFQ7TTC0P85B"],
  "includedWithGamePass": true,
  "supports4K": true,
  "supportsHDR": true,
  "optimizedForSeriesXS": true,
  "playAnywhere": true,
  "cloudGaming": true,
  "smartDelivery": true,
  "onlineMultiplayerMax": 12,
  "editions": ["9NKX70BBCDRN", "9P1HX37NMJLT", "9MTLKM2DJMZ2"],
  "editionsCount": 3,
  "hasAddOns": true,
  "coverImage": "https://store-images.s-microsoft.com/image/apps.18975...",
  "badges": ["Optimized for Series X|S", "Game Pass", "Smart Delivery"],
  "scrapedAt": "2026-06-23T20:40:00.000Z"
}
````

***

### Examples

**Search for racing games:**

```json
{
  "searchQuery": "forza",
  "country": "en-US",
  "maxResults": 25
}
```

**Compare one search across three countries:**

```json
{
  "searchQuery": "halo",
  "countries": ["en-US", "en-GB", "ja-JP"],
  "maxResults": 20
}
```

**Scrape specific game pages directly:**

```json
{
  "startUrls": [
    { "url": "https://www.xbox.com/en-US/games/store/forza-horizon-5/9NKX70BBCDRN" }
  ],
  "countries": ["en-US", "de-DE", "pt-BR"]
}
```

**Game Pass titles on sale, 4K, rated 4+:**

```json
{
  "searchQuery": "shooter",
  "priceFilter": "onSale",
  "gamePassOnly": true,
  "fourKOnly": true,
  "minRating": 4,
  "maxResults": 50
}
```

***

### 💰 Pricing

**$0.99 per 1,000 results** — you only pay for games successfully retrieved. Failed retries and filtered-out games are never charged.

| Results | Cost |
|---------|------|
| 100 | ~$0.10 |
| 1,000 | ~$0.99 |
| 10,000 | ~$9.90 |
| 100,000 | ~$99.00 |

> Volume discounts apply automatically on higher subscription tiers, down to $0.69 per 1,000.

> Flat-rate alternatives typically charge $29–$49/month regardless of usage.

Use the **Max results** cap in the input to control your spend exactly.

***

### Performance

| Run size | Approximate time |
|---|---|
| 25 games, 1 country | under 1 minute |
| 50 games, 3 countries | 1–2 minutes |
| 100 games, all 51 countries | 5–10 minutes |

Multi-country pricing adds one batched lookup per region; it does not re-fetch the game pages.

***

### Known limitations

- Prices reflect the anonymous storefront price. Personalized offers tied to a signed-in Microsoft account are not visible to any anonymous scraper.
- A game's price array only includes regions where that title is actually published.
- User ratings and rating counts are global Microsoft Store values, not per-region.
- Discovery is keyword- and URL-based; full category enumeration is not exhaustive.

***

### Technical details

- **Source:** Xbox / Microsoft Store — game catalog and pricing.
- **Coverage:** 51 country storefronts, 44 currencies.
- **Memory:** 512 MB.
- **Retry:** Automatic retry on network errors, exponential backoff, 3 attempts per request.

### 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)
- [Steam Store Scraper](https://apify.com/unfenced-group/steam-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

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

Keyword(s) to search the Xbox Store for, e.g. "forza", "halo", "racing". Leave blank if you supply Start URLs.

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

Single storefront region to scrape prices from. Each region returns prices in its local currency. Ignored if 'Countries' is set.

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

Scrape prices from multiple storefronts in one run. Each game is returned once with a per-country price array. Overrides the single Country field.

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

Price every supported storefront (51 regions) in a single run. Overrides Country and Countries.

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

Maximum number of games to return.

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

Optional Xbox Store URLs to scrape directly — game pages (…/games/store/{slug}/{id}) or search result pages.

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

Restrict to free, paid, or on-sale games.

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

Only return games priced at or above this amount (in the first region's local currency).

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

Only return games priced at or below this amount (in the first region's local currency).

## `gamePassOnly` (type: `boolean`):

Only return games included with Xbox Game Pass.

## `fourKOnly` (type: `boolean`):

Only return games that support 4K Ultra HD.

## `cloudGamingOnly` (type: `boolean`):

Only return games playable via Xbox Cloud Gaming (xCloud).

## `playAnywhereOnly` (type: `boolean`):

Only return Xbox Play Anywhere titles (one purchase, console + PC).

## `optimizedSeriesOnly` (type: `boolean`):

Only return games optimized for Xbox Series X|S.

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

Only return games available on the selected platforms.

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

Only return games in the selected categories.

## `minRating` (type: `number`):

Only return games with an average user rating at or above this value (0–5).

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

Only return games released on or after this date (YYYY-MM-DD).

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

Only return games released on or before this date (YYYY-MM-DD).

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

Include image gallery and trailer video URLs in the output.

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

Include the full game description, accessibility details and PC system requirements.

## Actor input object example

```json
{
  "searchQuery": "halo",
  "country": "en-US",
  "countries": [],
  "allCountries": false,
  "maxResults": 50,
  "startUrls": [],
  "priceFilter": "all",
  "gamePassOnly": false,
  "fourKOnly": false,
  "cloudGamingOnly": false,
  "playAnywhereOnly": false,
  "optimizedSeriesOnly": false,
  "platforms": [],
  "genres": [],
  "includeMedia": true,
  "includeDescription": true
}
```

# 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 = {
    "searchQuery": "halo"
};

// Run the Actor and wait for it to finish
const run = await client.actor("unfenced-group/xbox-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 = { "searchQuery": "halo" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Xbox Store Scraper",
        "description": "Scrape Xbox / Microsoft Store games with localized pricing in 51 countries, ratings, Game Pass inclusion, editions and capabilities. No API key.",
        "version": "0.0",
        "x-build-id": "d4y1zaCyutgaRP1Fd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/unfenced-group~xbox-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-unfenced-group-xbox-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~xbox-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-unfenced-group-xbox-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~xbox-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-unfenced-group-xbox-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": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword(s) to search the Xbox Store for, e.g. \"forza\", \"halo\", \"racing\". Leave blank if you supply Start URLs.",
                        "default": ""
                    },
                    "country": {
                        "title": "Country / store region",
                        "enum": [
                            "en-US",
                            "en-GB",
                            "en-CA",
                            "en-AU",
                            "en-NZ",
                            "en-IE",
                            "de-DE",
                            "fr-FR",
                            "es-ES",
                            "it-IT",
                            "nl-NL",
                            "pt-PT",
                            "nl-BE",
                            "de-AT",
                            "de-CH",
                            "pl-PL",
                            "cs-CZ",
                            "sk-SK",
                            "hu-HU",
                            "ro-RO",
                            "el-GR",
                            "bg-BG",
                            "hr-HR",
                            "sl-SI",
                            "sv-SE",
                            "nb-NO",
                            "da-DK",
                            "fi-FI",
                            "is-IS",
                            "ja-JP",
                            "ko-KR",
                            "zh-HK",
                            "zh-TW",
                            "en-SG",
                            "en-MY",
                            "th-TH",
                            "id-ID",
                            "vi-VN",
                            "en-PH",
                            "en-IN",
                            "pt-BR",
                            "es-MX",
                            "es-AR",
                            "es-CL",
                            "es-CO",
                            "es-PE",
                            "tr-TR",
                            "ar-SA",
                            "ar-AE",
                            "he-IL",
                            "en-ZA",
                            "uk-UA"
                        ],
                        "type": "string",
                        "description": "Single storefront region to scrape prices from. Each region returns prices in its local currency. Ignored if 'Countries' is set.",
                        "default": "en-US"
                    },
                    "countries": {
                        "title": "Countries (multi-region pricing)",
                        "type": "array",
                        "description": "Scrape prices from multiple storefronts in one run. Each game is returned once with a per-country price array. Overrides the single Country field.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "en-US",
                                "en-GB",
                                "en-CA",
                                "en-AU",
                                "en-NZ",
                                "en-IE",
                                "de-DE",
                                "fr-FR",
                                "es-ES",
                                "it-IT",
                                "nl-NL",
                                "pt-PT",
                                "nl-BE",
                                "de-AT",
                                "de-CH",
                                "pl-PL",
                                "cs-CZ",
                                "sk-SK",
                                "hu-HU",
                                "ro-RO",
                                "el-GR",
                                "bg-BG",
                                "hr-HR",
                                "sl-SI",
                                "sv-SE",
                                "nb-NO",
                                "da-DK",
                                "fi-FI",
                                "is-IS",
                                "ja-JP",
                                "ko-KR",
                                "zh-HK",
                                "zh-TW",
                                "en-SG",
                                "en-MY",
                                "th-TH",
                                "id-ID",
                                "vi-VN",
                                "en-PH",
                                "en-IN",
                                "pt-BR",
                                "es-MX",
                                "es-AR",
                                "es-CL",
                                "es-CO",
                                "es-PE",
                                "tr-TR",
                                "ar-SA",
                                "ar-AE",
                                "he-IL",
                                "en-ZA",
                                "uk-UA"
                            ],
                            "enumTitles": [
                                "🇺🇸 United States (USD)",
                                "🇬🇧 United Kingdom (GBP)",
                                "🇨🇦 Canada (CAD)",
                                "🇦🇺 Australia (AUD)",
                                "🇳🇿 New Zealand (NZD)",
                                "🇮🇪 Ireland (EUR)",
                                "🇩🇪 Germany (EUR)",
                                "🇫🇷 France (EUR)",
                                "🇪🇸 Spain (EUR)",
                                "🇮🇹 Italy (EUR)",
                                "🇳🇱 Netherlands (EUR)",
                                "🇵🇹 Portugal (EUR)",
                                "🇧🇪 Belgium (EUR)",
                                "🇦🇹 Austria (EUR)",
                                "🇨🇭 Switzerland (CHF)",
                                "🇵🇱 Poland (PLN)",
                                "🇨🇿 Czechia (CZK)",
                                "🇸🇰 Slovakia (EUR)",
                                "🇭🇺 Hungary (HUF)",
                                "🇷🇴 Romania (RON)",
                                "🇬🇷 Greece (EUR)",
                                "🇧🇬 Bulgaria (EUR)",
                                "🇭🇷 Croatia (EUR)",
                                "🇸🇮 Slovenia (EUR)",
                                "🇸🇪 Sweden (SEK)",
                                "🇳🇴 Norway (NOK)",
                                "🇩🇰 Denmark (DKK)",
                                "🇫🇮 Finland (EUR)",
                                "🇮🇸 Iceland (ISK)",
                                "🇯🇵 Japan (JPY)",
                                "🇰🇷 South Korea (KRW)",
                                "🇭🇰 Hong Kong (HKD)",
                                "🇹🇼 Taiwan (TWD)",
                                "🇸🇬 Singapore (SGD)",
                                "🇲🇾 Malaysia (MYR)",
                                "🇹🇭 Thailand (THB)",
                                "🇮🇩 Indonesia (IDR)",
                                "🇻🇳 Vietnam (VND)",
                                "🇵🇭 Philippines (PHP)",
                                "🇮🇳 India (INR)",
                                "🇧🇷 Brazil (BRL)",
                                "🇲🇽 Mexico (MXN)",
                                "🇦🇷 Argentina (ARS)",
                                "🇨🇱 Chile (CLP)",
                                "🇨🇴 Colombia (COP)",
                                "🇵🇪 Peru (PEN)",
                                "🇹🇷 Turkey (TRY)",
                                "🇸🇦 Saudi Arabia (SAR)",
                                "🇦🇪 United Arab Emirates (AED)",
                                "🇮🇱 Israel (ILS)",
                                "🇿🇦 South Africa (ZAR)",
                                "🇺🇦 Ukraine (UAH)"
                            ]
                        },
                        "default": []
                    },
                    "allCountries": {
                        "title": "All countries",
                        "type": "boolean",
                        "description": "Price every supported storefront (51 regions) in a single run. Overrides Country and Countries.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of games to return.",
                        "default": 50
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional Xbox Store URLs to scrape directly — game pages (…/games/store/{slug}/{id}) or search result pages.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "priceFilter": {
                        "title": "Price filter",
                        "enum": [
                            "all",
                            "free",
                            "paid",
                            "onSale"
                        ],
                        "type": "string",
                        "description": "Restrict to free, paid, or on-sale games.",
                        "default": "all"
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "type": "integer",
                        "description": "Only return games priced at or above this amount (in the first region's local currency)."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "type": "integer",
                        "description": "Only return games priced at or below this amount (in the first region's local currency)."
                    },
                    "gamePassOnly": {
                        "title": "Game Pass only",
                        "type": "boolean",
                        "description": "Only return games included with Xbox Game Pass.",
                        "default": false
                    },
                    "fourKOnly": {
                        "title": "4K only",
                        "type": "boolean",
                        "description": "Only return games that support 4K Ultra HD.",
                        "default": false
                    },
                    "cloudGamingOnly": {
                        "title": "Cloud gaming only",
                        "type": "boolean",
                        "description": "Only return games playable via Xbox Cloud Gaming (xCloud).",
                        "default": false
                    },
                    "playAnywhereOnly": {
                        "title": "Play Anywhere only",
                        "type": "boolean",
                        "description": "Only return Xbox Play Anywhere titles (one purchase, console + PC).",
                        "default": false
                    },
                    "optimizedSeriesOnly": {
                        "title": "Optimized for Series X|S only",
                        "type": "boolean",
                        "description": "Only return games optimized for Xbox Series X|S.",
                        "default": false
                    },
                    "platforms": {
                        "title": "Platforms",
                        "type": "array",
                        "description": "Only return games available on the selected platforms.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "XboxSeriesX",
                                "XboxOne",
                                "PC",
                                "XCloud"
                            ],
                            "enumTitles": [
                                "Xbox Series X|S",
                                "Xbox One",
                                "PC",
                                "Cloud (xCloud)"
                            ]
                        },
                        "default": []
                    },
                    "genres": {
                        "title": "Genres / categories",
                        "type": "array",
                        "description": "Only return games in the selected categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Action & adventure",
                                "Card & board",
                                "Classics",
                                "Family & kids",
                                "Fighting",
                                "Music",
                                "Other",
                                "Platformer",
                                "Puzzle & trivia",
                                "Racing & flying",
                                "Role playing",
                                "Shooter",
                                "Simulation",
                                "Sports",
                                "Strategy",
                                "Word"
                            ]
                        },
                        "default": []
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "type": "number",
                        "description": "Only return games with an average user rating at or above this value (0–5)."
                    },
                    "releasedAfter": {
                        "title": "Released after",
                        "type": "string",
                        "description": "Only return games released on or after this date (YYYY-MM-DD)."
                    },
                    "releasedBefore": {
                        "title": "Released before",
                        "type": "string",
                        "description": "Only return games released on or before this date (YYYY-MM-DD)."
                    },
                    "includeMedia": {
                        "title": "Include media",
                        "type": "boolean",
                        "description": "Include image gallery and trailer video URLs in the output.",
                        "default": true
                    },
                    "includeDescription": {
                        "title": "Include description & system requirements",
                        "type": "boolean",
                        "description": "Include the full game description, accessibility details and PC system requirements.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
