# Steam Reviews Scraper (`s_actors/steam-reviews-scraper`) Actor

Steam game reviews by link, app ID or name on Valve's new reviews API (the old appreviews endpoint shuts down 22 Oct 2026). Review text, recommended, playtime, votes, language, Steam Deck, refunds, developer replies. Exact date windows, playtime filters, only new reviews.

- **URL**: https://apify.com/s_actors/steam-reviews-scraper.md
- **Developed by:** [Superior Actors](https://apify.com/s_actors) (community)
- **Categories:** Social media, E-commerce, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.29 / 1,000 steam reviews

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

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

Download **Steam game reviews** of any game by **store link, app ID or name**: **review text**, **recommended or not**, **hours played at review and in total**, **helpful and funny votes**, **language**, **date posted and edited**, **Steam Deck**, **refunded**, **received for free**, **Early Access**, **developer response** and the reviewer's Steam profile, plus the game's **store review score** (Overwhelmingly Positive, 98% of 286,831).

```json
{ "games": ["https://store.steampowered.com/app/1145360/Hades/", "413150", "Hollow Knight Silksong"], "maxReviewsPerGame": 500 }
```

No Steam account, no Web API key, no cookies. Use it as a **Steam reviews API**: one call returns clean JSON, CSV or Excel.

#### Built on Steam's new reviews API (the old one stops on 22 October 2026)

Valve is switching off the old `store.steampowered.com/appreviews` endpoint on **22 October 2026** ([Steamworks announcement](https://steamcommunity.com/groups/steamworks/announcements/detail/676258795703241581)). Most Steam review scrapers and Python scripts still call it. This Actor already runs on the replacement, **IUserReviewsService/GetAppReviews**, and uses its new filters:

| Filter | What it does |
|---|---|
| 📅 **Exact date window** | Reviews from / until a date (or "30 days"). Steam applies it exactly: no reviews from outside the window, nothing to trim or pay for |
| ⏱️ **Playtime at review** | Only reviewers with at least (or at most) N hours when they wrote it: skip 2-hour first impressions, or study refund-window reviews |
| 🕹️ **Steam Deck players** | Only reviews by people who played mostly on Steam Deck |
| 🌐 **Several languages at once** | English + Russian + Simplified Chinese in one request, or all 30 |
| 👍 **Positive / negative**, 🛒 **Steam purchases / keys**, 💣 **review bombs** | Same choices as the store page |

#### What you get

One row per review. Real example, 12 October 2026 (English, Russian and Chinese, last 60 days, 2+ hours played):

| gameName | recommended | reviewText | playtimeAtReviewHours | votesHelpful | language | createdAt |
|---|---|---|---|---|---|---|
| Hades | true | Офигенейшая игра | 73.3 | 0 | russian | 2026-10-12 |
| Hollow Knight: Silksong | true | very hard and i love it | 132.8 | 0 | english | 2026-10-12 |
| Cyberpunk 2077 | false | try not to sleep whle playing the game | 2.3 | 1 | english | 2026-10-12 |
| Stardew Valley | true | VERY GOOD GAME | 39.3 | 0 | english | 2026-10-12 |

| Field | Description |
|---|---|
| `reviewText`, `recommended`, `language` | The review, thumbs up (`true`) or down, Steam language code |
| `createdAt`, `updatedAt`, `isEdited` | Posted and last edited (UTC) |
| `votesHelpful`, `votesFunny`, `helpfulnessScore`, `commentCount` | Votes, Steam's helpfulness score, comments |
| `playtimeAtReviewHours`, `playtimeTotalHours`, `playtimeLastTwoWeeksHours`, `deckPlaytimeAtReviewHours`, `lastPlayedAt` | Hours the reviewer played: when writing, in total, lately, on Steam Deck |
| `primarilySteamDeck`, `steamPurchase`, `receivedForFree`, `writtenDuringEarlyAccess`, `refunded` | Flags of the review |
| `developerResponse`, `developerRespondedAt` | The developer's reply |
| `authorSteamId`, `authorProfileUrl`, `authorReviewCount`, `reviewUrl` | Reviewer and a link to the review |
| `appId`, `gameName`, `gameUrl`, `reviewScore`, `totalReviews`, `positivePercent` | Game and its store score |
| `gameDeveloper`, `gamePublisher`, `gameReleaseDate`, `gamePrice`, `gameGenres`, `gameImage` | Store card (with **Game details** on, the default) |

The **Games summary** (`GAMES` in the run's key-value store) has one entry per game: store score, total, positive and negative reviews, and how many reviews match your filters.

#### How it works

1. Add **games**: store links, app IDs or names. Any number
2. Choose **Max reviews per game** (0 = all), **sort**, **languages**, **positive / negative**, and optionally a **date window**, **playtime** and **Steam Deck** filters
3. Run, then download the reviews as CSV, Excel, JSON or HTML

#### Monitor new Steam reviews

Turn on **Only new reviews**, save the input as a task and schedule it (every hour, every day). Each run returns only reviews written since the previous run, so you can send **new negative reviews** of your game (or your competitors') to Slack, Discord or email with an Apify integration. Runs without new reviews cost only the run start.

#### Why this Actor

| | |
|---|---|
| ✅ **Works after 22 October** | Runs on Valve's new reviews API, not the endpoint being switched off |
| 📅 **Exact date windows** | Steam filters by date itself, so a 3-day window returns exactly 3 days |
| ⏱️ **Playtime and Steam Deck filters** | Filters other scrapers cannot offer on the old endpoint |
| 🔔 **Only new reviews** | Review monitoring for developers and publishers |
| 🎮 **Names work** | "Hollow Knight Silksong" finds app 1030300 |
| 💵 **$0.49 per 1,000 reviews** | No subscription |

#### Pricing

Pay per review in the results, no subscription needed. Apify Scale and Business plans pay less:

| Event | Free and Starter plans | Scale plan | Business plan |
|---|---|---|---|
| Run start | $0.001 | $0.001 | $0.001 |
| Steam review in the results | $0.00049 | $0.00038 | $0.00029 |

| Task | Cost |
|---|---|
| 1,000 reviews of one game | ~$0.49 |
| 100 latest reviews of 20 games | ~$0.98 |
| New reviews of your game every hour for a month (~50 new a day) | ~$1.46 per month |

Games that are not found are not charged.

#### Ready-made tasks

Open it, change the games, and run:

| Task | What you get |
|---|---|
| [Export Steam Reviews to CSV or Excel](https://apify.com/s_actors/steam-reviews-scraper/examples/steam-reviews-export) | The latest 500 reviews of a game, ready to download |

#### FAQ

**Will it break on 22 October 2026?** No. It never calls the old `appreviews` endpoint: everything goes through `IUserReviewsService/GetAppReviews`, the method Valve names as the replacement.

**Do I need a Steam Web API key?** No. The new method works without a key; keyless calls share a lower rate limit, so the Actor spreads requests over proxy IPs when Steam answers "too many requests".

**How many reviews can I get?** All of them: set **Max reviews per game** to 0 with **Most recent first**. Steam returns 100 per request: 1,500 reviews of one game take about 5 seconds, 24,000 reviews of 12 games about a minute.

**Why do the totals differ from the store page?** The store page counts Steam purchases in all languages. Your filters (languages, keys, dates, playtime) change `reviewsMatchingFilters`; `totalReviews` is always the store page number.

**Can I get new reviews in real time?** Steam caches keyless answers for up to 10 minutes, so new reviews appear with up to 10 minutes delay. Hourly schedules are the sweet spot.

**Which games work?** Every Steam app with reviews: games, DLC, software and soundtracks, released or Early Access.

#### Use with the API and AI agents

Run it via the [Apify API](https://docs.apify.com/api/v2) from Python, Node.js or any HTTP client (a drop-in replacement for scripts that called the old `appreviews` endpoint), or connect it to Claude, ChatGPT and other AI agents through the [Apify MCP server](https://mcp.apify.com): "What do players complain about in the negative reviews of Hollow Knight: Silksong from the last week?"

#### Other tools

| Tool | What it does |
|---|---|
| [Google Sheets Import & Export](https://apify.com/s_actors/google-sheets-import-export) | Send the reviews to a Google Sheet |
| [Roblox Game Stats & Player Count Tracker](https://apify.com/s_actors/roblox-game-stats-tracker) | Live players, visits and charts of Roblox games |
| [YouTube Comments Scraper](https://apify.com/s_actors/youtube-comments-scraper) | Comments of game trailers and let's plays, with sentiment |

#### Is it legal?

The Actor collects only public reviews that Steam shows to any visitor, through Valve's own public reviews API. Reviewers are identified only by their public Steam ID and profile link.

# Actor input Schema

## `games` (type: `array`):

One per line: Steam store links (store.steampowered.com/app/1145360/Hades/), app IDs (the number in the link) or game names (the best Steam store search match is taken). Community and SteamDB app links work too. Any number of games.

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

Limit for each game. 0 = every review that matches the filters (popular games have hundreds of thousands).

## `sort` (type: `string`):

Order of the reviews. Most recent goes through every review; Most helpful is the order of the Steam store page (all time, or within the date window).

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

Only recommended, only not recommended, or both.

## `languages` (type: `array`):

Only reviews written in these languages. Empty = all languages.

## `dateFrom` (type: `string`):

Only reviews written on or after this date: 2026-10-01, or relative: 7 days, 2 weeks, 6 months, 1 year. The window is exact (no reviews from outside it).

## `dateTo` (type: `string`):

Only reviews written on or before this date (the whole day counts): 2026-10-12, or relative: 30 days. Empty = until now.

## `minPlaytimeHours` (type: `integer`):

Only reviewers who had played at least this many hours when they wrote the review. Filters out "2 hours in" first impressions.

## `maxPlaytimeHours` (type: `integer`):

Only reviewers who had played at most this many hours when they wrote the review (first impressions, refund-window reviews).

## `steamDeckOnly` (type: `boolean`):

Only reviews by players who played mostly on Steam Deck when they wrote the review.

## `purchaseType` (type: `string`):

Steam purchases only is what the store page counts in its score; keys include Humble, Kickstarter and review copies.

## `includeOffTopic` (type: `boolean`):

Steam hides reviews from off-topic review bombing periods by default. Turn on to get them too.

## `onlyNewReviews` (type: `boolean`):

For scheduled runs (save the input as a task and add a schedule, for example every hour). The first run collects up to Max reviews per game and remembers the newest one; later runs return only reviews written since then. Sort is always Most recent.

## `monitorName` (type: `string`):

Name of the memory used by Only new reviews. Use a different name for each task, otherwise two tasks share what they have seen.

## `includeGameDetails` (type: `boolean`):

Add the game name, developer, publisher, release date, price, genres and header image to every row (one store request per game).

## `maxConcurrency` (type: `integer`):

How many games are collected at the same time. Steam limits keyless requests per IP; the Actor moves to proxy IPs when that happens.

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

Requests go direct first and move to Apify datacenter proxies (a new IP per request) when Steam rate-limits the current IP. The default works for most runs.

## `debugLog` (type: `boolean`):

Log every retried request (for troubleshooting).

## Actor input object example

```json
{
  "games": [
    "https://store.steampowered.com/app/1145360/Hades/",
    "413150"
  ],
  "maxReviewsPerGame": 100,
  "sort": "recent",
  "reviewType": "all",
  "steamDeckOnly": false,
  "purchaseType": "all",
  "includeOffTopic": false,
  "onlyNewReviews": false,
  "monitorName": "default",
  "includeGameDetails": true,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debugLog": false
}
```

# Actor output Schema

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

Review text, recommended or not, playtime, votes, language, date, Steam Deck, refunded, developer response.

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

One entry per game: store review score, total, positive and negative reviews, reviews matching your filters, game details.

## `all` (type: `string`):

Every field of every review with the game details.

# 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 = {
    "games": [
        "https://store.steampowered.com/app/1145360/Hades/",
        "413150"
    ],
    "maxReviewsPerGame": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("s_actors/steam-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 = {
    "games": [
        "https://store.steampowered.com/app/1145360/Hades/",
        "413150",
    ],
    "maxReviewsPerGame": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("s_actors/steam-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 '{
  "games": [
    "https://store.steampowered.com/app/1145360/Hades/",
    "413150"
  ],
  "maxReviewsPerGame": 100
}' |
apify call s_actors/steam-reviews-scraper --silent --output-dataset

```

## MCP server setup

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