# Xbox Store Reviews Scraper (`automation-lab/xbox-store-reviews-scraper`) Actor

Extract public Xbox game reviews, ratings, helpfulness votes, device family, and star distributions from Store URLs or product IDs.

- **URL**: https://apify.com/automation-lab/xbox-store-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 review extracteds

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Reviews Scraper

Extract public Xbox game reviews, star ratings, helpfulness votes, and rating distributions from Xbox Store URLs or product IDs.

Use **Xbox Store Reviews Scraper** to turn customer feedback into structured JSON, CSV, Excel, XML, or RSS data without an Xbox login or API key.

- 🎮 Monitor feedback after a game launch or patch.
- ⭐ Compare average ratings and 1–5-star distributions.
- 💬 Collect review titles, text, authors, and timestamps.
- 👍 Rank customer feedback by helpful and unhelpful votes.
- 🌍 Request reviews in supported Xbox locales.

The Actor uses Xbox's anonymous public ratings surface and saves one dataset row per review.

### What does Xbox Store Reviews Scraper do?

The Actor accepts public Xbox Store game pages and 12-character Xbox product IDs.

For every game, it requests a bounded sample of public written reviews and the current rating summary.

Each review row includes:

- Xbox product ID and source URL
- reviewer name
- star rating
- review title and full text
- submission timestamp
- helpful and unhelpful votes
- Xbox helpfulness score
- device family
- total written-review count
- average rating and total rating count
- counts for every 1–5-star bucket

No Microsoft account, private cookie, or customer API key is required.

### Who is it for?

#### Game studios and publishers

Track recurring complaints, praise, and feature requests around releases, updates, and live-service events.

#### Community and player-support teams

Build a queue of highly helpful reviews and watch recent feedback for support or moderation themes.

#### Gaming analysts

Compare public customer ratings across titles, regions, or competitors in a repeatable dataset.

#### Marketing and research agencies

Export customer language for voice-of-customer research, launch reports, and category benchmarking.

#### QA and product teams

Schedule recent-review pulls after patches to spot reports of crashes, balance issues, or regressions.

### Why use this Xbox review extractor?

Copying reviews manually is slow and difficult to repeat.

This Actor provides:

- **Structured exports** instead of copied page text.
- **Repeatable monitoring** with Apify schedules.
- **Multiple games per run** using URLs and IDs together.
- **Useful context** because rating totals accompany every review.
- **Honest limits** based on the currently verified Xbox endpoint behavior.
- **Typed output** ready for spreadsheets, databases, BI tools, and LLM analysis.

### What Xbox review data can I extract?

| Field | Description |
|---|---|
| `productId` | Xbox's 12-character product identifier |
| `sourceUrl` | Public Xbox Store URL |
| `reviewId` | Stable public review identifier |
| `reviewerName` | Public Xbox reviewer name |
| `rating` | Review score from 1 to 5 |
| `title` | Review headline |
| `reviewText` | Full public review text |
| `submittedAt` | Xbox submission timestamp |
| `helpfulnessScore` | Xbox helpfulness ranking score |
| `helpfulVotes` | Positive helpfulness votes |
| `unhelpfulVotes` | Negative helpfulness votes |
| `deviceFamily` | Reported Xbox device family |
| `totalReviewCount` | Total written reviews for the product |
| `averageRating` | Current average customer rating |
| `totalRatingCount` | Total ratings, including ratings without text |
| `oneStarCount`–`fiveStarCount` | Rating distribution by star bucket |
| `locale` | Locale used for the request |
| `orderBy` | Helpful or recent ordering |
| `starFilter` | Selected star slice |
| `scrapedAt` | UTC extraction timestamp |

### How to scrape Xbox Store reviews

1. Open the Actor on Apify.
2. Add one or more public Xbox game/store URLs.
3. Optionally add raw product IDs.
4. Choose **Most helpful** or **Most recent**.
5. Select all ratings or one star value.
6. Set 1–20 reviews per game.
7. Click **Start**.
8. Download the dataset as JSON, CSV, Excel, XML, or RSS.

The prefilled example requests five reviews and normally finishes well under two minutes.

### Input parameters

#### Xbox game URLs

Use public URLs such as:

```text
https://www.xbox.com/en-US/games/store/arc-raiders/9NDF1F263RZ4/0010
````

Only `xbox.com` URLs containing a `/store/` product path are accepted.

#### Xbox product IDs

Use IDs such as:

```text
9NDF1F263RZ4
```

URLs and IDs can be combined. Duplicate product IDs are removed.

#### Maximum reviews per game

Choose an integer from 1 to 20.

Xbox's currently verified anonymous request accepts up to 20 review rows. The Actor does not claim unverified deep pagination.

#### Review order

- `MostHelpful` ranks feedback using Xbox's helpfulness ordering.
- `MostRecent` prioritizes newly submitted reviews.

#### Star filter

Select all ratings or only one-, two-, three-, four-, or five-star reviews.

#### Locale

Use a locale such as `en-US`, `de-DE`, or `fr-FR`.

A locale embedded in an Xbox URL takes precedence over the default locale field.

### Input example

```json
{
  "startUrls": [
    {
      "url": "https://www.xbox.com/en-US/games/store/arc-raiders/9NDF1F263RZ4/0010"
    }
  ],
  "maxReviewsPerProduct": 10,
  "orderBy": "MostRecent",
  "starFilter": "NoFilter",
  "locale": "en-US"
}
```

You can also use only product IDs:

```json
{
  "productIds": ["9NDF1F263RZ4"],
  "maxReviewsPerProduct": 5,
  "orderBy": "MostHelpful",
  "starFilter": "FiveStar",
  "locale": "en-US"
}
```

### Output example

```json
{
  "productId": "9NDF1F263RZ4",
  "sourceUrl": "https://www.xbox.com/en-US/games/store/product/9NDF1F263RZ4",
  "locale": "en-US",
  "reviewId": "502601a4-f8cb-eba9-d41e-bc92ea625632",
  "reviewerName": "MrSprinkles21",
  "rating": 5,
  "title": "Ragequit",
  "reviewText": "Wasps made my friend uninstall. 10/10 for pissing him off",
  "submittedAt": "2025-10-31T23:43:01.4213911",
  "helpfulnessScore": 0.88830566,
  "helpfulVotes": 3500,
  "unhelpfulVotes": 403,
  "deviceFamily": "Windows.Xbox",
  "totalReviewCount": 6890,
  "averageRating": 3.3,
  "totalRatingCount": 12106,
  "oneStarCount": 3939,
  "twoStarCount": 924,
  "threeStarCount": 689,
  "fourStarCount": 607,
  "fiveStarCount": 5947,
  "orderBy": "MostHelpful",
  "starFilter": "NoFilter",
  "scrapedAt": "2026-07-18T02:40:00.000Z"
}
```

Counts can change whenever Xbox customers add ratings or reviews.

### How much does it cost to scrape Xbox reviews?

Xbox Store Reviews Scraper uses pay-per-event pricing.

A small start charge covers run setup, followed by one charge for each saved review.

Your Apify plan tier determines the exact per-review rate shown in the Console before you start a run.

The free Apify plan can be used for small tests within its included platform credits.

For cost control:

- test one game with five reviews first;
- increase to 20 only after checking the output;
- avoid requesting the same product ID twice;
- use Apify schedules at the frequency your monitoring workflow needs.

### Tips for better Xbox review monitoring

- Use `MostRecent` after releases and patches.
- Use `MostHelpful` for established customer pain points.
- Pull one-star reviews to prioritize complaints.
- Pull five-star reviews to identify loved features and customer language.
- Store `reviewId` in your database to detect newly appearing reviews.
- Compare `totalRatingCount` and star buckets over time for rating movement.
- Keep locale consistent when comparing games.

### Scheduling and change detection

Apify schedules can run this Actor hourly, daily, weekly, or on a custom cron expression.

A practical monitoring workflow is:

1. Run the Actor daily with `MostRecent`.
2. Export the dataset to your database or webhook.
3. Deduplicate on `reviewId`.
4. Alert when new one-star reviews appear.
5. Group review text by topic or game version.
6. Chart average rating and star-count changes.

The Actor returns current source data and does not maintain cross-run history itself.

### Integrations

Connect the dataset to:

- **Google Sheets** for launch and patch review trackers.
- **Slack** for one-star review alerts.
- **Make** or **Zapier** for no-code workflows.
- **Webhooks** for event-driven ingestion.
- **BigQuery**, **Snowflake**, or PostgreSQL for longitudinal analysis.
- **Power BI**, Tableau, or Looker Studio for dashboards.
- **LLM pipelines** for sentiment, themes, and issue classification.

A useful automation sends newly observed `reviewId` values to a queue and classifies only unseen review text.

### Use with the Apify API

Replace `<APIFY_TOKEN>` with your token.

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/xbox-store-reviews-scraper').call({
  productIds: ['9NDF1F263RZ4'],
  maxReviewsPerProduct: 10,
  orderBy: 'MostRecent',
  starFilter: 'NoFilter',
  locale: 'en-US'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation-lab/xbox-store-reviews-scraper").call(run_input={
    "productIds": ["9NDF1F263RZ4"],
    "maxReviewsPerProduct": 10,
    "orderBy": "MostRecent",
    "starFilter": "NoFilter",
    "locale": "en-US",
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~xbox-store-reviews-scraper/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "productIds": ["9NDF1F263RZ4"],
    "maxReviewsPerProduct": 10,
    "orderBy": "MostRecent",
    "starFilter": "NoFilter",
    "locale": "en-US"
  }'
```

### Use with MCP and AI assistants

Apify MCP lets Claude Code and other compatible clients run the Actor as a tool.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/xbox-store-reviews-scraper"
```

#### Claude Desktop, Cursor, or VS Code

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/xbox-store-reviews-scraper"
    }
  }
}
```

Example prompts:

- “Get the five most recent Xbox reviews for product 9NDF1F263RZ4.”
- “Collect one-star reviews and summarize the three most common complaints.”
- “Compare rating distributions for these three Xbox product IDs.”
- “Create a CSV of helpful reviews with author, votes, device, and timestamp.”

### Reliability and error handling

The Actor validates inputs before making source requests.

It retries bounded transient failures and checks the returned JSON shape.

If one game fails but another succeeds, successful products remain in the dataset and the failure appears in the log.

If every product request fails, the run fails instead of silently returning a misleading empty success.

An Xbox product with zero public written reviews can legitimately produce zero rows while its request still succeeds.

### Limitations

- Maximum review rows are currently 20 per product and run configuration.
- Xbox may vary available reviews by locale or product.
- Some ratings do not include written review text.
- The source controls sorting and helpfulness calculations.
- Product title, publisher, developer, price, and catalog metadata are outside version 1 scope.
- Deleted or moderated reviews may disappear from later runs.
- Xbox can change its public endpoint or response fields.

### Is it legal to scrape Xbox Store reviews?

The Actor accesses public customer review data without authentication.

You are responsible for your use of the data and for complying with applicable laws, Xbox terms, privacy obligations, and intellectual-property rules.

Avoid using public reviewer names for unsolicited contact, identity resolution, harassment, or sensitive profiling.

For research and monitoring, collect only the fields you need, set an appropriate retention period, and honor valid deletion or access requests where applicable.

This documentation is general information, not legal advice.

### Troubleshooting

#### “Could not find a product ID in URL”

Use a public `xbox.com` game/store page containing a 12-character product ID, or paste the ID into `productIds`.

#### “All product requests failed”

Check whether each ID exists, confirm the locale format, and inspect the run log for the Xbox HTTP status.

#### I received fewer reviews than the total count

`totalReviewCount` is the source's aggregate count. The Actor intentionally returns only the selected sample of up to 20 rows.

#### I received zero rows

The selected product/star/locale combination may contain no written reviews. Try `NoFilter` and verify the product ID on Xbox.

#### Why does the source URL use `/product/`?

It is a stable normalized reference built from the locale and product ID. Your original Xbox URL may use a localized product slug.

### FAQ

#### Does this Actor need an Xbox login?

No. It uses anonymous public review data.

#### Can I scrape several games in one run?

Yes. Add multiple URLs and/or product IDs. Duplicate IDs are removed.

#### Can I fetch the newest reviews?

Yes. Set `orderBy` to `MostRecent`.

#### Can I filter only one-star reviews?

Yes. Set `starFilter` to `OneStar`.

#### Does it return every review ever written?

No. Version 1 returns a verified bounded sample of up to 20 reviews per game. It does not advertise unverified pagination.

#### Can I export to CSV or Excel?

Yes. Use the dataset Export button or Apify dataset API.

#### How should I identify new reviews?

Persist `reviewId` and compare IDs between scheduled runs.

### Related Automation Lab actors

- [Steam Reviews Scraper](https://apify.com/automation-lab/steam-reviews-scraper) for Steam customer feedback.
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) for marketplace product reviews.
- [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper) for Walmart customer feedback.

Choose the actor matching the source where customers publish reviews; this Actor is specific to public Xbox Store game reviews.

### Support

If a valid public Xbox game URL fails, open an issue from the Actor page.

Include:

- the affected URL or product ID;
- the locale, order, and star filter;
- the run URL;
- the approximate time of the failure;
- the expected and observed result.

Do not include Microsoft passwords, private cookies, personal access tokens, or unrelated personal data.

# Actor input Schema

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

Add public xbox.com game/store URLs. The Actor extracts each 12-character product ID.

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

Optional 12-character product IDs, for example 9NDF1F263RZ4.

## `maxReviewsPerProduct` (type: `integer`):

Return 1–20 public reviews per game. Xbox currently limits one request to 20 reviews.

## `orderBy` (type: `string`):

Sort reviews by helpfulness or recency.

## `starFilter` (type: `string`):

Return all ratings or only reviews with a selected star rating.

## `locale` (type: `string`):

Xbox language/region used for product IDs that do not come from a localized URL, such as en-US or de-DE.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.xbox.com/en-US/games/store/arc-raiders/9NDF1F263RZ4/0010"
    }
  ],
  "productIds": [],
  "maxReviewsPerProduct": 5,
  "orderBy": "MostHelpful",
  "starFilter": "NoFilter",
  "locale": "en-US"
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.xbox.com/en-US/games/store/arc-raiders/9NDF1F263RZ4/0010"
        }
    ],
    "productIds": [],
    "maxReviewsPerProduct": 5,
    "orderBy": "MostHelpful",
    "starFilter": "NoFilter",
    "locale": "en-US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/xbox-store-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.xbox.com/en-US/games/store/arc-raiders/9NDF1F263RZ4/0010" }],
    "productIds": [],
    "maxReviewsPerProduct": 5,
    "orderBy": "MostHelpful",
    "starFilter": "NoFilter",
    "locale": "en-US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/xbox-store-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.xbox.com/en-US/games/store/arc-raiders/9NDF1F263RZ4/0010"
    }
  ],
  "productIds": [],
  "maxReviewsPerProduct": 5,
  "orderBy": "MostHelpful",
  "starFilter": "NoFilter",
  "locale": "en-US"
}' |
apify call automation-lab/xbox-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Xbox Store Reviews Scraper",
        "description": "Extract public Xbox game reviews, ratings, helpfulness votes, device family, and star distributions from Store URLs or product IDs.",
        "version": "0.1",
        "x-build-id": "cRvZdRHRYt5JLCTCv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~xbox-store-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-xbox-store-reviews-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/automation-lab~xbox-store-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-xbox-store-reviews-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/automation-lab~xbox-store-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-xbox-store-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "🎮 Xbox game URLs",
                        "type": "array",
                        "description": "Add public xbox.com game/store URLs. The Actor extracts each 12-character product ID.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productIds": {
                        "title": "Xbox product IDs",
                        "type": "array",
                        "description": "Optional 12-character product IDs, for example 9NDF1F263RZ4.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Maximum reviews per game",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Return 1–20 public reviews per game. Xbox currently limits one request to 20 reviews.",
                        "default": 10
                    },
                    "orderBy": {
                        "title": "Review order",
                        "enum": [
                            "MostHelpful",
                            "MostRecent"
                        ],
                        "type": "string",
                        "description": "Sort reviews by helpfulness or recency.",
                        "default": "MostHelpful"
                    },
                    "starFilter": {
                        "title": "Star rating filter",
                        "enum": [
                            "NoFilter",
                            "OneStar",
                            "TwoStar",
                            "ThreeStar",
                            "FourStar",
                            "FiveStar"
                        ],
                        "type": "string",
                        "description": "Return all ratings or only reviews with a selected star rating.",
                        "default": "NoFilter"
                    },
                    "locale": {
                        "title": "🌍 Default locale",
                        "pattern": "^[a-z]{2,3}-[A-Z]{2}$",
                        "type": "string",
                        "description": "Xbox language/region used for product IDs that do not come from a localized URL, such as en-US or de-DE.",
                        "default": "en-US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
