# Steam Game & Review Scraper — Prices, Details & Reviews (`haketa/steam-game-scraper`) Actor

Scrape Steam games: title, price & discount, genres, developer, publisher, release date, Metacritic, platforms, achievements, screenshots plus review score and reviews. Search or by app ID, any country. For price tracking, market and review research. Not affiliated with Steam or Valve.

- **URL**: https://apify.com/haketa/steam-game-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

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/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 Game & Review Scraper — Prices, Discounts, Details & Reviews

> **The ultimate Steam scraper for extracting complete PC game catalogs, live promotional pricing, global currency rates, Metacritic scores, player review sentiment, and system requirements from the [Steam Store](https://store.steampowered.com) — without an API key, login hurdles, or browser overhead.** Search by any gaming keyword or provide exact Steam App IDs to harvest structured data ready for market research, price tracking, and sentiment analysis.

[![Steam Store](https://img.shields.io/badge/Steam-Store%20Catalog-1b2838?style=for-the-badge\&logo=steam\&logoColor=white)](https://apify.com/haketa/steam-game-scraper)
[![Prices & Discounts](https://img.shields.io/badge/Prices%20%26%20Discounts-2da44e?style=for-the-badge\&logo=pricetag\&logoColor=white)](https://apify.com/haketa/steam-game-scraper)
[![Reviews & Sentiment](https://img.shields.io/badge/Reviews%20%26%20Sentiment-0077b6?style=for-the-badge\&logo=star\&logoColor=white)](https://apify.com/haketa/steam-game-scraper)
[![Export Formats](https://img.shields.io/badge/Export-JSON%20%2F%20CSV%20%2F%20Excel-fb8500?style=for-the-badge\&logo=airplayvideo\&logoColor=white)](https://apify.com/haketa/steam-game-scraper)
[![Deep Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B%20Unlocked-8250df?style=for-the-badge\&logo=databricks\&logoColor=white)](https://apify.com/haketa/steam-game-scraper)

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Data Target** | Official Steam Storefront game profiles, pricing, DLC, and review databases |
| **Input Options** | Search keywords (`roguelike`, `rpg`, `zombie`), or direct Steam App IDs (`730`, `1091500`) |
| **Output Formats** | JSON, CSV, Excel, XML, HTML, API endpoint |
| **Pricing Intelligence**| Current price, pre-discount price, discount %, currency, and regional pricing |
| **Review Telemetry** | Aggregate review score, positive review %, total positive/negative counts, and optional review texts |
| **Technical Metadata** | Developers, publishers, genres, tags, Metacritic scores, system compatibility, languages |
| **Pagination Capability**| Unlocked 1,000+ deep pagination (50 games/page, `0` = auto/unlimited) |
| **Proxy Support** | Compatible with Apify Datacenter proxies (default on, ultra-low cost) |
| **Processing Speed** | Up to 8 games per second via concurrent batch requests |

***

### 🔎 Why scrape Steam store data?

Steam is the undisputed epicenter of PC gaming, hosting tens of thousands of video games, expansive downloadable content (DLC), and billions of player reviews. The Steam storefront holds critical business and market telemetry: competitive pricing benchmarks, promotional discount depths, publisher release schedules, hardware compatibility, and authentic customer sentiment signals.

Collecting this rich information manually or through fragile DOM scrapers is time-consuming and computationally heavy. Modern game storefronts dynamically render content, gate adult content behind age confirmation checks, and localize pricing based on geographic regions.

This **Steam game scraper** provides a clean, enterprise-grade data extraction pipeline. It communicates directly with public storefront APIs to extract complete game manifests, regional currencies, and review histograms concurrently. You get clean, de-duplicated records delivered directly to your data warehouse or BI dashboard.

#### Primary Use Cases

- **Game publishers & indie market intelligence** — Analyze competitor launch prices, discount cadences, genre tagging, and player review velocity to inform marketing strategies.
- **Price tracking & sale alert platforms** — Build automated price-drop notification services, seasonal sale monitors, and international price comparison tools.
- **Sentiment & player reception analysis** — Measure how community sentiment evolves over time by monitoring positive review percentages and review score labels.
- **Hardware & platform analytics** — Track the market adoption of operating systems (Windows, macOS, Linux/SteamOS) and controller compatibility.
- **Catalog discovery for media & affiliate portals** — Power gaming news portals, deal roundups, and recommendation engines with fresh, structured game metadata.
- **Machine learning & academic research** — Train sentiment models on game descriptions, user reviews, and developer release histories.

***

### ✨ Key Features & Capabilities

- ✅ **Keyword search with deep pagination** — Query Steam with natural terms (`deckbuilder`, `survival horror`, `vr`) and paginate hundreds of results deep (`maxPagesPerSearch: 0` = uncapped).
- ✅ **Direct Steam App ID ingestion** — Provide specific game identifiers (e.g. `730` for Counter-Strike 2, `1091500` for Cyberpunk 2077) for instant targeted extraction.
- ✅ **Multi-currency regional pricing** — Configure any ISO country code (`us`, `gb`, `de`, `tr`, `jp`) to evaluate regional pricing strategies and currency fluctuations.
- ✅ **Comprehensive review intelligence** — Captures total reviews, positive/negative breakdown, positive review percentage, and official qualitative rating labels (*Overwhelmingly Positive*, *Mixed*).
- ✅ **Optional verbatim review texts** — Retrieve individual written player reviews with playtime hours, helpfulness votes, and purchase verification flags.
- ✅ **Automated deduplication** — Automatic de-duplication across multi-keyword queries ensures each unique App ID appears only once in your dataset.
- ✅ **High-speed concurrent batching** — Retrieves game manifests in parallel batches of 8, allowing extraction of 500+ games in under 3 minutes.
- ✅ **Universal export & integrations** — Download datasets in CSV, Excel, or JSON format, or route records directly to Google Sheets, Make, Zapier, and webhooks.

***

### 📥 Input Parameters

All parameters are optional. Running the Actor with default inputs triggers a fast sample run of 50 popular games under the `"roguelike"` genre.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | array | `["roguelike"]` | Search keywords to discover games on Steam. |
| `appIds` | array | `[]` | Specific Steam App IDs to scrape directly (e.g. `["730", "1091500"]`). |
| `includeReviews` | boolean | `true` | Fetch aggregate review scores, ratings, and positive/negative totals. |
| `maxReviewsPerGame` | integer | `0` | Number of individual review text bodies to fetch per game (`0` = summary totals only). |
| `reviewFilter` | string | `"recent"` | Sorting order for review texts: `recent`, `updated`, or `all` (most helpful). |
| `country` | string | `"us"` | Two-letter country code determining currency and regional store pricing (`us`, `gb`, `de`, `tr`). |
| `language` | string | `"english"` | Target language for game titles, descriptions, and genres. |
| `maxItems` | integer | `0` | Hard cap on total games scraped. Set to `0` for unlimited (governed by search hits). |
| `maxPagesPerSearch` | integer | `0` | Maximum pages per search term (50 games/page). Set to `0` for unlimited pagination. |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Apify Datacenter proxies are standard and cost-effective. |

***

### 💡 Example Inputs

#### Example 1: Track prices and discounts across popular RPGs

```json
{
  "searchTerms": ["open world rpg", "action rpg"],
  "country": "us",
  "language": "english",
  "includeReviews": true,
  "maxReviewsPerGame": 0,
  "maxItems": 200,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

#### Example 2: Scrape exact games and harvest player reviews

```json
{
  "appIds": ["1091500", "1245620", "252490"],
  "includeReviews": true,
  "maxReviewsPerGame": 25,
  "reviewFilter": "all",
  "country": "us"
}
```

***

### 📤 Output Data Structure

The Actor pushes clean, structured game records directly to the default dataset. Below is a real verified output item:

```json
{
  "appId": 252490,
  "name": "Rust",
  "type": "game",
  "url": "https://store.steampowered.com/app/252490",
  "isFree": false,
  "price": 19.99,
  "priceInitial": 39.99,
  "discountPercent": 50,
  "currency": "USD",
  "priceFormatted": "$19.99",
  "priceInitialFormatted": "$39.99",
  "releaseDate": "Feb 8, 2018",
  "comingSoon": false,
  "developers": ["Facepunch Studios"],
  "publishers": ["Facepunch Studios"],
  "genres": ["Action", "Adventure", "Indie", "Massively Multiplayer", "RPG"],
  "categories": ["Multi-player", "MMO", "PvP", "Online PvP", "Co-op"],
  "metacriticScore": 69,
  "metacriticUrl": "https://www.metacritic.com/game/pc/rust",
  "recommendationsTotal": 1178418,
  "achievementsTotal": 116,
  "dlcCount": 5,
  "platformWindows": true,
  "platformMac": true,
  "platformLinux": false,
  "controllerSupport": "partial",
  "requiredAge": 0,
  "shortDescription": "The only aim in Rust is to survive. Everything wants you to die - the island’s wildlife and other inhabitants...",
  "supportedLanguages": "English, French, Italian, German, Spanish - Spain, Japanese",
  "website": "http://rust.facepunch.com/",
  "headerImage": "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/252490/header.jpg",
  "screenshots": [
    "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/252490/ss_271feae6.jpg"
  ],
  "contentDescriptors": "Contains violence and caveman themed nudity.",
  "reviewScoreDesc": "Very Positive",
  "reviewScore": 8,
  "totalReviews": 1284573,
  "totalPositive": 1112274,
  "totalNegative": 172299,
  "positivePercent": 87,
  "scrapedAt": "2026-11-10T14:48:12.342Z"
}
```

***

### 📊 Extracted Field Reference & Coverage

#### 🎮 Game Identity & Catalog Metadata

| Field | Type | Description | Coverage |
|---|---|---|---|
| `appId` | number | Unique Steam application ID | 🟢 High (100%) |
| `name` | string | Official game title | 🟢 High (100%) |
| `type` | string | Catalog entry type (`game`, `dlc`, `demo`, `mod`) | 🟢 High (100%) |
| `url` | string | Canonical link to Steam store page | 🟢 High (100%) |
| `developers` | array | Development studios credited | 🟢 High (100%) |
| `publishers` | array | Publishing entities credited | 🟢 High (100%) |
| `genres` | array | Primary genre classifications (Action, RPG, Strategy) | 🟢 High (98%) |
| `categories` | array | Feature tags (Multi-player, Steam Cloud, Achievements) | 🟢 High (98%) |
| `releaseDate` | string | Stated release date string | 🟢 High (100%) |
| `comingSoon` | boolean | Indicates whether game is unreleased | 🟢 High (100%) |

#### 💵 Commercial Pricing & Discounts

| Field | Type | Description | Coverage |
|---|---|---|---|
| `isFree` | boolean | Indicates free-to-play status | 🟢 High (100%) |
| `price` | number | Final payable price in selected currency | 🟢 High (~88%) |
| `priceInitial` | number | Baseline price prior to active discount | 🟢 High (~88%) |
| `discountPercent` | number | Current promotional discount percentage (`0` if not on sale) | 🟢 High (~88%) |
| `currency` | string | Three-letter ISO currency code (`USD`, `EUR`, `GBP`) | 🟢 High (~88%) |
| `priceFormatted` | string | Formatted retail price string (e.g. `"$19.99"`) | 🟢 High (~88%) |
| `priceInitialFormatted` | string | Formatted pre-discount price string | 🟢 High (~88%) |

*(Note: Unreleased games flagged with `comingSoon: true` do not declare pricing until launch.)*

#### ⭐ Sentiment, Ratings & Community Reviews

| Field | Type | Description | Coverage |
|---|---|---|---|
| `reviewScoreDesc` | string | Official qualitative rating (e.g. *Very Positive*, *Mixed*) | 🟢 High (~90%) |
| `positivePercent` | number | Share of total positive user reviews (0 to 100%) | 🟢 High (98%) |
| `totalReviews` | number | Total lifetime customer reviews | 🟢 High (98%) |
| `totalPositive` | number | Total positive upvotes | 🟢 High (98%) |
| `totalNegative` | number | Total negative downvotes | 🟢 High (98%) |
| `metacriticScore` | number | Metacritic aggregate critique score (0 to 100) | 🟡 Conditional (~15%) |
| `metacriticUrl` | string | Link to official Metacritic review breakdown | 🟡 Conditional (~15%) |
| `reviews` | array | List of individual review objects (when enabled) | 🟡 Conditional (Opt-in) |

#### 🖥️ Platform, Media & System Telemetry

| Field | Type | Description | Coverage |
|---|---|---|---|
| `platformWindows` | boolean | Windows OS compatibility | 🟢 High (100%) |
| `platformMac` | boolean | macOS compatibility | 🟢 High (100%) |
| `platformLinux` | boolean | Linux and SteamOS compatibility | 🟢 High (100%) |
| `controllerSupport` | string | Gamepad support level (`full`, `partial`, or empty) | 🟡 Conditional (~50%) |
| `achievementsTotal` | number | Total unlockable Steam achievements | 🟢 High (~75%) |
| `dlcCount` | number | Count of listed expansion DLCs | 🟢 High (100%) |
| `shortDescription` | string | Concise store elevator pitch | 🟢 High (99%) |
| `supportedLanguages` | string | Cleaned text of supported audio and interface languages | 🟢 High (98%) |
| `headerImage` | string | Main landscape banner image URL | 🟢 High (100%) |
| `screenshots` | array | Up to 10 high-resolution screenshot image URLs | 🟢 High (98%) |
| `scrapedAt` | string | ISO 8601 execution timestamp | 🟢 High (100%) |

***

### 🔁 Deep 1,000+ Pagination Architecture

The Actor implements an enterprise-grade pagination pipeline:

1. **Storefront Search Batching**: The discovery engine requests 50 game records per batch directly from the storefront search service.
2. **Infinite Pagination Cap**: When `maxPagesPerSearch` is set to `0`, the scraper automatically advances search offsets across thousands of catalog items until `maxItems` is met or search hits are exhausted.
3. **Multi-Query Orchestration**: You can pass multiple search queries in `searchTerms` (e.g. `["strategy", "tactics", "turn-based"]`); the engine traverses each query and automatically de-duplicates records by unique App ID.
4. **Concurrent Detail Enrichment**: Once App IDs are discovered, game manifests and review summaries are fetched in parallel batches of 8, allowing extraction of 1,000+ games in under 6 minutes.

***

### 🚀 How to Run the Scraper

#### Via Apify Console

1. Open the Actor on Apify Console.
2. Enter your desired search terms in **Search terms** or list specific Steam App IDs.
3. Select your target country code (e.g. `us` for USD, `de` for EUR, `gb` for GBP).
4. Configure **Max games** (`maxItems`) according to your quota (set `0` for uncapped pagination).
5. Click **Start** and monitor real-time progress in the log tab.
6. Export the final dataset in CSV, Excel, or JSON format.

#### Programmatically via Python

```python
from apify_client import ApifyClient

## Initialize client with your Apify API token
client = ApifyClient("YOUR_APIFY_TOKEN")

## Configure target search payload
run_input = {
    "searchTerms": ["survival crafting"],
    "country": "us",
    "language": "english",
    "includeReviews": True,
    "maxItems": 100,
    "maxPagesPerSearch": 0
}

## Run Actor and stream records
run = client.actor("haketa/steam-game-scraper").call(run_input=run_input)
dataset = client.dataset(run["defaultDatasetId"])

## Filter games with positive reviews and active discounts
for game in dataset.iterate_items():
    if game.get("discountPercent", 0) > 0 and game.get("positivePercent", 0) >= 80:
        print(f"🔥 {game['name']} - {game['discountPercent']}% OFF -> {game['priceFormatted']} ({game['positivePercent']}% Positive)")
```

#### Programmatically via Node.js

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/steam-game-scraper').call({
    searchTerms: ['cyberpunk'],
    country: 'us',
    maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map(g => ({
    name: g.name,
    price: g.priceFormatted,
    discount: `${g.discountPercent}%`,
    reviews: g.reviewScoreDesc,
    metacritic: g.metacriticScore
})));
```

***

### 💡 Practical Scraping Tips

- **Fastest Run Configuration**: Keep `maxReviewsPerGame` at `0`. You will still receive complete review summary metrics (total reviews, positive percentage, review score label) without the network overhead of paginating individual text reviews.
- **Regional Price Comparison**: Run concurrent runs with different `country` parameters (`us`, `gb`, `de`, `tr`) to map international price disparity and identify regional pricing anomalies.
- **Deal Alert Workflows**: Set up a daily Apify schedule and filter for `discountPercent > 30` to publish automated sale roundups.
- **Indie vs AAA Segmentation**: Filter by `metacriticScore != null` to separate major publisher releases from indie studio titles.

***

### ❓ Frequently Asked Questions

**Do I need a Steam account or Steam Web API key?**\
No. The scraper queries public storefront endpoints directly. No personal accounts, cookies, or Steam Web API developer tokens are required.

**Can I scrape games in currencies other than USD?**\
Yes. Set the two-letter `country` parameter to any supported territory (e.g. `de` for EUR, `gb` for GBP, `tr` for USD/TRY, `jp` for JPY). Prices and currencies will automatically adapt.

**Why do some games show empty price fields?**\
Unreleased games marked with `comingSoon: true` do not have declared prices on Steam until launch day. Free-to-play games return `price: 0` and `isFree: true`.

**How are mature and age-restricted games handled?**\
The scraper includes automated age-verification cookies in its request headers, allowing it to harvest data for mature-rated titles without being blocked by age gates.

**What happens if Steam rate-limits review requests?**\
The scraper features built-in fallback resilience: if the primary review endpoint throttles a request, it seamlessly falls back to Steam's lifetime review histogram service, ensuring aggregate review totals are never lost.

**Can I extract DLC and soundtrack pricing?**\
Yes. When searching or passing specific DLC App IDs, the scraper extracts DLC records identically to full game titles.

***

### 🔌 Integrations & Export Options

- **Direct Download**: Instant export in CSV, JSON, NDJSON, Excel (XLSX), and XML formats.
- **REST API Access**: Stream dataset rows directly into your application backends:
  `GET https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=json`
- **Automation Connectors**: Pipe new sale alerts to Discord, Slack, Telegram, or Notion via Zapier, Make, and n8n integrations.
- **Cloud Warehouses**: Sync catalog telemetry directly into Snowflake, BigQuery, or Amazon Redshift via Apify storage webhooks.

***

### 🔗 Related Gaming & Store Scrapers

- [Google Play Scraper](https://apify.com/haketa/google-play-scraper) — Extract Android mobile games, installs, and reviews.
- [App Store Scraper](https://apify.com/haketa/app-store-scraper) — Extract iOS app listings, rankings, and customer feedback.
- [Product Hunt Launches Scraper](https://apify.com/haketa/producthunt-launches-scraper) — Monitor new gaming and software launches.

***

### 📋 Changelog

#### Version 1.2 (2026-11)

- **Deep 1,000+ Pagination Unlocked**: `maxPagesPerSearch` updated to default to `0` (unlimited), allowing deep pagination up to thousands of games per search query.
- **Empty Run Fallback**: Added seamless fallback to sample game categories when executed with empty input payloads.
- **Enhanced Review Histogram Fallback**: Hardened secondary review fallback to ensure positive/negative counts are always populated.
- **Schema Validation**: Standardized all string representations across output schema for seamless tabular display.

#### Version 1.1 (2026-10)

- Added mature content cookie handling to bypass store age verification screens.
- Concurrent batch enrichment for store details and Metacritic scores.

#### Version 1.0 (2026-10)

- Initial public release of Steam Game & Review Scraper.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/steam-game-scraper/changelog.md

# Actor input Schema

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

Keywords to find games (e.g. "roguelike", "zombie", "racing"). Each is searched and paginated.

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

Specific Steam app IDs to scrape directly (e.g. 730, 1091500).

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

Attach the review score, rating label and positive/negative totals to each game.

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

How many individual review texts to fetch per game (0 = summary only).

## `reviewFilter` (type: `string`):

Which reviews to fetch when getting texts.

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

Two-letter country code for pricing/currency (e.g. us, gb, de, tr).

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

Content language for descriptions (e.g. english, turkish).

## `maxItems` (type: `integer`):

Maximum games across all searches. Set to 0 for unlimited games governed by search pagination.

## `maxPagesPerSearch` (type: `integer`):

Pagination cap per search term (50 games per page). Set to 0 for unlimited pagination governed by maxItems.

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

Apify Proxy. Steam endpoints are public — datacenter is enough and enabled by default.

## Actor input object example

```json
{
  "searchTerms": [
    "roguelike"
  ],
  "includeReviews": true,
  "maxReviewsPerGame": 0,
  "reviewFilter": "recent",
  "country": "us",
  "language": "english",
  "maxItems": 50,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `appId` (type: `string`):

Steam app ID

## `name` (type: `string`):

Game title

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

game/dlc/demo

## `url` (type: `string`):

Store page URL

## `isFree` (type: `string`):

Free to play

## `price` (type: `string`):

Final price

## `priceInitial` (type: `string`):

Pre-discount price

## `discountPercent` (type: `string`):

Discount percent

## `currency` (type: `string`):

Currency

## `priceFormatted` (type: `string`):

Formatted final price

## `priceInitialFormatted` (type: `string`):

Formatted pre-discount price

## `releaseDate` (type: `string`):

Release date

## `comingSoon` (type: `string`):

Unreleased

## `developers` (type: `string`):

Developers

## `publishers` (type: `string`):

Publishers

## `genres` (type: `string`):

Genres

## `categories` (type: `string`):

Store categories

## `metacriticScore` (type: `string`):

Metacritic score

## `recommendationsTotal` (type: `string`):

Total recommendations

## `achievementsTotal` (type: `string`):

Achievement count

## `dlcCount` (type: `string`):

Number of DLC

## `platformWindows` (type: `string`):

Windows support

## `platformMac` (type: `string`):

Mac support

## `platformLinux` (type: `string`):

Linux support

## `controllerSupport` (type: `string`):

Controller support (full/partial)

## `shortDescription` (type: `string`):

Short description

## `supportedLanguages` (type: `string`):

Supported languages

## `website` (type: `string`):

Official website

## `headerImage` (type: `string`):

Header image URL

## `screenshots` (type: `string`):

Screenshot URLs

## `reviewScoreDesc` (type: `string`):

e.g. Very Positive

## `totalReviews` (type: `string`):

Total reviews

## `totalPositive` (type: `string`):

Positive reviews

## `positivePercent` (type: `string`):

Positive percent

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

Review texts

## `scrapedAt` (type: `string`):

ISO timestamp

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchTerms": [
        "roguelike"
    ],
    "maxItems": 50,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/steam-game-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchTerms": ["roguelike"],
    "maxItems": 50,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/steam-game-scraper").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 '{
  "searchTerms": [
    "roguelike"
  ],
  "maxItems": 50,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/steam-game-scraper --silent --output-dataset

```

## MCP server setup

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

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/TGaWRQiz92qs1Q0cJ/builds/Mokz729OYTEjiJiFr/openapi.json