# Steam Reviews & Game Data Scraper (`hydrocore/steam-reviews-game-data`) Actor

Get Steam reviews and game data (price, discount, tags, genres, Metacritic, review score, live player count) from Steam's official public endpoints. Full review history, filters for language, type, purchase and dates. Reviewer IDs hashed by default. Hard spend caps.

- **URL**: https://apify.com/hydrocore/steam-reviews-game-data.md
- **Developed by:** [Hydrocore Data](https://apify.com/hydrocore) (community)
- **Categories:** E-commerce, Developer tools, Marketing
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Steam Reviews & Game Data Scraper

Get **Steam user reviews** and **game data** in one run, straight from Steam's official public endpoints: no login, no API key, no proxy.
List games by **app ID, store URL or name**, choose your filters, and get clean rows ready for spreadsheets, sentiment analysis, dashboards or AI tools.

- **Full review history** (newest first or recently updated), with filters for language, positive/negative, purchase type and an exact date range
- **Game records** (optional): price, discount, release date, developers, publishers, genres, top user tags, Metacritic, Steam review score and counts, **players online right now**
- **Privacy by default:** reviewer Steam IDs are replaced with a hashed ID unless you turn raw IDs on
- **Hard limits** on reviews per game, reviews per run and money. You never pay for games that weren't found, duplicates or reviews outside your filters. A run that saves nothing costs nothing, not even the start fee.

### Why this one is better

Steam retired its old review endpoint (`store.steampowered.com/appreviews/...?json=1`) on **22 October 2026**; it now redirects to the Steam home page. This Actor is built on its replacement, `IUserReviewsService/GetAppReviews`, and sends every filter as the **number** Steam expects. That detail matters: when filters are sent as words (`"recent"`, `"all"`), Steam silently ignores them and falls back to its short "helpful" list. With the correct values this Actor walks the **whole** history: in our test it paged through all **12,722 of 12,722** English reviews of *A Short Hike*, back to its release in July 2019.

Comparison with the two most-used Steam review Actors on Apify (their public Store pages, plus one small test run of each with the same input on 3 November 2026: Elden Ring, English, negative only, 14-20 Nov 2023):

| | **This Actor** | automation-lab / Steam Game Reviews Scraper | memo23 / Steam Reviews Scraper |
|---|---|---|---|
| **Test result** (Steam reports 28 matching reviews) | **28 reviews** | 0 reviews; the log shows it still calls the retired `appreviews` endpoint ("Invalid JSON after 3 retries"). The $0.003 start fee was charged. Last build 2 Sep 2026. | Works: 25 reviews returned in our run (its own log reported 28 matching) |
| **Price per 1,000 reviews** | **$0.49** (flat) | $0.575 on Free plan, down to $0.14 on Diamond | $1.00 |
| **Start fee** | $0.0025, **only if the run saves at least one row** | $0.003 every run | $0.005 per GB of memory, every run |
| **Input** | App IDs, store/community URLs **and game names** | App IDs, URLs and game names | App IDs and URLs |
| **Game data** (price, discount, tags, genres, Metacritic, review score) | Yes, as separate game records | Optional game info attached to reviews (no price, tags or players listed) | No |
| **Current player count** | Yes | No | No |
| **Date range** | Applied by Steam, works with "Newest first" (full history) | README: dates only work with the "most helpful" sort and it switches to it | Yes, exact window |
| **Reviewer Steam IDs** | **Hashed by default**; raw ID, profile and review links only if you turn them on | Raw Steam ID and profile URL in every row | Raw Steam ID and profile URL in every row |
| **Spend limit** | "Max spend (USD)" input plus Run options' maximum cost, checked before every row | Run options only | Run limit shared across games |
| **Off-topic (review-bomb) filter** | No | No | Yes ("includeOffTopic") |

Prices and features can change; check each Actor's page for the latest. Higher Apify plans get lower prices from automation-lab's tiered pricing, so on Silver plans and above it is cheaper per review than this Actor (when it returns data).

### How to use it

1. Under **Games**, add one game per line: an app ID (`1245620`), a store URL (`https://store.steampowered.com/app/1245620/ELDEN_RING/`) or a name (`Elden Ring`).
2. Set **Max reviews per game** (default 100). Set it to **0** with **Include game details** on to get only game records.
3. Optional: pick a language, positive/negative only, purchase type, sort order or a date range.
4. Optional: set **Max spend (USD)** to cap the cost.
5. Press **Start**. Rows appear in the **Output** tab while the run is going.

For a weekly report, schedule the Actor with **Only the last N days** set to 7.

### What you get

Rows start with `recordType` (`review` or `game`). Rows of the same type always have the same columns in the same order; empty values are `null`, numbers are numbers and dates are ISO 8601 in UTC.

**Review row** (real row from a test run on 2026-11-04, review text shortened):

```json
{
  "recordType": "review",
  "gameName": "ELDEN RING",
  "appId": 1245620,
  "recommended": true,
  "sentiment": "positive",
  "review": "What can I even say that hasn't been said already? Play this game if you haven't already. It's not for everyone, but everyone should at least try it out.",
  "language": "english",
  "createdAt": "2026-11-05T03:59:15.000Z",
  "updatedAt": "2026-11-05T03:59:15.000Z",
  "votesHelpful": 0,
  "votesFunny": 0,
  "helpfulnessScore": 0.5,
  "commentCount": 0,
  "authorPlaytimeAtReviewHours": 546.3,
  "authorPlaytimeForeverHours": 546.3,
  "authorPlaytimeLastTwoWeeksHours": 0,
  "authorDeckPlaytimeAtReviewHours": null,
  "authorNumReviews": 4,
  "authorLastPlayedAt": "2026-06-13T04:22:37.000Z",
  "steamPurchase": false,
  "receivedForFree": false,
  "writtenDuringEarlyAccess": false,
  "primarilySteamDeck": false,
  "refunded": false,
  "edited": false,
  "developerResponse": null,
  "developerRespondedAt": null,
  "hardwareOs": null,
  "hardwareCpu": null,
  "hardwareGpu": null,
  "hardwareRamMb": null,
  "hardwareVramMb": null,
  "recommendationId": "239407584",
  "authorId": "2342fa57770bf7d74bcb",
  "authorSteamId": null,
  "authorProfileUrl": null,
  "reviewUrl": null,
  "gameReviewsUrl": "https://steamcommunity.com/app/1245620/reviews/",
  "scrapedAt": "2026-11-05T04:12:24.798Z"
}
```

**Game record** (`recordType: "game"`, when **Include game details** is on; real row, long lists shortened):

```json
{
  "recordType": "game",
  "gameName": "ELDEN RING",
  "appId": 1245620,
  "appType": "game",
  "price": 59.99,
  "priceBeforeDiscount": 59.99,
  "discountPercent": 0,
  "currency": "USD",
  "priceFormatted": "$59.99",
  "priceCountry": "US",
  "isFree": false,
  "releaseDate": "Feb 24, 2022",
  "releaseDateIso": "2022-02-24",
  "comingSoon": false,
  "reviewScoreLabel": "Very Positive",
  "reviewPercentPositive": 93,
  "reviewCount": 835430,
  "allReviewsTotal": 1161134,
  "allReviewsPositive": 1080476,
  "allReviewsNegative": 80658,
  "recommendationsTotal": 835430,
  "currentPlayers": 15769,
  "metacriticScore": 94,
  "metacriticUrl": "https://www.metacritic.com/game/pc/elden-ring?ftag=MCD-06-10aaa1f",
  "developers": [
    "FromSoftware, Inc."
  ],
  "publishers": [
    "FromSoftware, Inc.",
    "Bandai Namco Entertainment"
  ],
  "genres": [
    "Action",
    "RPG"
  ],
  "categories": [
    "Single-player",
    "Multi-player",
    "PvP",
    "Online PvP",
    "Co-op",
    "..."
  ],
  "tags": [
    "Souls-like",
    "Open World",
    "Dark Fantasy",
    "RPG",
    "Difficult",
    "..."
  ],
  "platformWindows": true,
  "platformMac": false,
  "platformLinux": false,
  "requiredAge": 16,
  "supportedLanguages": [
    "English",
    "French",
    "Italian",
    "German",
    "Spanish - Spain",
    "..."
  ],
  "fullAudioLanguages": [
    "English"
  ],
  "dlcCount": 3,
  "achievementsTotal": 42,
  "storeUrl": "https://store.steampowered.com/app/1245620/",
  "website": null,
  "headerImage": "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/1245620/header.jpg?t=1790290043",
  "shortDescription": "THE CRITICALLY ACCLAIMED FANTASY ACTION RPG. Rise, Tarnished, and be guided by grace to brandish the power of the Eld...",
  "scrapedAt": "2026-11-05T04:12:24.584Z"
}
```

**Views.** The Output tab opens in **Overview (reviews)**. There are also **Games**, **Review signals** (a compact table without the long text), **Reviewer hardware** and **Detailed** (every field) views. Download as JSON, CSV, Excel or HTML, or use the API, Make, Zapier, n8n or the Apify MCP server.

**Sorting and filters.** *Sort* picks Steam's order (most recent, recently updated or most helpful). Filters for language, positive/negative, purchase type, dates and **Minimum playtime at review** are applied before the per-game and total limits; skipped reviews are free. Reviews with the same ID are saved only once.

> Changed in v1.1: game rows use `gameName` (was `name`) and `appType` (was `type`); the nested `platforms` object is now `platformWindows`, `platformMac`, `platformLinux`; the nested review `hardware` object is now `hardwareOs`, `hardwareCpu`, `hardwareGpu`, `hardwareRamMb`, `hardwareVramMb`; columns are in a fixed order; new `minPlaytimeHours` filter.

The `RUN_SUMMARY` record in the key-value store lists, for each game, how many reviews were saved, how many Steam reports for your filters, how many duplicates or out-of-range reviews were skipped (free), which inputs weren't found (free), the total charged and why the run stopped.

#### Review fields

| Field | Meaning |
|---|---|
| `appId`, `gameName` | The game |
| `recommendationId` | Steam's review ID (used to remove duplicates) |
| `recommended`, `sentiment` | Thumbs up/down, as true/false and as "positive"/"negative" |
| `review`, `language` | Review text and its language |
| `createdAt`, `updatedAt`, `edited` | Posted and last edited (UTC) |
| `votesHelpful`, `votesFunny`, `helpfulnessScore`, `commentCount` | Community reactions |
| `steamPurchase`, `receivedForFree`, `writtenDuringEarlyAccess`, `primarilySteamDeck`, `refunded` | Steam's flags on the review |
| `authorId` | Hashed reviewer ID (see Privacy) |
| `authorNumReviews`, `authorPlaytime...Hours`, `authorLastPlayedAt` | Reviewer's review count and playtime in hours |
| `developerResponse`, `developerRespondedAt` | The developer's public reply, if any |
| `hardwareOs`, `hardwareCpu`, `hardwareGpu`, `hardwareRamMb`, `hardwareVramMb` | PC specs, only if the reviewer chose to show them |
| `authorSteamId`, `authorProfileUrl`, `reviewUrl` | Only with **Include reviewers' raw Steam IDs** on |

#### Game record fields

| Field | Meaning |
|---|---|
| `gameName`, `appType`, `storeUrl` | Name, item type (game, dlc...) and store link |
| `price`, `priceBeforeDiscount`, `discountPercent`, `currency`, `priceFormatted`, `priceCountry`, `isFree` | Current price in the store country you chose |
| `releaseDate`, `releaseDateIso`, `comingSoon` | Release information |
| `developers`, `publishers`, `genres`, `categories`, `tags` | Who made it and how Steam and players classify it |
| `metacriticScore`, `metacriticUrl` | Metacritic score shown on Steam |
| `reviewScoreLabel`, `reviewPercentPositive`, `reviewCount` | The summary shown on the store page |
| `allReviewsTotal`, `allReviewsPositive`, `allReviewsNegative` | All reviews in every language, including key activations |
| `currentPlayers` | Players in the game at scrape time |
| `platformWindows`, `platformMac`, `platformLinux`, `requiredAge`, `supportedLanguages`, `fullAudioLanguages`, `shortDescription`, `website`, `headerImage`, `dlcCount`, `achievementsTotal`, `recommendationsTotal` | Other store data |

### Pricing

Pay per event. You only pay for rows saved to your dataset, plus a small start fee once the run has saved something. No platform usage charges on top.

| Event | Price | Per 1,000 |
|---|---|---|
| **Review** (one review saved) | $0.00049 | $0.49 |
| **Game record** (one game's details saved) | $0.00077 | $0.77 |
| **Actor start** (once per run, only if at least one row is saved) | $0.0025 | |

Examples: 50 reviews of one game = $0.0025 + 50 × $0.00049 = **$0.027**. 1,000 reviews = **$0.49** + $0.0025. Details for 100 games, no reviews = $0.077 + $0.0025 = **$0.08**.

**Never charged:** games or names that weren't found, invalid URLs, duplicate reviews (same review ID), reviews outside your date range, reviews without text, failed requests, and runs that save nothing at all.

### Input options

| Option | Default | What it does |
|---|---|---|
| Games | (required) | App IDs, Steam store/community URLs or game names, one per line |
| Max reviews per game | 100 | Stop after this many reviews per game. 0 = no reviews (game records only) |
| Max reviews in total | 0 (off) | Hard limit for the whole run |
| Include game details | off | Add one game record per game |
| Review language | All languages | One Steam language, or all |
| Review type | All | Positive only, negative only, or both |
| Purchase type | All reviewers | Bought on Steam, not bought on Steam (keys, gifts), or all |
| Sort order | Newest first | Newest first, recently updated (both full history), or most helpful (short list) |
| Reviews written on or after / on or before | none | Date range (UTC, whole days) |
| Only the last N days | 0 (off) | Shortcut for scheduled runs |
| Minimum playtime at review (hours) | 0 (off) | Keep only reviews written after at least this much playtime; skipped reviews are free |
| Store country for prices | us | Two-letter country code for prices and currency |
| Include reviewers' raw Steam IDs | off | Adds raw Steam ID, profile URL and review URL |
| Your own hashing secret | none | Your own key for the hashed reviewer IDs |
| Max spend (USD) | none | Stop before charging more than this |

Example input:

```json
{
  "games": ["1245620", "https://store.steampowered.com/app/1055540/A_Short_Hike/", "Hades"],
  "maxReviewsPerGame": 200,
  "language": "english",
  "reviewType": "negative",
  "startDate": "2026-01-01",
  "includeGameDetails": true,
  "maxSpendUsd": 1
}
```

### FAQ

**Do I need a Steam account or API key?**
No. Everything comes from Steam's public endpoints that anyone can open without logging in.

**Can it really get all reviews of a big game?**
Yes, with **Newest first** or **Recently updated** sorting. Set **Max reviews per game** high enough. Big games take a while: Steam returns 100 reviews per request, and the Actor waits at least 0.3 seconds between requests to be polite, so expect roughly 8,000-15,000 reviews per minute (our test run saved 3,000 Elden Ring reviews in 23 seconds). Keep an eye on the cost: 100,000 reviews cost $49.

**Why does "Most helpful" return only a few hundred reviews?**
Steam caps that list itself, so the Actor can't page past it. For complete data, use **Newest first**.

**How does name search work?**
The Actor uses Steam's store search and picks an exact name match if there is one, otherwise the top result. The run log shows which game was picked and the other close matches. If the wrong game is picked, use the app ID (the number after `/app/` in the store URL).

**Why are there fewer reviews than the number on the store page?**
The store page counts reviews in all languages from Steam purchasers. Your filters (language, type, purchase type, dates) narrow that down. The log and `RUN_SUMMARY` show how many reviews Steam reports for your exact filters.

**Why does "Bought on Steam" return nothing for a free game?**
Steam doesn't count free-to-play installs as purchases. Use **All reviewers** for free games.

**How do I make sure I never spend more than a set amount?**
Set **Max spend (USD)**, or **Maximum cost per run** in Run options (the lower one wins). The Actor checks the limit before saving each batch and stops before it would go over. **Max reviews per game** and **Max reviews in total** are extra hard stops.

**What happens if Steam is slow or limits requests?**
The Actor retries network errors, timeouts and "too many requests" answers with growing pauses (up to 6 attempts) and follows Steam's Retry-After header. If a game still fails, it keeps what was saved, notes the problem in `RUN_SUMMARY` and moves on to the next game. Failed requests are never charged.

**What is the hashed reviewer ID?**
`authorId` is an HMAC-SHA256 hash of the reviewer's Steam ID with a secret key. The same reviewer gets the same `authorId` in all your runs, so you can count repeat reviewers, but the ID can't be turned back into a Steam profile. By default the key is tied to your Apify account; set **Your own hashing secret** to control it yourself.

**Is it legal? What about privacy?**
The Actor only reads data that Steam publishes openly without a login, through Steam's own public endpoints, at a polite rate. Reviews are written by real people, so they are personal data in many countries (for example under the GDPR) even though they are public. That's why reviewer Steam IDs are hashed by default and no names or avatars are collected. Review text can still contain personal details, so use the data for a clear purpose (such as product research or sentiment analysis), keep only what you need, and don't use it to contact or profile individual players. Steam's terms and copyright in the review texts also apply to what you do with the data. This Actor is not affiliated with or endorsed by Valve. If in doubt, ask a lawyer.

**Will a run ever fail because one game is wrong?**
No. Invalid app IDs, unknown names and URLs without an app ID are logged, listed in `RUN_SUMMARY` and skipped for free; the other games are still collected and the run finishes normally.

**Something doesn't work.**
Open an issue on the Issues tab with the run link. Every run ends with a clear status message and a `RUN_SUMMARY`.

# Actor input Schema

## `games` (type: `array`):

One game per line. Use a Steam app ID (1245620), a Steam store or community URL (https://store.steampowered.com/app/1245620/ELDEN_RING/) or a game name (Elden Ring). Names are looked up with Steam's store search and the closest match is used; the run log shows which game was picked. The same game listed twice is collected once.

## `maxReviewsPerGame` (type: `integer`):

Stop collecting a game's reviews after this many. Set 0 to skip reviews and get only game records (turn on "Include game details"). With "Newest first" or "Recently updated" sorting the Actor can go through a game's full review history.

## `maxReviewsTotal` (type: `integer`):

Optional hard limit for the whole run across all games. The run stops when it is reached. 0 means no run-wide limit (only "Max reviews per game" applies).

## `includeGameDetails` (type: `boolean`):

Also save one game record per game: name, price, discount, currency, release date, developers, publishers, genres, categories, top user tags, Metacritic score, Steam review score and counts, current player count, platforms, languages and more. Charged as one "Game record" each.

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

Only reviews written in this language. "All languages" usually returns several times more reviews than English alone.

## `reviewType` (type: `string`):

Only positive ("Recommended") or only negative ("Not Recommended") reviews, or both.

## `purchaseType` (type: `string`):

Filter by how the reviewer got the game. Note: for free-to-play games Steam counts no one as "Bought on Steam", so use "All reviewers" for those.

## `sort` (type: `string`):

"Newest first" and "Recently updated" can page through every review a game has. Steam's "Most helpful" list is short: it only holds the top few hundred reviews, so use it for a quick sample.

## `startDate` (type: `string`):

Optional. Only reviews created on or after this date (YYYY-MM-DD, UTC). The window is applied by Steam and checked again by the Actor, so old windows are as fast as recent ones.

## `endDate` (type: `string`):

Optional. Only reviews created on or before this date (YYYY-MM-DD, UTC). The whole day is included.

## `lastDays` (type: `integer`):

Optional shortcut for scheduled runs: only reviews from the last N days (for example 7 for a weekly run). 0 means off. If you also set a start date, the later of the two is used.

## `minPlaytimeHours` (type: `integer`):

Only keep reviews whose author had played at least this many hours when writing the review. 0 = keep all. Skipped reviews are not charged.

## `countryCode` (type: `string`):

Two-letter country code used for game prices and discounts, for example us, gb, de, br or jp. Prices are shown in that store's currency.

## `includeRawSteamId` (type: `boolean`):

Off by default. Each review then has a hashed reviewer ID (authorId) that stays the same for the same reviewer across your runs but can't be traced back to a Steam profile. Turn this on only if you need the public Steam ID, profile URL and review URL, and make sure you have a lawful reason to process them.

## `hashSalt` (type: `string`):

Optional. A secret of your choice used to hash reviewer IDs. Use the same secret to get matching IDs across accounts or tools; change it to make old IDs unlinkable. If empty, a key tied to your Apify account is used.

## `maxSpendUsd` (type: `number`):

Optional. The run stops before it would charge more than this amount in total (start fee included). Leave empty for no extra limit. The "Maximum cost per run" in Run options is always respected too.

## Actor input object example

```json
{
  "games": [
    "1245620",
    "https://store.steampowered.com/app/1055540/A_Short_Hike/",
    "Hades"
  ],
  "maxReviewsPerGame": 50,
  "maxReviewsTotal": 0,
  "includeGameDetails": false,
  "language": "all",
  "reviewType": "all",
  "purchaseType": "all",
  "sort": "recent",
  "lastDays": 0,
  "minPlaytimeHours": 0,
  "countryCode": "us",
  "includeRawSteamId": false
}
```

# Actor output Schema

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

Reviews with game, verdict, text, language, date, votes and playtime.

## `games` (type: `string`):

One row per game with price, discount, tags, genres, scores and current players (when "Include game details" is on).

## `hardware` (type: `string`):

Reviews with the reviewer's OS, CPU, GPU and memory, when Steam shares it.

## `results` (type: `string`):

Every saved row. Review rows have recordType "review", game records have recordType "game".

## `summary` (type: `string`):

Per game: reviews saved, reviews Steam reports for your filters, duplicates and out-of-range reviews skipped (free), inputs not found (free); plus total charged and why the run stopped.

# 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 = {
    "games": [
        "1245620",
        "https://store.steampowered.com/app/1055540/A_Short_Hike/",
        "Hades"
    ],
    "maxReviewsPerGame": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("hydrocore/steam-reviews-game-data").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 = {
    "games": [
        "1245620",
        "https://store.steampowered.com/app/1055540/A_Short_Hike/",
        "Hades",
    ],
    "maxReviewsPerGame": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("hydrocore/steam-reviews-game-data").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "games": [
    "1245620",
    "https://store.steampowered.com/app/1055540/A_Short_Hike/",
    "Hades"
  ],
  "maxReviewsPerGame": 50
}' |
apify call hydrocore/steam-reviews-game-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hydrocore/steam-reviews-game-data"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/LsOiHj5tnv6bG2cNO/builds/4GHu4PsptoF5Ss2f3/openapi.json