# Steam Scraper (`donjuan_mime/steam-scraper`) Actor

Scrape Steam games and reviews: prices and discounts in any country, ratings, genres, developers, release dates, and full review text. No login or API key.

- **URL**: https://apify.com/donjuan_mime/steam-scraper.md
- **Developed by:** [Donjuan](https://apify.com/donjuan_mime) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.30 / 1,000 items

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 Scraper: games, prices, discounts, and reviews

Steam Scraper collects game data and user reviews from the Steam store. For every game you get the name, prices and discounts in the country you pick, release date, developers, publishers, genres, categories, platforms, Metacritic score, Steam rating, total positive and negative reviews, images, and supported languages. Turn on reviews to also get the full text of each review with the reviewer's playtime, helpful votes, language, and dates.

You don't need a Steam account, an API key, or any code. Add game IDs, store links, or search terms, press **Start**, and download the results as JSON, CSV, Excel, XML, or HTML. Or pull them into your app through the Apify API.

### What can you do with Steam data?

- **Track prices and sales.** Check what a game costs in the US, Ukraine, Germany, or any other store country, with the discount and the price before it. Run it on a schedule to log price history.
- **Watch competitors.** Follow ratings, review counts, and prices of games in your genre, and see how players react after each update.
- **Analyze reviews.** Pull thousands of reviews with text, language, and playtime for sentiment analysis, bug hunting, or feature requests. Filter by positive or negative reviews and by language.
- **Research the market.** Paste a store search link with tags, price filters, or specials, and get every game in that slice with its rating and price.
- **Build datasets.** Export clean rows to a spreadsheet or a database for research, dashboards, or model training.

### What data does Steam Scraper extract?

| Group | Fields |
|---|---|
| Game | app ID, store URL, name, app type (game, dlc, demo, ...), short description, developers, publishers, website, required age |
| Release | release date as Steam shows it, ISO date, coming soon flag |
| Price | currency, price before discount, current price, discount percent, formatted prices, free to play flag |
| Rating | Steam rating (for example "Very Positive"), score from 1 to 9, total, positive, and negative reviews, recommendations, Metacritic score and link |
| Details | genres, categories, platforms (Windows, macOS, Linux), supported languages |
| Media | header image, full-size screenshots |
| Reviews | review ID, link, game, text, language, recommended or not, helpful and funny votes, helpfulness score, comment count, posted and updated dates, bought on Steam, received for free, refunded, early access, Steam Deck flag, developer response |
| Reviewer | Steam ID, profile link, games owned, reviews written, total playtime, playtime in the last two weeks, playtime at review, last played date |

### How to scrape Steam

1. Open the actor and go to the **Input** tab.
2. Add what to scrape:
   - **App IDs**: the number in a store link, for example `1091500` for `https://store.steampowered.com/app/1091500/`.
   - **Start URLs**: game pages, or a store search page with any filters you set on the Steam site.
   - **Search queries**: words to search the store for.
3. Pick the store country and language. Turn on **Include reviews** if you want reviews.
4. Press **Start**. When the run finishes, open the **Output** tab and switch between the **Games** and **Reviews** views, or press **Export** to download the data.

### Input

| Field | Type | Description |
|---|---|---|
| `appIds` | array of strings | Steam app IDs. |
| `startUrls` | array | Game pages (`https://store.steampowered.com/app/...`) or store search pages (`https://store.steampowered.com/search/?...`). A search page keeps all its filters. |
| `searchQueries` | array of strings | Terms to search the store for. |
| `maxGamesPerSearch` | integer | The maximum number of games from each search query and each search page. Default 20. |
| `country` | string | Two-letter store country (`us`, `ua`, `de`, ...). Sets the currency and regional prices. Default `us`. |
| `language` | string | Steam language name for descriptions, genres, and categories (`english`, `german`, `ukrainian`, ...). Default `english`. |
| `includeReviews` | boolean | Also scrape reviews, one item per review. |
| `maxReviewsPerGame` | integer | The maximum number of reviews per game. Default 100. |
| `reviewsFilter` | string | `recent` (most recent), `updated` (recently updated), or `all` (most helpful). |
| `reviewsLanguage` | string | Steam language name or `all`. |
| `reviewType` | string | `all`, `positive`, or `negative`. |
| `proxyCountryCode` | string | A two-letter country code to use Apify residential proxy in that country. `None` uses Apify datacenter proxy. |

#### Input example

```json
{
  "appIds": ["1091500", "292030"],
  "startUrls": [
    { "url": "https://store.steampowered.com/search/?specials=1&tags=19" }
  ],
  "searchQueries": ["witcher"],
  "maxGamesPerSearch": 20,
  "country": "us",
  "language": "english",
  "includeReviews": true,
  "maxReviewsPerGame": 500,
  "reviewsFilter": "recent",
  "reviewsLanguage": "english",
  "reviewType": "all",
  "proxyCountryCode": "None"
}
```

### Output

Games and reviews go into one dataset. Each item has a `type` field: `game` or `review`. The **Games** and **Reviews** views in the Output tab show the columns for each type.

#### Game example

A real item for Cyberpunk 2077 from the US store. Lists are shortened.

```json
{
  "type": "game",
  "appId": 1091500,
  "url": "https://store.steampowered.com/app/1091500/",
  "name": "Cyberpunk 2077",
  "appType": "game",
  "shortDescription": "Cyberpunk 2077 is an open-world, action-adventure RPG set in the dark future of Night City...",
  "developers": ["CD PROJEKT RED"],
  "publishers": ["CD PROJEKT RED"],
  "releaseDate": "Dec 9, 2020",
  "releaseDateISO": "2020-12-09",
  "comingSoon": false,
  "isFree": false,
  "requiredAge": 17,
  "price": {
    "currency": "USD",
    "initial": 59.99,
    "final": 17.99,
    "discountPercent": 70,
    "initialFormatted": "$59.99",
    "finalFormatted": "$17.99"
  },
  "platforms": { "windows": true, "mac": true, "linux": false },
  "genres": ["RPG"],
  "categories": ["Single-player", "Steam Achievements", "Full controller support"],
  "metacritic": { "score": 86, "url": "https://www.metacritic.com/game/pc/cyberpunk-2077?ftag=MCD-06-10aaa1f" },
  "recommendations": 897134,
  "reviewSummary": {
    "score": 8,
    "scoreDesc": "Very Positive",
    "totalPositive": 859745,
    "totalNegative": 128617,
    "totalReviews": 988362
  },
  "headerImage": "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/1091500/.../header.jpg",
  "screenshots": ["https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/1091500/ss_2f649b68....1920x1080.jpg"],
  "supportedLanguages": ["English", "French", "German", "Polish", "Ukrainian"],
  "website": "https://www.cyberpunk.net",
  "input": "1091500"
}
```

#### Review example

A real review of The Witcher 3: Wild Hunt.

```json
{
  "type": "review",
  "recommendationId": "238018454",
  "url": "https://steamcommunity.com/profiles/76561198025906759/recommended/292030/",
  "appId": 292030,
  "appName": "The Witcher 3: Wild Hunt — Remastered",
  "author": {
    "steamId": "76561198025906759",
    "profileUrl": "https://steamcommunity.com/profiles/76561198025906759/",
    "gamesOwned": 1741,
    "reviews": 34,
    "playtimeForever": 13083,
    "playtimeLastTwoWeeks": 170,
    "playtimeAtReview": 13023,
    "lastPlayedISO": "2026-10-18T14:51:14.000Z"
  },
  "language": "english",
  "text": "The high standard for open world CRPGs, arguably surpassed now by Crimson Desert, but not in story and style.",
  "votedUp": true,
  "votesUp": 0,
  "votesFunny": 0,
  "weightedScore": 0.5,
  "commentCount": 0,
  "steamPurchase": true,
  "receivedForFree": false,
  "refunded": false,
  "writtenDuringEarlyAccess": false,
  "primarilySteamDeck": false,
  "createdAtISO": "2026-10-18T13:22:35.000Z",
  "updatedAtISO": "2026-10-18T13:22:35.000Z",
  "input": "292030"
}
```

#### Notes on fields

- Playtime is in minutes.
- `price` is missing for free games and for games that have no price yet. `price.initial` and `price.final` are in currency units, for example `17.99` dollars.
- `releaseDateISO` is filled when the store language is `english`. Other languages keep only `releaseDate` as Steam writes it, for example `9. Dez. 2020`.
- `reviewSummary` covers reviews in all languages, whatever you pick in `reviewsLanguage`.
- `developerResponse` appears only on reviews the developer answered.

### Limits

- Steam allows about 200 game detail requests per 5 minutes from one IP. The actor keeps under that limit, so it collects about 40 games per minute. Reviews come 100 per request and load much faster: 1,800 reviews of three games took 8 seconds in our tests.
- A search goes as deep as the Steam store search does. Narrow queries end early, for example "witcher" had 115 results in our tests, while the specials list ran past 2,000 games. Large searches take time because of the game detail limit above.
- Games that aren't sold in the chosen store country are skipped, as Steam doesn't return them there.

### How much does it cost?

You pay for each item in the dataset, games and reviews alike, at $0.30 per 1,000 items. 100 games with 100 reviews each make 10,100 items and cost about $3.03. Without reviews, 1,000 games cost $0.30.

### Export and integrations

The results go into an Apify dataset. From there you can:

- download them as JSON, CSV, Excel, XML, HTML, or RSS from the **Output** tab;
- send them to Google Sheets, Slack, Zapier, Make, and other tools through Apify integrations;
- schedule runs, for example once a day, to track prices and ratings over time;
- start runs and read the results from your own code through the Apify API.

#### Run it through the API

```bash
curl -X POST "https://api.apify.com/v2/acts/<username>~steam-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"appIds": ["1091500"], "includeReviews": true, "maxReviewsPerGame": 200}'
```

### FAQ

#### Do I need a Steam account or a Steam API key?

No. The actor uses the public data the Steam store shows to every visitor.

#### How do I find a game's app ID?

Open the game in the Steam store. The number after `/app/` in the address is the app ID. You can also paste the whole link into **Start URLs**.

#### Can I get prices in my currency?

Yes. Set **Store country** to your country code, for example `ua` for hryvnias or `de` for euros.

#### How do I scrape only discounted games?

Open the Steam store search, turn on **Special Offers** and any other filters, and paste the link into **Start URLs**.

#### Can I get only negative reviews?

Yes. Turn on **Include reviews** and set **Review type** to **Negative**. Combine it with **Review language** to read complaints in one language.

#### Is it legal to scrape Steam?

The actor collects only public data that anyone can see in the Steam store. Reviews are tied to public Steam profiles, so make sure you have a legitimate reason to collect them and follow the GDPR and other laws that apply to you. If you're not sure, ask a lawyer.

### Disclaimer

This actor is provided as is, without warranty. You're responsible for how you use it and for following Steam's terms of service and the laws that apply to you. Valve and Steam aren't affiliated with this actor.

# Actor input Schema

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

Steam app IDs, the number in a store link such as https://store.steampowered.com/app/1091500/.

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

Steam store links: a game page, or a search page with any filters (tags, specials, price, sorting) set on the Steam site.

## `searchQueries` (type: `array`):

Search the Steam store for these terms.

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

The maximum number of games to take from each search query and each search page URL.

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

Two-letter country code (us, ua, de, ...). Sets the currency and regional prices, and hides games not sold in that country.

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

Steam language name for descriptions, genres, and categories, for example english, german, ukrainian, or schinese. releaseDateISO is filled only for english.

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

Also scrape user reviews of every game, one dataset item per review.

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

The maximum number of reviews to scrape from each game.

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

Most recent first, recently updated first, or most helpful first.

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

Steam language name (english, ukrainian, russian, schinese, ...) or "all".

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

All reviews, only positive (recommended), or only negative.

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

Two-letter country code (US, DE, ...) to use Apify residential proxy in that country. "None" uses Apify datacenter proxy.

## Actor input object example

```json
{
  "appIds": [
    "1091500"
  ],
  "maxGamesPerSearch": 20,
  "country": "us",
  "language": "english",
  "includeReviews": false,
  "maxReviewsPerGame": 100,
  "reviewsFilter": "recent",
  "reviewsLanguage": "all",
  "reviewType": "all",
  "proxyCountryCode": "None"
}
```

# Actor output Schema

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

One item per game (type "game") and, with reviews turned on, one item per review (type "review").

# 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 = {
    "appIds": [
        "1091500"
    ]
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,donjuan_mime/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/3e3OVPmygBEdWcAtX/builds/CAwKAprYxyNcjVSZQ/openapi.json