# Steam Store Scraper - Games, Prices, Tags, Reviews (`fabrikit/steam-store-scraper`) Actor

Scrape the Steam store: top sellers, new releases, specials, searches by keyword or tag, or any app ID. Price and discount, release date, developers, genres, tags, Metacritic, review totals, platforms. From US$1 per 1,000 games.

- **URL**: https://apify.com/fabrikit/steam-store-scraper.md
- **Developed by:** [Fabrikit](https://apify.com/fabrikit) (community)
- **Categories:** E-commerce, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 games

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

Pull game data straight from the public Steam store: **top sellers, new releases, upcoming games, specials, keyword and tag searches, or any list of app IDs / store URLs**. Prices in any store currency, discounts, release dates, developers and publishers, genres, user tags, Metacritic, review totals, platforms, DLC count and more.

No login, no API key. Company and game data only - no review texts, no reviewer names.

### What you get

| Field | Description |
|---|---|
| `appId`, `name`, `type`, `url` | Identity of the store item |
| `isFree`, `currency`, `priceInitial`, `priceFinal`, `discountPercent`, `priceFormatted` | Price in the selected store country |
| `releaseDate`, `comingSoon` | Release information |
| `developers`, `publishers` | Studios (companies) |
| `genres`, `categories`, `tags` | Steam genres, store features and the most voted user tags |
| `platforms` | Windows / macOS / Linux flags |
| `metacriticScore`, `metacriticUrl` | Metacritic data when Steam shows it |
| `reviewScore`, `reviewScoreDesc`, `totalPositive`, `totalNegative`, `totalReviews` | Review summary (totals only) |
| `shortDescription`, `headerImage`, `requiredAge`, `dlcCount`, `website` | Store page content |

### Input examples

Top 50 sellers in Germany, German texts:

```json
{ "listing": "topsellers", "country": "de", "language": "german", "maxItems": 50 }
```

Co-op roguelikes under 15 USD, fast mode (search-level data only):

```json
{ "listing": "none", "tags": ["Roguelike", "Co-op"], "maxPrice": 15, "includeDetails": false, "maxItems": 500 }
```

Specific games:

```json
{ "listing": "none", "appIds": ["620", "570"], "startUrls": ["https://store.steampowered.com/app/1245620/ELDEN_RING/"] }
```

### Output example

```json
{
  "appId": 620,
  "name": "Portal 2",
  "type": "game",
  "url": "https://store.steampowered.com/app/620/Portal_2/",
  "isFree": false,
  "currency": "USD",
  "priceInitial": 9.99,
  "priceFinal": 9.99,
  "discountPercent": 0,
  "releaseDate": "18 Apr, 2011",
  "developers": ["Valve"],
  "genres": ["Action", "Adventure"],
  "tags": ["Puzzle", "Co-op", "First-Person"],
  "metacriticScore": 95,
  "reviewScoreDesc": "Overwhelmingly Positive",
  "totalPositive": 462323,
  "totalNegative": 6070,
  "totalReviews": 468393
}
```

### Modes and speed

- **Full details (default):** one store record per game. Steam allows roughly 200 detail requests per 5 minutes per IP, so the actor paces itself at about 1.7 seconds per game (about 35 games per minute). If Steam answers with a rate limit, the actor waits and, on Apify, moves to a residential proxy.
- **Fast mode (`includeDetails: false`):** only the search listing is read - hundreds of games per second. You still get name, current price and discount, release date, platforms, review summary and user tags; developers, genres, Metacritic, description and DLC count are `null`.

### Pricing

Pay per result: **US$1 per 1,000 games** (event `game-result`), plus the small standard Apify start event. You never pay for failed or skipped lookups.

### FAQ

**Can I scrape reviews?** No. This actor returns only the review *summary* (score and totals), never review texts or authors.

**How do I get prices in another currency?** Set `country` to the store country (`gb`, `br`, `cl`, `jp`...). `language` controls the language of descriptions, genres and tags.

**How many games can one search return?** Steam search lists thousands of matches; the actor pages through them 100 at a time until `maxItems`.

**Tag names?** Use the names you see on Steam ("Open World", "Roguelike") or numeric tag IDs. All listed tags must match.

### Use cases

Market and pricing research, discount trackers, publisher/competitor catalogues, game recommendation datasets, genre trend analysis.

***

### En espanol

Extrae datos publicos de la tienda de Steam: mas vendidos, novedades, proximos lanzamientos, ofertas, busquedas por palabra o etiqueta y consultas por app ID o URL. Devuelve precio y descuento (en la moneda del pais elegido), fecha de lanzamiento, desarrolladoras, generos, etiquetas, Metacritic y totales de resenas (sin textos ni autores). Modo rapido (`includeDetails: false`) para listados masivos; el modo completo respeta el limite de Steam (~200 consultas cada 5 min). Precio: US$1 por cada 1.000 juegos.

# Actor input Schema

## `listing` (type: `string`):

Which Steam list to read. 'Search only' uses just your search terms and tags below.

## `searchTerms` (type: `array`):

Keywords to search on the Steam store, one search per entry (for example: farming, deck builder). Combined with the list and tag filters.

## `tags` (type: `array`):

Only games with ALL of these Steam tags. Use the names shown on Steam (Roguelike, Co-op, Open World, Indie...) or numeric tag IDs.

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

Look up specific games by Steam app ID (for example 620 for Portal 2). They are added after the search results.

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

Steam store game URLs such as https://store.steampowered.com/app/620/Portal_2/.

## `contentType` (type: `string`):

What kind of store items to search. Games only is the default.

## `maxPrice` (type: `integer`):

Only games up to this price in whole currency units of the selected country (0 = free games only). Leave empty for no limit.

## `onlyDiscounted` (type: `boolean`):

Only games currently on sale.

## `platform` (type: `string`):

Only games available on this operating system.

## `sortBy` (type: `string`):

Order of the search results. Relevance is the Steam default (top sellers order for lists).

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

Two-letter Steam store country code that sets prices and currency (us, gb, de, es, cl, br, jp...).

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

Steam language name used for descriptions, genres and tags (english, spanish, german, french, latam, brazilian...).

## `includeDetails` (type: `boolean`):

Fetch the full store record for every game (developers, publishers, genres, metacritic, description, DLC, exact price). Turn off for a much faster run with search-level data only (name, price, release date, reviews, tags). Steam allows about 200 detail lookups per 5 minutes, so detail runs take roughly 1.7 seconds per game.

## `includeReviewSummary` (type: `boolean`):

Add exact positive/negative review totals and the review score (no review texts or reviewer names). Only used when full game details are on.

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

Maximum number of games to save.

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

Steam works without a proxy; Apify datacenter proxy is the default. If Steam rate-limits the run, the actor switches to a residential proxy automatically.

## Actor input object example

```json
{
  "listing": "topsellers",
  "contentType": "games",
  "onlyDiscounted": false,
  "platform": "any",
  "sortBy": "_ASC",
  "country": "us",
  "language": "english",
  "includeDetails": true,
  "includeReviewSummary": true,
  "maxItems": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All records collected during the run

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/steam-store-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 = { "proxyConfiguration": { "useApifyProxy": True } }

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/steam-store-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/steam-store-scraper --silent --output-dataset

```

## MCP server setup

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