# Steam Games & Reviews Scraper (`mina_safwat/steam-scraper`) Actor

Scrapes Steam game data — prices, discounts, genres, Metacritic scores, live player counts, and user reviews

- **URL**: https://apify.com/mina\_safwat/steam-scraper.md
- **Developed by:** [Mina](https://apify.com/mina_safwat) (community)
- **Categories:** Developer tools, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Scrape **Steam game data and user reviews** — prices, discounts, genres, Metacritic scores, review sentiment, and how many people are playing right now.

### What does Steam Games & Reviews Scraper do?

Search the Steam store or name games directly by their app ID, and get back the full store listing: price and any current discount, developer and publisher, genres and categories, Metacritic score, release date, supported platforms and languages, screenshots, and the description.

Switch on the extras and each game also carries its **review breakdown** — how many positive and negative reviews, the percentage, and the individual reviews with playtime — plus the **live player count**.

### Why use Steam Games & Reviews Scraper?

- **Price and discount tracking** — watch a wishlist and catch sales as they start.
- **Review mining** — pull thousands of reviews to see what players praise and complain about.
- **Market research** — study pricing, genres, and review sentiment across a category.
- **Competitor monitoring** — track rival titles' player counts and review scores over time.
- **Games journalism and analytics** — measure how a launch is actually going.

Running it on Apify adds scheduling, an API, integrations (Sheets, Slack, Zapier, S3), and run monitoring.

### How to use Steam Games & Reviews Scraper

1. Enter **Search terms**, or **App IDs** for exact games.
2. Set **Max games**.
3. Turn on **Include reviews** or **Include live player count** if you want them.
4. Click **Start**.

Results appear in the Output tab as they are scraped, and download as JSON, CSV, Excel, or XML.

### Input

| Field | Description |
| --- | --- |
| `search_terms` | Words to search the store for, one per line. |
| `app_ids` | Steam app IDs — the number in a store URL, e.g. `730`. |
| `max_games` | Total cap across searches and IDs. |
| `country` | Two-letter store country. Prices and availability differ by store. |
| `language` | Steam language name such as `english` or `german`. Affects descriptions and which reviews come back. |
| `include_reviews` + `max_reviews_per_game` + `reviews_sort` | User reviews and the sentiment breakdown. |
| `include_player_count` | How many people are playing right now. |

### Output

```json
{
  "app_id": 730,
  "name": "Counter-Strike 2",
  "url": "https://store.steampowered.com/app/730/",
  "is_free": true,
  "price": 29.99,
  "original_price": 59.99,
  "discount_percent": 50,
  "currency": "USD",
  "developers": ["Valve"],
  "genres": ["Action", "Free To Play"],
  "metacritic_score": 83,
  "release_date": "21 Aug, 2012",
  "platforms": ["windows", "linux"],
  "players_online": 1057077,
  "review_score_label": "Very Positive",
  "total_reviews": 1496553,
  "total_positive": 1276085,
  "positive_pct": 85.27
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Data fields

| Field | Description |
| --- | --- |
| `app_id`, `name`, `url`, `type`, `header_image` | Which game, and its store page. |
| `price`, `original_price`, `discount_percent`, `currency`, `price_label` | Price as a number, plus what Steam displays. |
| `is_free` | Whether the game is free to play. |
| `developers`, `publishers`, `genres`, `categories` | Who made it and how it is classified. |
| `metacritic_score`, `total_recommendations` | Critic score and Steam recommendation count. |
| `review_score_label`, `total_reviews`, `total_positive`, `total_negative`, `positive_pct` | Review sentiment at a glance. |
| `reviews` | Individual reviews with text, votes, and the reviewer's playtime in hours. |
| `players_online` | Live concurrent players. |
| `release_date`, `coming_soon`, `required_age` | Release information. |
| `platforms`, `supported_languages`, `dlc_count` | Technical and content details. |
| `description`, `short_description`, `screenshots`, `website` | Store listing content. |

### How much does it cost to scrape Steam?

One request per game, plus one for each extra. Reviews are the heavy part — they arrive 100 at a time, so a thousand reviews for one game is about ten requests.

### Tips

- **App IDs are faster than searching.** If you already know the games, skip the search step.
- **Country changes prices.** Run the same list against several stores to compare regional pricing.
- **Playtime is the credibility signal** in review data — `playtime_hours_at_review` tells you whether a reviewer had actually played it.
- **Track sales by scheduling it** daily against a wishlist and watching `discount_percent`.

### FAQ and support

**Does it need a Steam account or API key?** No. It reads publicly visible store pages and the public review feed.

**Why was a game skipped?** Steam returns no store page when a game is region-locked, delisted, or the ID is wrong. The log names each skipped ID and the run carries on.

**Why are prices missing on some games?** Free titles have no price block at all. Those come back with `is_free: true` and empty price fields rather than a zero.

**Why do I get fewer reviews than I asked for?** Games with fewer reviews than your limit simply return all they have. Language also filters them — asking for `german` returns only German-language reviews.

**Is scraping Steam legal?** This Actor collects publicly available store data. Reviews carry public usernames; if you store them, handle that in line with GDPR and similar laws. You are responsible for how you use the data, including Valve's terms. Consult a lawyer if you are unsure.

Found a bug or want a field that is missing? Open an issue on the Actor's Issues tab.

# Actor input Schema

## `search_terms` (type: `array`):

Words to search the Steam store for, one per line. Results from several terms are merged.

## `app_ids` (type: `array`):

Steam app IDs — the number in a store URL, e.g. 730 in store.steampowered.com/app/730/. Use these to look up exact games.

## `max_games` (type: `integer`):

Stops after this many games in total.

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

Two-letter country code. Prices and availability differ by store.

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

Steam language name, e.g. english, german, brazilian. Affects descriptions and which reviews are returned.

## `include_reviews` (type: `boolean`):

Attach user reviews and the overall positive/negative breakdown for each game.

## `max_reviews_per_game` (type: `integer`):

Reviews arrive 100 at a time, so large numbers mean more requests per game.

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

Which reviews to collect first.

## `include_player_count` (type: `boolean`):

Add how many people are playing the game right now.

## Actor input object example

```json
{
  "search_terms": [
    "roguelike"
  ],
  "app_ids": [],
  "max_games": 25,
  "country": "us",
  "language": "english",
  "include_reviews": false,
  "max_reviews_per_game": 50,
  "reviews_sort": "Most helpful",
  "include_player_count": false
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "search_terms": [
        "roguelike"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mina_safwat/steam-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 = { "search_terms": ["roguelike"] }

# Run the Actor and wait for it to finish
run = client.actor("mina_safwat/steam-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 '{
  "search_terms": [
    "roguelike"
  ]
}' |
apify call mina_safwat/steam-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mina_safwat/steam-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/20yQfnYg0WS9ErBox/builds/zVxzffEvnqcYhikk6/openapi.json