# Steam Store Search & App Details Scraper (`ninhothedev/steam-search-scraper`) Actor

$0.5/1K 🔥 Steam store search scraper! Find games by keyword or genre with price, reviews, genres & specs. No key. JSON, CSV, Excel or API in seconds. Build game catalogs & price trackers ⚡

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

## Pricing

from $0.50 / 1,000 results

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/platform/actors/running/actors-in-store#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 Store Search & App Details Scraper

**Search the Steam store by keyword or genre and export every matching game as clean, structured data** — price, discount, review summary, review count, genres, categories, developer, publisher, Metacritic score, platform support and store URL.

No Steam API key. No login. No browser. Just type `roguelike`, `city builder` or `souls-like` and get a spreadsheet of every game that matches.

***

### What makes this actor different

This is the **search-driven** Steam scraper. You give it *search terms*, it gives you *the games that match them* — exactly like typing into the Steam store search box, but exported as JSON, CSV or Excel with full app details attached.

If you already know which Steam actor you need, here is the line-up:

| Actor | What it does | Use it when |
| --- | --- | --- |
| **Steam Store Search & App Details Scraper** (this one) | Searches the store by **keyword or genre**, returns matching games with full details | You want to *find* games — "every roguelike deckbuilder", "all city builders under $20" |
| [Steam Games Scraper](https://apify.com/ninhothedev/steam-games-scraper) | Scrapes details for Steam apps you already know | You already have app IDs or a fixed list of games |
| [Steam Deals Scraper](https://apify.com/ninhothedev/steam-deals-scraper) | Scrapes the discounts / specials pages | You only care about what is **on sale right now** |
| [Steam Charts Scraper](https://apify.com/ninhothedev/steam-charts-scraper) | Scrapes top sellers and player-count charts | You want **rankings and popularity**, not search |

Short version: **Games = lookup. Deals = discounts. Charts = rankings. Search (this actor) = discovery.**

***

### Features

- **Keyword and genre search** — any query the Steam store accepts works here (`roguelike`, `city builder`, `horror co-op`, `metroidvania`)
- **Multiple terms per run** — results are merged and de-duplicated by app ID
- **Full app-details enrichment** — developers, publishers, genres, categories, Metacritic, review totals, platform flags, description
- **Region-aware pricing** — set a country code and get local currency and local prices
- **Discount data** — original price, final price and discount percent
- **Search rank preserved** — see exactly where each game ranked for your term
- **Polite by design** — built-in delays keep the run under Steam's rate limits
- **No API key, no proxy required**

***

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | select | `search` | Operation mode. `search` runs a store search per term. |
| `terms` | array | `["roguelike", "city builder"]` | Keywords or genres to search for. Each is searched separately. |
| `country` | string | `us` | Two-letter country code controlling store region, currency and price. |
| `enrichDetails` | boolean | `true` | Fetch the full app-details payload for every hit. Slower, much richer. |
| `maxItems` | integer | `100` | Hard cap on games pushed to the dataset (max 1000). Split across terms. |

#### Example input

```json
{
  "mode": "search",
  "terms": ["roguelike deckbuilder", "city builder"],
  "country": "us",
  "enrichDetails": true,
  "maxItems": 200
}
```

***

### Output

One dataset item per game:

```json
{
  "app_id": 1145360,
  "name": "Hades",
  "search_rank": 3,
  "released": "Sep 17, 2020",
  "review_summary": "Overwhelmingly Positive",
  "review_total": 284065,
  "price_final": 12.49,
  "price_original": 24.99,
  "discount_pct": 50,
  "currency": "USD",
  "is_free": false,
  "developers": ["Supergiant Games"],
  "publishers": ["Supergiant Games"],
  "genres": ["Action", "Indie", "RPG"],
  "categories": ["Single-player", "Steam Achievements", "Full controller support"],
  "metacritic_score": 93,
  "windows": true,
  "mac": true,
  "linux": false,
  "short_description": "Defy the god of the dead as you hack and slash out of the Underworld.",
  "header_image": "https://shared.akamai.steamstatic.com/.../header.jpg",
  "url": "https://store.steampowered.com/app/1145360",
  "source": "steam",
  "scraped_at": "2026-07-28T14:26:16+00:00"
}
```

Every field is nullable — Steam does not publish review scores for brand-new titles, free-to-play games have no `price_overview`, and most indie games have no Metacritic entry.

Export as **JSON, CSV, Excel, XML or RSS** from the Apify dataset, or pull it through the Apify API.

***

### Use cases

#### Game market research

Search a genre, export every title, and analyse price distribution, review sentiment and release cadence. Answer questions like "what does a roguelike deckbuilder actually sell for?" before you price your own.

#### Price comparison and monitoring

Run the same terms against several `country` codes and compare regional pricing, or schedule a daily run and diff `price_final` to catch discounts the moment they go live.

#### Catalog building

Populate a games database, a genre directory, a "best of" listicle or an internal recommendation engine with clean metadata and header images — no manual copy-paste.

#### Affiliate and content sites

Build genre landing pages, price-drop feeds or curated collections with real store data, review summaries and cover art, refreshed on a schedule.

***

### Pricing

Roughly **$0.50 per 1,000 games** scraped on the Apify platform, depending on whether detail enrichment is enabled. A 100-game run with full enrichment typically costs a few cents.

Detail enrichment adds one request per game. Turn `enrichDetails` off for the fastest and cheapest runs when you only need name, price, rank and review summary.

***

### How it works

1. Calls Steam's infinite-scroll store search endpoint (`/search/results/?...&json=1`), which returns a JSON envelope containing rendered HTML.
2. Parses `a.search_result_row` elements with BeautifulSoup — app ID, title, release date, review tooltip, price block, platform icons and capsule image.
3. Optionally calls `/api/appdetails?appids=...` per game for developers, publishers, genres, categories, Metacritic, review totals and description.
4. Pages through results until `maxItems` is reached, pushing to the dataset in batches of 50.

Requests use a Chrome browser fingerprint (`curl_cffi`) with a plain `urllib` fallback, plus built-in delays to stay under Steam's ~200 requests / 5 minutes limit.

***

### Related actors

- [Steam Games Scraper](https://apify.com/ninhothedev/steam-games-scraper) — detail lookup for known Steam apps
- [Steam Deals Scraper](https://apify.com/ninhothedev/steam-deals-scraper) — current Steam discounts and specials
- [Steam Charts Scraper](https://apify.com/ninhothedev/steam-charts-scraper) — top sellers and player-count charts
- [GOG Games Scraper](https://apify.com/ninhothedev/gog-games-scraper) — the same idea for the GOG store

***

### FAQ

**Do I need a Steam API key?**
No. This actor uses the public store endpoints that power the Steam website itself.

**Can I search by genre instead of keyword?**
Yes. Steam's search matches genre and tag names, so `roguelike`, `city builder` and `metroidvania` all work as terms.

**Why is `metacritic_score` empty for most games?**
Most indie titles are never reviewed by Metacritic. The field stays `null` rather than being faked.

**Why does a game have no price?**
Free-to-play titles and unreleased games have no price payload. Check `is_free` to distinguish them.

**How many games can I get per term?**
Steam search returns thousands of hits per query; the actor pages through them until `maxItems` (max 1000 per run) is reached.

**Is this legal?**
It reads publicly available store pages, the same data any visitor sees, and collects no personal data. Respect Steam's terms of service and keep your run frequency reasonable.

***

### Disclaimer

This actor is not affiliated with, endorsed by or sponsored by Valve Corporation or Steam. All game data and trademarks belong to their respective owners.

# Actor input Schema

## `mode` (type: `string`):

What the actor should do. 'search' runs a Steam store search for each of your terms and returns the matching games, optionally enriched with full app details.

## `terms` (type: `array`):

Keywords or genres to search the Steam store for, e.g. 'roguelike', 'city builder', 'souls-like', 'horror co-op'. Each term is searched separately and results are merged and de-duplicated by app ID.

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

Two-letter country code that decides the store region, currency and prices (e.g. 'us' for USD, 'de' for EUR, 'gb' for GBP, 'br' for BRL).

## `enrichDetails` (type: `boolean`):

If enabled, each search hit is enriched via the Steam app-details endpoint, adding developers, publishers, genres, categories, Metacritic score, total review count, platform flags and the short description. Slower but far richer. Disable for a fast, price-only run.

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

Hard cap on how many games are pushed to the dataset across all search terms. The budget is split evenly between your terms. Maximum 1000.

## Actor input object example

```json
{
  "mode": "search",
  "terms": [
    "roguelike",
    "city builder"
  ],
  "country": "us",
  "enrichDetails": true,
  "maxItems": 100
}
```

# 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 = {
    "terms": [
        "roguelike",
        "city builder"
    ],
    "country": "us",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("ninhothedev/steam-search-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 = {
    "terms": [
        "roguelike",
        "city builder",
    ],
    "country": "us",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("ninhothedev/steam-search-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 '{
  "terms": [
    "roguelike",
    "city builder"
  ],
  "country": "us",
  "maxItems": 100
}' |
apify call ninhothedev/steam-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/aFzcs2rbl6biEsb4r/builds/KUrJJFlSEyXOQxct5/openapi.json