# Steam Scraper — Game Data, Reviews & Store Intelligence (`scrapepilot/steam-scraper----game-data-reviews-store-intelligence`) Actor

Scrape Steam game data and reviews from any game, keyword search, or trending list. Get price, discount, genres, Metacritic score, system requirements, screenshots, and paginated player reviews. No login, no API key. $7.99/month. 2-hour free trial.

- **URL**: https://apify.com/scrapepilot/steam-scraper----game-data-reviews-store-intelligence.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** Developer tools, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$7.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 🎮 Steam Scraper — Game Data, Reviews & Store Intelligence

> **The most complete Steam Scraper on Apify.** Extract full Steam game data and Steam game reviews from any game, keyword search, or featured/trending list — price, discount, genres, platforms, developer, publisher, release date, Metacritic score, system requirements, screenshots, DLC count, achievements, and paginated player reviews. No login. No API key. Instant structured output.

---

### 📌 Table of Contents

- [What Is This Actor?](#what-is-this-actor)
- [Why Use This Steam Scraper?](#why-use-this-steam-scraper)
- [Supported Modes](#supported-modes)
- [Use Cases](#use-cases)
- [Input Parameters](#input-parameters)
- [Output Fields](#output-fields)
- [Example Input & Output](#example-input--output)
- [Pricing & Free Trial](#pricing--free-trial)
- [Performance & Limits](#performance--limits)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Terms of Use](#legal--terms-of-use)

---

### 🔍 What Is This Actor?

**Steam Scraper** is a production-ready Apify actor that extracts complete **Steam game data** and **Steam game reviews** from the Steam Store — by keyword search, direct App ID, Steam URL, or featured/trending game lists.

Provide a search keyword like `"open world RPG"`, paste a Steam game URL, enter one or many App IDs, or switch to featured mode to get the current top sellers and new releases — and receive back a rich, structured dataset for every game: name, price, discount percentage, genres, developer, publisher, release date, platform support, Metacritic score, system requirements, screenshots, DLC count, achievement count, and total recommendations.

Enable the optional **Steam game reviews** extraction to also pull paginated player reviews for each game — with recommended status, playtime, helpful votes, and full review text.

This **Steam scraper** works without any login, without Steam API credentials, and without any manual steps — making it the most complete Steam game intelligence tool available on Apify.

---

### 🚀 Why Use This Steam Scraper?

| Feature | This Actor | Manual Browsing | SteamDB | Other Scrapers |
|---|---|---|---|---|
| **Steam game data — full set** | ✅ 25+ fields | ❌ Slow | ⚠️ Partial | ⚠️ |
| **Steam game reviews — paginated** | ✅ Optional | ❌ | ❌ | ⚠️ |
| **Keyword search mode** | ✅ | ✅ | ✅ | ⚠️ |
| **Featured / top sellers list** | ✅ | ✅ | ✅ | ❌ |
| **Bulk App ID input** | ✅ | ❌ | ❌ | ⚠️ |
| **Price + discount percent** | ✅ | ✅ | ✅ | ⚠️ |
| **Metacritic score** | ✅ | ✅ | ✅ | ❌ |
| **System requirements** | ✅ | ✅ | ⚠️ | ❌ |
| **Screenshots (up to 5)** | ✅ | ✅ | ❌ | ❌ |
| **No login or API key** | ✅ | ✅ | ✅ | ✅ |

> **Bottom line:** This **Steam scraper** is the only actor that combines keyword search, bulk App ID lookup, featured game lists, and optional **Steam game reviews** — all with 25+ structured fields per game — in a single run with no credentials needed.

---

### 🎬 Supported Modes

| Mode | What It Does | Best For |
|---|---|---|
| `search` | Searches the Steam Store by keyword and scrapes full game data | Discovering games by genre, topic, or feature |
| `app` | Scrapes full game data for specific App IDs or Steam URLs | Monitoring specific games, bulk catalog extraction |
| `featured` | Fetches Steam's current new releases, top sellers, and specials | Tracking trending games, deal monitoring |

---

### 🎯 Use Cases

#### 🎮 Game Market Research & Pricing Intelligence
- Scrape **Steam game data** across genres to analyze pricing trends, discount frequency, and release patterns
- Monitor Steam's top sellers and new releases with scheduled featured mode runs
- Track price and discount changes on a watchlist of game App IDs over time

#### 📊 Gaming Industry Analytics
- Collect **Steam game data** at scale for gaming market reports — developer activity, genre distribution, platform coverage
- Analyze Metacritic score correlations with Steam recommendation counts across thousands of titles
- Study achievement count and DLC density as indicators of post-launch content investment

#### ⭐ Steam Game Reviews & Sentiment Analysis
- Extract **Steam game reviews** in bulk for sentiment analysis and NLP model training
- Collect player feedback for product research using recommended/not recommended status as ground truth
- Build labeled review datasets from Steam game reviews across multiple genres and languages

#### 🛠️ Game Discovery & Recommendation Platforms
- Power a game recommendation engine with structured **Steam game data** — genres, platforms, requirements
- Build a game comparison tool using price, Metacritic score, and review count data
- Populate a gaming database with verified Steam metadata including screenshots and descriptions

#### 🏢 Developer & Publisher Competitive Intelligence
- Scrape all games from competitor developers or publishers using targeted keyword searches
- Compare system requirements, DLC counts, and achievement systems across similar titles
- Monitor new release activity from specific studios with scheduled runs

#### 🎓 Academic & Game Studies Research
- Build datasets of Steam game metadata for game design or platform economics research
- Study pricing strategies across genres and platform types using structured Steam store data
- Collect **Steam game reviews** as primary source material for player experience research

---

### ⚙️ Input Parameters

```json
{
  "mode":         "search",
  "query":        "open world RPG",
  "app_ids":      [],
  "app_url":      "",
  "max_results":  20,
  "max_reviews":  0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `"search"` | Extraction mode — `"search"` for keyword, `"app"` for App IDs or URL, `"featured"` for trending lists |
| `query` | string | `""` | Search keyword — used in `search` mode. E.g. `"action RPG"`, `"survival horror"`, `"indie platformer"` |
| `app_ids` | array or string | `[]` | Steam App IDs — used in `app` mode. Comma or newline-separated string also accepted |
| `app_url` | string | `""` | Single Steam game page URL — App ID is extracted automatically |
| `max_results` | integer | `20` | Maximum games to return |
| `max_reviews` | integer | `0` | Maximum **Steam game reviews** per game. Set to `0` to skip review extraction |
| `proxyConfiguration` | object | Off | Optional proxy config — Steam works without proxy for most runs |

***

### 📋 Output Fields

#### 🎮 Game Data Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `app_id` | string | Steam App ID | `"1091500"` |
| `name` | string | Game title | `"Cyberpunk 2077"` |
| `type` | string | Content type | `"game"`, `"dlc"` |
| `description` | string | Short description | `"An open-world action RPG..."` |
| `url` | string | Steam store page URL | `"https://store.steampowered.com/app/..."` |
| `header_image` | string | Header image URL | `"https://cdn.cloudflare.steamstatic.com/..."` |
| `screenshots` | array | Up to 5 screenshot URLs | `["https://...", "https://..."]` |
| `developers` | array | Developer names | `["CD PROJEKT RED"]` |
| `publishers` | array | Publisher names | `["CD PROJEKT RED"]` |
| `release_date` | string | Release date | `"December 10, 2020"` |
| `is_free` | boolean | Free to play | `false` |
| `price` | string | Current price | `"$29.99"` |
| `price_original` | string | Original price | `"$59.99"` |
| `discount_percent` | integer | Discount percentage | `50` |
| `genres` | array | Genre tags | `["Action", "RPG"]` |
| `platforms` | object | Windows / Mac / Linux support | `{"windows":true,"mac":false,"linux":false}` |
| `metacritic_score` | integer | Metacritic score | `86` |
| `total_recommendations` | integer | Total Steam recommendations | `420000` |
| `achievements_count` | integer | Total achievements | `45` |
| `dlc_count` | integer | Number of DLC items | `3` |
| `min_requirements` | string | Minimum system requirements | `"OS: Windows 10..."` |
| `rec_requirements` | string | Recommended requirements | `"OS: Windows 10..."` |

#### ⭐ Steam Game Reviews Fields *(when `max_reviews > 0`)*

| Field | Type | Description | Example |
|---|---|---|---|
| `review_id` | string | Unique Steam review ID | `"148674291"` |
| `recommended` | boolean | Thumbs up or thumbs down | `true` |
| `review_text` | string | Full review text (max 3000 chars) | `"One of the best RPGs I have played..."` |
| `author_playtime_h` | float | Author playtime in hours | `187.4` |
| `votes_helpful` | integer | Helpful votes | `89` |
| `votes_funny` | integer | Funny votes | `8` |
| `steam_purchase` | boolean | Purchased on Steam | `true` |
| `early_access` | boolean | Written during Early Access | `false` |
| `language` | string | Review language | `"english"` |
| `timestamp` | integer | Unix timestamp | `1710504600` |

***

### 📦 Example Input & Output

**Input:**

```json
{
  "mode":        "search",
  "query":       "survival horror",
  "max_results": 3,
  "max_reviews": 5
}
```

**Output (one record):**

```json
{
  "app_id":      "1091500",
  "name":        "Cyberpunk 2077",
  "price":       "$29.99",
  "discount_percent": 50,
  "genres":      ["Action", "RPG"],
  "developers":  ["CD PROJEKT RED"],
  "release_date":"December 10, 2020",
  "metacritic_score": 86,
  "total_recommendations": 420000,
  "platforms":   { "windows": true, "mac": false, "linux": false },
  "reviews": [
    {
      "recommended":      true,
      "review_text":      "One of the best RPGs I have played in years.",
      "author_playtime_h":187.4,
      "votes_helpful":    89,
      "steam_purchase":   true,
      "language":         "english"
    }
  ]
}
```

***

### 💰 Pricing & Free Trial

| Plan | Price | Includes |
|---|---|---|
| **Free Trial** | $0 | 2 hours full access — no credit card required |
| **Monthly** | $7.99 / month | Unlimited runs, all modes, game data + reviews |

#### Everything included in every plan:

- ✅ Full Steam game data — 25+ fields per game
- ✅ Steam game reviews — optional, paginated, any volume
- ✅ Search, App ID bulk, and featured/trending modes
- ✅ Price, discount, Metacritic score, system requirements
- ✅ Screenshots, DLC count, achievement count
- ✅ Platform support (Windows, Mac, Linux)
- ✅ No login or API key required
- ✅ JSON + CSV + Excel export from Apify dataset
- ✅ Scheduled runs for price and review monitoring

> **Start your 2-hour free trial now** — no credit card needed. Click **Try for free** at the top of this page.

***

### ⚡ Performance & Limits

| Mode | Games | Estimated Time |
|---|---|---|
| Search (no reviews) | 20 | ~2–4 minutes |
| App IDs bulk (no reviews) | 20 | ~3–5 minutes |
| Featured list | 30 | ~4–6 minutes |
| With reviews (50/game) | 10 games | ~8–15 minutes |

- Results pushed to dataset in real time as each game is processed
- Steam game reviews are paginated automatically up to `max_reviews`
- No proxy required for most Steam requests
- Automatic rate limiting between requests to prevent throttling

***

### ❓ FAQ

**Q: Do I need a Steam account or API key?**
A: No. This **Steam scraper** uses Steam's public store endpoints — no account, no login, and no Steam API key is required.

**Q: How do I find a game's App ID?**
A: Go to the game's Steam store page. The App ID is the number in the URL — `store.steampowered.com/app/570/` means App ID `570`. You can also paste the full Steam URL into `app_url` and the actor extracts the ID automatically.

**Q: What does `max_reviews: 0` mean?**
A: Setting `max_reviews` to `0` (the default) skips **Steam game reviews** entirely and only returns game metadata. Set it to any positive number to enable review extraction.

**Q: What is `featured` mode?**
A: Featured mode fetches Steam's current new releases, top sellers, and specials — giving you trending games across three categories in a single run.

**Q: Can I scrape reviews from a specific game without fetching game data?**
A: Set `mode` to `"app"`, provide the App ID, and set `max_reviews` to your desired count. Both game data and reviews are returned together.

**Q: Can I export results to Excel or CSV?**
A: Yes. All results are pushed to the Apify dataset, which can be exported to JSON, CSV, Excel, and more from the Apify Console after the run completes.

***

### 📜 Changelog

#### v1.0.0 (Current)

- ✅ Three modes: keyword search, bulk App ID, and featured/trending
- ✅ Full Steam game data — 25+ fields per game
- ✅ Optional Steam game reviews with automatic pagination
- ✅ Price, discount percent, and currency per game
- ✅ Metacritic score and URL
- ✅ System requirements (min and recommended)
- ✅ Up to 5 screenshots per game
- ✅ Platform support flags (Windows, Mac, Linux)
- ✅ DLC count and achievement count
- ✅ Steam URL input with automatic App ID extraction
- ✅ No login or API key required
- ✅ Real-time dataset push as each game is processed

***

### 🏷️ Tags

`steam scraper` `steam game data` `steam game reviews` `steam store scraper` `game data extractor` `steam price tracker` `steam review scraper` `game metadata scraper` `steam app data` `gaming data scraper` `steam featured games` `game market research`

***

### ⚖️ Legal & Terms of Use

This actor accesses publicly visible game and review data on the Steam Store in the same way a regular user browses the platform.

**Please note:**

- Use extracted **Steam game data** only for **lawful purposes** — market research, game discovery, price tracking, academic research, and developer analytics are common legitimate uses
- Do not republish Steam store content or reviews in a way that violates Valve's Terms of Service
- Game descriptions, screenshots, and metadata are copyright of the respective developers and publishers
- Player review content belongs to original Steam reviewers — do not republish without appropriate attribution
- The actor developer is not responsible for how extracted data is used

***

### 🤝 Support & Feedback

- **Bug report?** Contact us via the Apify actor page
- **Feature request?** Post in the Apify Community forum
- **Loving it?** Please leave a ⭐ review — it helps other users find this actor!

***

<p align="center">
  <strong>Built with ❤️ on Apify</strong><br/>
  <em>The most complete Steam Scraper — full game data, reviews, search & featured lists</em><br/><br/>
  <strong>💰 $7.99/month · 🆓 2-hour free trial · No credit card required</strong>
</p>

# Actor input Schema

## `mode` (type: `string`):

What to scrape from Steam

## `query` (type: `string`):

Game name or keywords to search. E.g: 'action RPG', 'indie horror', 'multiplayer'

## `app_ids` (type: `string`):

Steam App IDs to scrape. Find in the game's Steam URL. E.g: 730 (CS2), 570 (Dota 2). One per line.

## `app_url` (type: `string`):

Full Steam store URL of a specific game

## `max_results` (type: `integer`):

Maximum number of games to return

## `max_reviews` (type: `integer`):

Number of reviews to fetch per game. 0 = no reviews.

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

Steam usually works without proxy, but RESIDENTIAL proxy helps avoid rate limits.

## Actor input object example

```json
{
  "mode": "search",
  "query": "action RPG",
  "max_results": 20,
  "max_reviews": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "query": "action RPG",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/steam-scraper----game-data-reviews-store-intelligence").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 = {
    "query": "action RPG",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/steam-scraper----game-data-reviews-store-intelligence").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 '{
  "query": "action RPG",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapepilot/steam-scraper----game-data-reviews-store-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Scraper — Game Data, Reviews & Store Intelligence",
        "description": "Scrape Steam game data and reviews from any game, keyword search, or trending list. Get price, discount, genres, Metacritic score, system requirements, screenshots, and paginated player reviews. No login, no API key. $7.99/month. 2-hour free trial.",
        "version": "0.0",
        "x-build-id": "BLP1UqfAF1OEmD73j"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~steam-scraper----game-data-reviews-store-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-steam-scraper----game-data-reviews-store-intelligence",
                "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/scrapepilot~steam-scraper----game-data-reviews-store-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-steam-scraper----game-data-reviews-store-intelligence",
                "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/scrapepilot~steam-scraper----game-data-reviews-store-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-steam-scraper----game-data-reviews-store-intelligence",
                "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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "app",
                            "featured"
                        ],
                        "type": "string",
                        "description": "What to scrape from Steam",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Game name or keywords to search. E.g: 'action RPG', 'indie horror', 'multiplayer'"
                    },
                    "app_ids": {
                        "title": "App IDs",
                        "type": "string",
                        "description": "Steam App IDs to scrape. Find in the game's Steam URL. E.g: 730 (CS2), 570 (Dota 2). One per line."
                    },
                    "app_url": {
                        "title": "Steam Game URL",
                        "type": "string",
                        "description": "Full Steam store URL of a specific game"
                    },
                    "max_results": {
                        "title": "Max Games",
                        "type": "integer",
                        "description": "Maximum number of games to return",
                        "default": 20
                    },
                    "max_reviews": {
                        "title": "Max Reviews Per Game",
                        "type": "integer",
                        "description": "Number of reviews to fetch per game. 0 = no reviews.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (Optional)",
                        "type": "object",
                        "description": "Steam usually works without proxy, but RESIDENTIAL proxy helps avoid rate limits."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
