# Steam Reviews Scraper — Exact Date Windows, No Key (`memo23/steam-reviews-scraper`) Actor

Scrape reviews for any Steam game by app id. Filter by language, positive/negative, purchase type and an exact date range. No API key, no login.

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

## Pricing

from $1.00 / 1,000 review scrapeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Reviews Scraper — Exact Date Windows, No Key

Scrape reviews for any game on Steam. Give it an app id or a store URL and get back the review text,
the verdict, the vote counts, and a full author block — playtime, games owned, review history, Steam
profile. No API key, no login, no cookies.

**Ask for a date range and get that date range.** Steam's own `day_range` filter leaks badly — asking
for 3 days returned reviews up to 3,515 days old, and a 30-day request let 33 of 60 through from
outside the window — so this scraper does not use it at all. It walks reviews newest-first and
enforces your window itself. Anything outside is never delivered and never charged, and the run log
says how many were trimmed.

### What you can filter on

| Field | Type | Default | Notes |
|---|---|---|---|
| `appIds` | array | — (required) | Numeric ids (`570`) or store URLs (`…/app/292030/…`). Several games per run |
| `maxItems` | integer | `1000` | Hard cap across the whole run |
| `language` | select | `all` | Steam language code, or every language |
| `reviewType` | select | `all` | Positive only, negative only, or both |
| `purchaseType` | select | `all` | Bought on Steam, activated from a key, or either |
| `onlyReviewsAfter` | date | — | Start of the window, e.g. `2026-01-01` |
| `onlyReviewsBefore` | date | — | End of the window; a bare date includes that whole day |
| `includeOffTopic` | boolean | `false` | Include bursts Steam classes as off-topic review bombing |

All of these are verified live, not assumed. On The Witcher 3: `negative` returned 200 rows with none
recommended, `positive` + `german` returned 100 with all recommended and all German, and
`non_steam_purchase` returned 100 with none marked as a Steam purchase.

**One caveat worth knowing.** `purchaseType` only separates anything on a **paid** game. Every
acquisition of a free-to-play title counts as a Steam purchase, so on something like Dota 2 all three
settings return identical rows. That is Steam's behaviour, not a bug here.

**A second one.** Steam serves reviews newest-first, so a window well in the past means paging down
through everything newer to reach it — a window from three weeks ago took 16 pages to fill 300 rows,
where a recent one fills immediately. The upside of walking in order is that the crawl knows when it
is finished: asking for a two-day window with a cap of 5,000 stopped after 6 pages and 191 reviews
rather than running to the cap. The log reports both the pages walked and the rows trimmed.

### What you get per review

**Review:** id, permalink, text, language, recommended or not, created and updated timestamps.

**Engagement:** helpful votes, funny votes, Steam's weighted vote score, comment count.

**Context flags:** bought on Steam, received free, written during early access, played mainly on Steam
Deck, refunded.

**Author:** Steam id, display name, profile URL, avatar, games owned, reviews written, and playtime —
at the time of the review, lifetime, and last two weeks — reported in hours rather than Steam's raw
minutes.

### Example input

```json
{
  "appIds": ["292030"],
  "maxItems": 500,
  "language": "english",
  "reviewType": "negative",
  "onlyReviewsAfter": "2026-06-01",
  "onlyReviewsBefore": "2026-08-31"
}
```

### Notes

- Steam's public review endpoint is used directly, so runs are fast and need no proxy.
- Reviews are deduplicated by `recommendationid` within a run.
- Cursor pagination stops when Steam stops advancing the cursor, rather than spinning on the last page.
- A run that finds nothing says why in its status rather than returning a silent empty dataset.

# Actor input Schema

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

Numeric Steam app ids (e.g. 570) or store URLs (e.g. https://store.steampowered.com/app/292030/). One run can cover several games.

## `maxItems` (type: `integer`):

Hard cap across every app in the run. Reviews outside your date window are never pushed and never charged, so they do not consume this.

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

Steam language code, or "all" for every language.

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

Keep only recommended or only not-recommended reviews.

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

Where the copy came from. Note this only separates anything on paid games — every acquisition of a free-to-play title counts as a Steam purchase.

## `onlyReviewsAfter` (type: `string`):

Start of the date window, e.g. 2026-01-01. Steam's own day\_range filter leaks badly, so results are trimmed to your exact dates before anything is pushed or charged.

## `onlyReviewsBefore` (type: `string`):

End of the window, e.g. 2026-03-31 (that whole day is included).

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

Steam hides bursts it classes as off-topic review bombing. Turn this on to include them.

## Actor input object example

```json
{
  "appIds": [
    "570"
  ],
  "maxItems": 1000,
  "language": "all",
  "reviewType": "all",
  "purchaseType": "all",
  "includeOffTopic": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "appIds": [
        "570"
    ],
    "onlyReviewsAfter": "",
    "onlyReviewsBefore": ""
};

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

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

```

## MCP server setup

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