# Steam MCP Server — Game Search & Deals for AI (`longanimous_bracken/steam-scraper`) Actor

MCP Server for Steam. Search games, prices, and deals. AI-agent ready.

- **URL**: https://apify.com/longanimous\_bracken/steam-scraper.md
- **Developed by:** [petteri mähönen](https://apify.com/longanimous_bracken) (community)
- **Categories:** Other, Developer tools, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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 MCP Server — Game Search & Deals for AI

### 🧠 MCP Server — AI Agent Ready

This actor is a **Model Context Protocol (MCP) server** — AI assistants (Claude, GPT, Cursor) can call it directly to search and extract data:

```json
{"searchQuery": "example", "maxResults": 5}
```

Search Steam games, prices, and deals. Returns titles, prices, ratings, discounts — perfect for gaming market intelligence.

Search and extract game data from Steam Store with full API enrichment. Extract titles, prices, ratings, genres, tags, descriptions, screenshots, and 27+ fields per game.

### Features

- **Search & Extract** — Search Steam Store by keyword and extract game listings from search results
- **API Enrichment** — Enrich every result with Steam's official API for detailed descriptions, tags, genres, screenshots, developers, publishers, and more
- **Country-Specific Pricing** — Pass a country code (`cc`) to get localized pricing (USD, EUR, GBP, etc.)
- **Structured Output** — All results normalized to a consistent schema with 27+ fields
- **Lightweight** — CheerioCrawler, fast and cost-effective (no Playwright)

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | `"cyberpunk"` | Search term for Steam Store search |
| `tags` | string\[] | `[]` | Steam tags to filter by (e.g. "Singleplayer", "RPG") |
| `categories` | string\[] | `[]` | Steam categories (e.g. "Genre:Action", "Feature:Controller") |
| `priceMin` | number | `0` | Minimum price filter (0 = no minimum) |
| `priceMax` | number | `0` | Maximum price filter (0 = no maximum) |
| `maxResults` | number | `0` | Maximum number of games to extract (0 = no limit) |
| `fetchDetails` | boolean | `true` | Enrich results via Steam API (descriptions, tags, screenshots) |
| `cc` | string | `"us"` | Country code for localized pricing (e.g., `us`, `de`, `gb`, `jp`) |
| `sortBy` | string | `"relevance"` | Sort: relevance, price\_asc, price\_desc, name\_asc, name\_desc, released\_desc |
| `sortOrder` | string | `"desc"` | Sort order: asc or desc |

### Output Schema

Each result contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Game title |
| `app_id` | number | Steam App ID |
| `type` | string | App type (game, demorequire, etc.) |
| `price_cents` | number | Current price in cents |
| `discount_percent` | number | Current discount percentage |
| `release_date` | string | Release date (coming soon / month/year or exact date) |
| `review_percentage` | number | Positive review percentage (0-100) |
| `review_sentiment` | string | "Overwhelmingly Positive", "Very Positive", etc. |
| `platforms` | object | `{ windows, mac, linux }` — boolean flags |
| `url` | string | Steam Store URL |
| `steam_url` | string | Full Steam Store URL |
| `source` | string | Always `"steam"` |
| `cc` | string | Country code used for pricing |
| `search_query` | string | Original search query |
| `short_description` | string | Brief game description (from API) |
| `detailed_description` | string | Full HTML description (from API) |
| `about_the_game` | string | About section (from API) |
| `header_image` | string | Header image URL (from API) |
| `capsule_image` | string | Capsule image URL (from API) |
| `website` | string | Official game website (from API) |
| `developers` | array | Developer names |
| `publishers` | array | Publisher names |
| `currency` | string | Currency code (USD, EUR, etc.) |
| `price_initial_cents` | number | Original price before discount |
| `price_final_cents` | number | Current price after discount |
| `is_free` | boolean | Whether the game is free-to-play |
| `required_age` | number | Required age restriction |
| `metacritic_score` | number | Metacritic score (if available) |
| `recommendations` | number | Total number of user recommendations |
| `genres` | array | Genre names (e.g., `"Action"`, `"RPG"`) |
| `tags` | array | Tag names with counts |
| `categories` | array | Category names (e.g., `"Single-player"`, `"Steam Achievements"`) |
| `screenshots` | array | Screenshot image URLs (from API) |
| `achievements_total` | number | Total achievements (if available) |
| `dlc_count` | number | Number of DLC packages |
| `supported_languages` | array | Supported language codes |

### Example

#### Input

```json
{
  "searchQuery": "rpg",
  "maxResults": 20,
  "fetchDetails": true,
  "cc": "US"
}
```

#### Output (per item)

```json
{
  "title": "Baldur's Gate 3",
  "app_id": 1086940,
  "type": "game",
  "price_cents": 5999,
  "discount_percent": 0,
  "release_date": "3 Aug, 2023",
  "review_percentage": 96,
  "review_sentiment": "Overwhelmingly Positive",
  "platforms": { "windows": true, "mac": true, "linux": false },
  "url": "https://store.steampowered.com/app/1086940/Baldurs_Gate_3/",
  "steam_url": "https://store.steampowered.com/app/1086940/",
  "source": "steam",
  "cc": "US",
  "search_query": "rpg",
  "short_description": "Gather your party and return to the Forgotten Realms...",
  "developers": ["Larian Studios"],
  "publishers": ["Larian Studios"],
  "currency": "USD",
  "is_free": false,
  "genres": ["RPG", "Strategy"],
  "tags": ["RPG", "Story Rich", "Character Customization", ...],
  "categories": ["Single-player", "Multi-player", "Steam Achievements", ...],
  "screenshots": ["https://cdn.akamai.steamstatic.com/.../1.jpg", ...],
  "achievements_total": 54,
  "dlc_count": 0
}
```

### Use Cases

- **Game market research** — Analyze pricing, genres, and tags across Steam's catalog
- **Competitive analysis** — Track competitor game details, pricing changes, and review trends
- **Price monitoring** — Set up recurring runs to detect sales and discount patterns
- **Content aggregation** — Build game recommendation engines or curated lists
- **Data science** — Train ML models on game metadata, pricing, and review correlations

### Limitations

- Steam API allows only one App ID per request — enrichment is sequential (concurrency-limited)
- Free plan users: enrichment for 100+ games may take 30-60 seconds
- Steam rate limits apply — very large extractions (500+ games) may be throttled
- Some fields may be null for upcoming games or early access titles

### Pricing

This actor uses Apify's **Pay Per Event** model:

- **Result:** $0.001 per result ($1.00 per 1,000 results)
- **Actor Start:** $0.00005 (one-time per run)

With CheerioCrawler, runs are extremely cost-effective — a search returning 20 enriched games costs just ~$0.025.

### 💬 Quick Start for AI Assistants

Copy and paste this into ChatGPT, Claude, or another AI assistant to get help using this actor:

***

You are helping me use the "Steam Store Scraper" on Apify (actor ID: twcEXldXp9Z44wDcG). It searches and extracts game data from Steam Store with full API enrichment — titles, prices, ratings, genres, tags, descriptions, screenshots, and 27+ fields per game.

Input fields:

- searchQuery: string, e.g. "cyberpunk" or "rpg" (default: "cyberpunk")
- tags: string array, Steam tags to filter (e.g. "Singleplayer", "RPG")
- categories: string array, Steam categories (e.g. "Genre:Action")
- priceMin, priceMax: number, price filter (0 = no limit)
- maxResults: number, max games (0 = no limit, default: 0)
- fetchDetails: boolean, enrich via Steam API (default: true)
- cc: string, country code for pricing (us, de, gb, jp, etc., default: "us")
- sortBy: string, "relevance" | "price\_asc" | "price\_desc" | "name\_asc" | "released\_desc"

Output fields: title, app\_id, price\_cents, discount\_percent, review\_percentage, platforms, url, genres, tags, developers, publishers, screenshots, 27+ total fields.

## Help me with the right input, output processing, or troubleshooting.

### Changelog

| Version | Date | Changes |
|---------|------|---------|
| 0.2 | 2026-07-17 | Cloud deployment verified — 10 games, 10/10 enriched |
| 0.1 | 2026-07-17 | Initial release: search + Steam API enrichment, 27+ fields |

***

### Support & Feedback

**Enjoying this Actor?** [Leave a review on Apify Store](https://apify.com/longanimous_bracken/steam-scraper/reviews) — it helps others discover the tool.

Found a bug or have a feature request? [Open an issue](https://console.apify.com/actors/twcEXldXp9Z44wDcG/issues) on the Actor page.

# Actor input Schema

## `searchQuery` (type: `string`):

Search term for Steam Store (e.g. 'cyberpunk', 'rpg', 'indie').

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

Steam tags to filter by (e.g. 'Singleplayer', 'Indie', 'RPG').

## `categories` (type: `array`):

Steam categories (e.g. 'Genre:Action', 'Feature:Controller').

## `priceMin` (type: `number`):

Minimum price filter in local currency. 0 = no minimum.

## `priceMax` (type: `number`):

Maximum price filter in local currency. 0 = no maximum.

## `cc` (type: `string`):

Two-letter country code for pricing (e.g. 'us', 'eu', 'gb', 'fi').

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

Sort order for search results.

## `sortOrder` (type: `string`):

Ascending or descending sort order.

## `maxResults` (type: `integer`):

Maximum number of games to extract (hard cap 500). Defaults to 100.

## `maxPages` (type: `integer`):

Maximum number of search pages to crawl. Defaults to ceil(maxResults/50).

## `fetchDetails` (type: `boolean`):

Enrich results with full game data from Steam App Details API (genres, descriptions, screenshots, achievements, etc.).

## Actor input object example

```json
{
  "searchQuery": "cyberpunk",
  "tags": [],
  "categories": [],
  "priceMin": 0,
  "priceMax": 0,
  "cc": "us",
  "sortBy": "relevance",
  "sortOrder": "desc",
  "maxResults": 100,
  "maxPages": 0,
  "fetchDetails": true
}
```

# Actor output Schema

## `listings` (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 = {};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

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