# Steam Game Scraper (`crawlerbros/steam-game-scraper`) Actor

Extract comprehensive game data from Steam store pages. Simply provide a game name or Steam URL and get back all available game information, no login, no API key, no proxy required.

- **URL**: https://apify.com/crawlerbros/steam-game-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, AI, Other
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 12 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 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 Game Scraper

Extract comprehensive game data from Steam store pages. Simply provide a game name or Steam URL and get back all available game information — no login, no API key, no proxy required.

### What you get

For each game, this scraper extracts:

- **Game info** — Title, description, release date, developer, publisher, website
- **Pricing** — Current price, original price, discount percentage
- **Classification** — Genres, categories, user-defined tags
- **Platforms** — Windows, Mac, Linux support
- **System requirements** — Minimum and recommended specs for all platforms
- **Media** — Screenshot URLs, trailer video URLs and thumbnails
- **Languages** — Supported text languages and full audio languages
- **Review stats** — Total reviews, positive/negative counts, review score (e.g. "Very Positive")
- **Metacritic** — Score and URL (where available)
- **Achievements** — Total achievement count
- **DLC** — Count and App IDs of all DLC
- **Content descriptors** — Mature content warnings
- **Similar games** — Steam's "More like this" recommendations
- **Awards** — Industry awards won by the game

### Inputs

| Field | Type | Description |
|-------|------|-------------|
| **Steam Game URLs** | URL list | One or more Steam store URLs, e.g. `https://store.steampowered.com/app/1174180/Red_Dead_Redemption_2/` |
| **Game Names** | Text list | Search by name — the first Steam search result will be scraped, e.g. `"Dota 2"` |

At least one of the above inputs is required. You can mix URLs and names in the same run.

### Output

One JSON record per game. Example:

```json
{
  "appId": "1174180",
  "title": "Red Dead Redemption 2",
  "url": "https://store.steampowered.com/app/1174180/",
  "releaseDate": "Dec 5, 2019",
  "isFree": false,
  "priceFinal": 59.99,
  "priceFormatted": "$59.99",
  "developers": ["Rockstar Games"],
  "publishers": ["Rockstar Games"],
  "genres": ["Action", "Adventure"],
  "tags": ["Open World", "Story Rich", "Western", "Action", "Singleplayer"],
  "platforms": ["windows"],
  "totalReviews": 125000,
  "reviewScore": "Very Positive",
  "reviewScorePercent": 9,
  "metacriticScore": 97,
  "totalAchievements": 52,
  "dlcCount": 3,
  "dlcAppIds": ["1182396", "1182397", "1374580"],
  "supportedLanguages": ["English", "French", "German", "Spanish - Spain"],
  "fullyAudioLanguages": ["English"],
  "windowsRequirements": {
    "minimum": "OS: Windows 7 - Service Pack 1 (6.1.7601) ...",
    "recommended": "OS: Windows 10 ..."
  },
  "screenshots": ["https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/..."],
  "trailers": [{"name": "Launch Trailer", "mp4Url": "https://...", "thumbnail": "https://..."}],
  "similarGames": [{"appId": "271590", "title": "Grand Theft Auto V"}],
  "awards": [{"name": "Game of the Year", "year": 2019}],
  "scrapedAt": "2026-04-07T12:00:00Z"
}
````

### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| `appId` | string | Steam App ID |
| `title` | string | Game title |
| `url` | string | Steam store URL |
| `headerImage` | string | Header image URL |
| `capsuleImage` | string | Capsule image URL |
| `backgroundImage` | string | Background image URL |
| `shortDescription` | string | Short marketing description |
| `detailedDescription` | string | Full HTML description |
| `aboutTheGame` | string | About section HTML |
| `releaseDate` | string | Release date (e.g. "Dec 5, 2019") |
| `comingSoon` | boolean | Whether game is not yet released |
| `requiredAge` | integer | Minimum age requirement (0 if none) |
| `isFree` | boolean | Whether game is free-to-play |
| `currency` | string | Price currency (e.g. "USD") |
| `priceInitial` | float | Original price in currency units |
| `priceFinal` | float | Current price (after discount) |
| `discountPercent` | integer | Discount percentage (0 if no discount) |
| `priceFormatted` | string | Formatted current price (e.g. "$59.99") |
| `developers` | array | Developer name(s) |
| `publishers` | array | Publisher name(s) |
| `website` | string | Official website URL |
| `genres` | array | Steam genre labels |
| `categories` | array | Steam feature categories (e.g. "Single-player", "Steam Achievements") |
| `tags` | array | User-defined tags |
| `platforms` | array | Supported platforms: windows, mac, linux |
| `windowsRequirements` | object | `{minimum, recommended}` as plain text |
| `macRequirements` | object | `{minimum, recommended}` as plain text |
| `linuxRequirements` | object | `{minimum, recommended}` as plain text |
| `screenshots` | array | Full-size screenshot URLs |
| `trailers` | array | `{name, mp4Url, thumbnail}` for each trailer |
| `supportedLanguages` | array | All supported text languages |
| `fullyAudioLanguages` | array | Languages with full audio support |
| `totalReviews` | integer | Total number of reviews |
| `positiveReviews` | integer | Number of positive reviews |
| `negativeReviews` | integer | Number of negative reviews |
| `reviewScore` | string | Review score label (e.g. "Very Positive") |
| `reviewScorePercent` | integer | Steam's internal review score (1-9 scale) |
| `metacriticScore` | integer | Metacritic score (0 if not available) |
| `metacriticUrl` | string | Metacritic page URL |
| `totalAchievements` | integer | Total number of Steam achievements |
| `dlcCount` | integer | Number of DLC items |
| `dlcAppIds` | array | App IDs of all DLC |
| `contentDescriptors` | array | Mature content warnings |
| `legalNotice` | string | Legal notice text |
| `similarGames` | array | `{appId, title}` for recommended similar games |
| `awards` | array | `{name, year}` for industry awards |
| `scrapedAt` | string | ISO 8601 UTC timestamp of when data was scraped |

### Use cases

- **Game research** — Compare prices, requirements, and review scores across multiple titles
- **Market analysis** — Track genres, tags, and pricing trends across Steam's catalog
- **Content aggregation** — Build game databases or recommendation engines
- **Price monitoring** — Track discount percentages and current prices
- **Review analytics** — Analyse review score distributions across genres or developers

### FAQ

**Does this require a Steam account or API key?**
No. The scraper uses Steam's public store API and store pages — no login, account, or API key needed.

**Does this work for free-to-play games?**
Yes. Free games return `isFree: true` and price fields are set to `0`.

**What if a game has no Metacritic score or awards?**
Fields that aren't applicable return safe empty values (`0` for numbers, `""` for strings, `[]` for lists) — never `null`.

**Can I scrape multiple games at once?**
Yes — add multiple URLs or game names in the same run. Each produces one output record.

**What happens if I provide both a URL and a game name for the same game?**
The scraper deduplicates by App ID — the game is only scraped once.

**How fresh is the data?**
Data is fetched live from Steam at scrape time. The `scrapedAt` field records the exact UTC timestamp.

**Why is `reviewScorePercent` a number from 1-9 instead of a percentage?**
This is Steam's internal rating scale where 9 = "Overwhelmingly Positive", 8 = "Very Positive", etc. The `reviewScore` field contains the human-readable label.

# Actor input Schema

## `startUrls` (type: `array`):

Steam store page URLs for the games you want to scrape. Example: https://store.steampowered.com/app/1174180/Red\_Dead\_Redemption\_2/

## `gameNames` (type: `array`):

Search Steam by game name. The first search result will be scraped.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://store.steampowered.com/app/1174180/Red_Dead_Redemption_2/"
    }
  ],
  "gameNames": []
}
```

# Actor output Schema

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

Dataset containing all scraped Steam game records

# 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 = {
    "startUrls": [
        {
            "url": "https://store.steampowered.com/app/1174180/Red_Dead_Redemption_2/"
        }
    ],
    "gameNames": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "startUrls": [{ "url": "https://store.steampowered.com/app/1174180/Red_Dead_Redemption_2/" }],
    "gameNames": [],
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/steam-game-scraper").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 '{
  "startUrls": [
    {
      "url": "https://store.steampowered.com/app/1174180/Red_Dead_Redemption_2/"
    }
  ],
  "gameNames": []
}' |
apify call crawlerbros/steam-game-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Game Scraper",
        "description": "Extract comprehensive game data from Steam store pages. Simply provide a game name or Steam URL and get back all available game information, no login, no API key, no proxy required.",
        "version": "1.0",
        "x-build-id": "7nXAnAsdJ8vCfAysx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~steam-game-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-steam-game-scraper",
                "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/crawlerbros~steam-game-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-steam-game-scraper",
                "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/crawlerbros~steam-game-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-steam-game-scraper",
                "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": {
                    "startUrls": {
                        "title": "Steam Game URLs",
                        "type": "array",
                        "description": "Steam store page URLs for the games you want to scrape. Example: https://store.steampowered.com/app/1174180/Red_Dead_Redemption_2/",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "gameNames": {
                        "title": "Game Names",
                        "type": "array",
                        "description": "Search Steam by game name. The first search result will be scraped.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
