# Steam Games & Reviews Scraper: SteamSpy owners, tags, players (`innocent_archipelago/steam-games-reviews-scraper`) Actor

Search the Steam store by keyword, tag or search URL and get each game's price, discount, review score, SteamSpy owner estimate, user tags with votes, current players, developer, publisher and genres, plus its user reviews with playtime. No browser, $2 per 1,000 games.

- **URL**: https://apify.com/innocent\_archipelago/steam-games-reviews-scraper.md
- **Developed by:** [Spyridon Pikoulas](https://apify.com/innocent_archipelago) (community)
- **Categories:** Games, E-commerce, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 games

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 Games & Reviews Scraper

Search the Steam store the way its search box does, or give it any Steam search URL or list of
games. For every game it returns:

- **Store data:** price and discount in your chosen country's currency, review score and count,
  release date, developer, publisher, genres, categories, platforms, languages, Metacritic score
  and DLC count.
- **Owners and tags (from SteamSpy):** an owner estimate, user tags with their vote counts, and
  average playtime.
- **Players:** the number playing right now.
- **Reviews (optional):** text, thumbs up or down, helpful and funny votes, language, the
  reviewer's playtime at review time and in total, and whether the game was bought on Steam or
  received for free.

It needs no browser and no login. A game costs **$0.002** and a review **$0.0005**.

### What people use it for

- **Market research for game developers:** what sells in a tag or genre, at what price, and how
  many owners the leaders have.
- **Competitor tracking:** follow prices, discounts, review scores and player counts over time.
- **Review mining:** find what players praise and complain about in a genre, for design
  decisions or for training data.
- **Deal tracking:** point it at a search URL filtered to specials.

### How to use it

Use one or more of these three inputs:

- **Search terms**, such as `roguelike deckbuilder`.
- **Steam search URLs**. Any `store.steampowered.com/search/?…` URL works; its tags, sort order,
  price filters and specials are kept.
- **Games**, as app IDs (`646570`) or store URLs.

Then set **Max games per search**, and **Max reviews per game** if you want reviews (0, the
default, skips them). Store country and language set the currency and texts.

```json
{
  "searchUrls": ["https://store.steampowered.com/search/?tags=1716&sort_by=Reviews_DESC"],
  "maxGamesPerSearch": 100,
  "maxReviewsPerGame": 50,
  "reviewSort": "all",
  "reviewLanguage": "english"
}
```

### Output

The dataset holds `"type": "game"` and `"type": "review"` items. Filter on `type`, or open the
Games and Reviews views.

```json
{
  "type": "game",
  "appId": 646570,
  "name": "Slay the Spire",
  "priceCents": 2499,
  "discountPercent": 0,
  "currency": "USD",
  "reviewSummary": "Overwhelmingly Positive",
  "reviewPositivePercent": 97,
  "reviewCount": 191925,
  "ownersEstimate": "5,000,000 .. 10,000,000",
  "tags": {"Roguelike Deckbuilder": 1728, "Card Game": 1588, "Card Battler": 1535},
  "currentPlayers": 7967,
  "developers": ["Mega Crit"],
  "genres": ["Indie", "Strategy"]
}
```

```json
{
  "type": "review",
  "appId": 1162480,
  "gameName": "DIMENSION REIGN - ROGUELIKE DECKBUILDER",
  "votedUp": false,
  "text": "The game became locked on my first playthrough during a combat…",
  "language": "english",
  "createdAt": "2025-09-01T22:22:31+00:00",
  "votesUp": 0,
  "steamPurchase": true,
  "authorPlaytimeAtReviewMinutes": 33
}
```

### Use it as an API

One call runs it and returns the results as JSON (for runs under 5 minutes; longer ones start a
run and read its dataset). Apify's Python and JavaScript clients, and its Make, Zapier and n8n
integrations, work the same way.

```bash
curl -X POST "https://api.apify.com/v2/acts/innocent_archipelago~steam-games-reviews-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["roguelike deckbuilder"], "maxGamesPerSearch": 5, "maxReviewsPerGame": 3}'
```

### Pricing

- **$0.002 per game**, which is $2 per 1,000 games.
- **$0.0005 per review**, which is $0.50 per 1,000 reviews.

Runs that go through Apify's residential proxy also pay its traffic, $0.0012 per 100 KB. There are
no monthly fees.

### Good to know

- Steam's store details API allows about 200 games every 5 minutes from one IP. For runs of
  thousands of games, turn on Apify Proxy in the input, or turn off **Include store details** if
  the search data is enough.
- The owner estimate is SteamSpy's range, not Valve's own figure.

# Actor input Schema

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

Keywords, searched on the Steam store the way its search box does.

## `searchUrls` (type: `array`):

Any store.steampowered.com/search/ URL. Tags, sort order, price filters and specials are kept as they are.

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

Specific games, as app IDs (646570) or store URLs.

## `maxGamesPerSearch` (type: `integer`):

How many games to take from each search, in Steam's order.

## `includeDetails` (type: `boolean`):

Developer, publisher, genres, categories, platforms, release date, languages, Metacritic.

## `includeOwnersAndTags` (type: `boolean`):

Owner range, user tags with vote counts and average playtime (from SteamSpy).

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

0 skips reviews.

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

Which reviews come first.

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

Steam language name (english, german, schinese...) or 'all'.

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

Two-letter country code; sets currency and prices.

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

Steam language name for store texts: english, german, french...

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

Not needed for normal runs.

## Actor input object example

```json
{
  "searchTerms": [
    "roguelike deckbuilder"
  ],
  "maxGamesPerSearch": 50,
  "includeDetails": true,
  "includeOwnersAndTags": true,
  "maxReviewsPerGame": 0,
  "reviewSort": "recent",
  "reviewLanguage": "all",
  "countryCode": "us",
  "language": "english",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

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

No description

# API

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

## JavaScript example

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

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

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

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "searchTerms": ["roguelike deckbuilder"] }

# Run the Actor and wait for it to finish
run = client.actor("innocent_archipelago/steam-games-reviews-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 deckbuilder"
  ]
}' |
apify call innocent_archipelago/steam-games-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,innocent_archipelago/steam-games-reviews-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/qXhKQQk2jl3zTtJmA/builds/aEHiIgKUUsSxBkUDh/openapi.json