# Steam Review Scraper (`crawlerbros/steam-review-scraper`) Actor

Extract reviews from Steam for any game get review text, ratings, playtime stats, helpfulness votes, and author details. No login or proxy required.

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

## Pricing

from $2.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 Review Scraper

Extract reviews from Steam for any game — get review text, ratings, playtime stats, helpfulness votes, and author details. No login or proxy required.

### What is Steam Review Scraper?

A fast, free tool that extracts review data from [Steam](https://store.steampowered.com/) using Steam's public API. Provide game page URLs or game names and get structured review data including ratings, reviewer playtime, and community votes.

Perfect for game market research, sentiment analysis, competitor analysis, and player feedback collection.

### What data can you extract?

**Review details:**
- Full review text
- Rating (Positive / Negative)
- Date created and last updated
- Language
- Whether received for free
- Whether written during Early Access

**Author info:**
- Steam ID
- Total reviews by this author
- Total playtime (hours)
- Playtime at time of review (hours)

**Community engagement:**
- Helpful votes
- Funny votes
- Weighted helpfulness score (0–1)

### Input

#### Steam Game URLs

Provide Steam store page URLs for the games you want to scrape. Go to [store.steampowered.com](https://store.steampowered.com/), find a game, and copy the URL.

**Example:** `https://store.steampowered.com/app/1174180/Red_Dead_Redemption_2/`

#### Game Names

Alternatively, provide game name search terms. The first Steam search result will be used to scrape reviews.

**Note:** For best accuracy, use the exact game title or provide the store URL directly.

#### Options

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| startUrls | array | — | Steam store page URLs |
| gameNames | array | — | Game name search terms (first result used) |
| maxReviews | integer | `50` | Max reviews per game (up to 500) |
| reviewType | select | `all` | `all`, `positive`, or `negative` |
| language | string | `all` | Steam language code (e.g. `english`, `german`, `french`) or `all` |

At least one of `startUrls` or `gameNames` is required.

### Output

Each item in the dataset represents one review:

```json
{
    "appId": "1174180",
    "gameTitle": "Red Dead Redemption 2",
    "gameUrl": "https://store.steampowered.com/app/1174180/",
    "reviewId": "123456789",
    "reviewText": "One of the best games ever made. The world is stunning...",
    "rating": "Positive",
    "authorSteamId": "76561198012345678",
    "authorNumReviews": 42,
    "authorPlaytimeForever": 187.3,
    "authorPlaytimeAtReview": 120.5,
    "votesHelpful": 156,
    "votesFunny": 3,
    "weightedVoteScore": 0.923,
    "timestampCreated": "2024-11-15T10:30:00Z",
    "timestampUpdated": "2024-11-15T10:30:00Z",
    "receivedForFree": false,
    "writtenDuringEarlyAccess": false,
    "language": "english",
    "scrapedAt": "2026-04-06T12:00:00Z"
}
````

### Frequently Asked Questions

**Does this require a Steam account or API key?**
No. The scraper uses Steam's public review API which is available without authentication.

**Does it require a proxy?**
No. Steam's review API is freely accessible without proxies.

**How many reviews can I scrape per game?**
Up to 500 reviews per game per run. Steam's API provides cursor-based pagination with up to 100 reviews per request.

**Can I scrape multiple games at once?**
Yes. Add multiple URLs to `startUrls` or multiple names to `gameNames`. Each game is scraped up to `maxReviews`.

**Can I filter by language?**
Yes. Set the `language` field to a Steam language code. Use `all` for all languages. Supported codes: `english`, `german`, `french`, `spanish`, `portuguese`, `russian`, `schinese` (Simplified Chinese), `tchinese` (Traditional Chinese), `japanese`, `korean`, `turkish`, `italian`, `dutch`, `polish`, `thai`, `vietnamese`. Note: ISO codes like `en` or `de` will **not** work.

**What does the `weightedVoteScore` mean?**
It's Steam's internal helpfulness score (0–1) that weighs helpful/funny votes to surface the most useful reviews.

**Why might `authorPlaytimeAtReview` be 0?**
Some older reviews or reviews from certain regions may not have playtime data recorded by Steam.

**Can I use both URLs and game names in the same run?**
Yes. You can combine `startUrls` and `gameNames` in a single run. Duplicate games (same app ID) are automatically deduplicated.

# Actor input Schema

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

Steam store page URLs for the games you want to scrape reviews for. 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 used to scrape reviews.

## `maxReviews` (type: `integer`):

Maximum number of reviews to extract per game.

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

Filter reviews by type.

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

Filter reviews by language. Select 'All Languages' to include reviews in every language.

## Actor input object example

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

# Actor output Schema

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

Dataset containing all scraped Steam reviews

# 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-review-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-review-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-review-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Review Scraper",
        "description": "Extract reviews from Steam for any game get review text, ratings, playtime stats, helpfulness votes, and author details. No login or proxy required.",
        "version": "1.0",
        "x-build-id": "zxjyVI8ZBVUzMDFdz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~steam-review-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-steam-review-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-review-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-steam-review-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-review-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-steam-review-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 reviews for. 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 used to scrape reviews.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max Reviews",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per game.",
                        "default": 50
                    },
                    "reviewType": {
                        "title": "Review Type",
                        "enum": [
                            "all",
                            "positive",
                            "negative"
                        ],
                        "type": "string",
                        "description": "Filter reviews by type.",
                        "default": "all"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "all",
                            "english",
                            "german",
                            "french",
                            "spanish",
                            "latam",
                            "portuguese",
                            "brazilian",
                            "russian",
                            "schinese",
                            "tchinese",
                            "japanese",
                            "koreana",
                            "turkish",
                            "italian",
                            "dutch",
                            "polish",
                            "thai",
                            "vietnamese",
                            "indonesian",
                            "bulgarian",
                            "czech",
                            "danish",
                            "finnish",
                            "greek",
                            "hungarian",
                            "norwegian",
                            "romanian",
                            "swedish",
                            "ukrainian"
                        ],
                        "type": "string",
                        "description": "Filter reviews by language. Select 'All Languages' to include reviews in every language.",
                        "default": "all"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
