# Steam Scraper — Games, Prices, Reviews & Charts (`scrapesage/steam-scraper`) Actor

Scrape the Steam store: search games, full game details, prices & discounts, user reviews with sentiment, top sellers / new releases / specials charts, and SteamSpy owner & player stats. Publisher leads (website, support email), monitoring mode, any storefront. No login, no key, no browser.

- **URL**: https://apify.com/scrapesage/steam-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** E-commerce, Agents, Integrations
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.38 / 1,000 game scrapeds

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?

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 Scraper — Games, Prices, Reviews & Charts

> **Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Valve Corporation or any of its subsidiaries. All trademarks mentioned are the property of their respective owners. "Steam" is referenced only to describe the publicly available website this Actor collects data from.

Extract **everything public on the [Steam store](https://store.steampowered.com)** — full **game details** (price, discount, genres, categories, platforms, Metacritic, release date, screenshots), **user reviews** with a **sentiment summary**, **top-seller / new-release / specials charts**, and **SteamSpy stats** (owner estimates, concurrent players, playtime, community tags). Built straight on Steam's own store endpoints for clean, fast, structured data.

No login, no API key, no browser — and an optional **monitoring mode** that returns only new games and new reviews on each run.

### Why this Steam scraper?

Most Steam scrapers do one narrow thing — reviews only, or a single chart. This actor rolls **four jobs into one tool** and ships the **richest dataset in the category**: the complete game record, the review stream *and* the sentiment summary, plus owner/player estimates the official API never exposes.

| Data | Typical Steam scrapers | This actor |
|---|---|---|
| Search & browse games (keyword, sort, specials) | partial | ✅ |
| Full game details (price, discount, genres, platforms, Metacritic, release date…) | basic fields | ✅ 70+ fields |
| Derived analytics (priceFinalUsd, isDiscounted, releaseYear, achievementsCount, platformList…) | ❌ | ✅ computed per game |
| **SteamSpy** owners, peak concurrent players, playtime & community tags | ❌ | ✅ |
| **Publisher leads** — developer/publisher, website, support URL & email | ❌ | ✅ when published |
| Charts — top sellers / new releases / specials / coming soon | sometimes | ✅ |
| User reviews (recommendation, text, votes, author playtime) | ✅ | ✅ |
| **Review sentiment summary** (score, % positive, totals) | ❌ | ✅ one row per app |
| App ID ⇄ store URL — both accepted | partial | ✅ |
| **Monitoring mode** — only new games / reviews | ❌ | ✅ |
| One run, four jobs (search · details · charts · reviews) | ❌ | ✅ |

### Use cases

- **Game-market & competitive research** — see who tops a category or ranks for a keyword, with price, discount, Metacritic, review counts and SteamSpy owner/player estimates; benchmark your game against its rivals.
- **Price & discount monitoring** — track prices and sales across any storefront; run the specials chart on a schedule with monitoring mode to catch new discounts the moment they go live.
- **Review intelligence** — pull the full review stream plus a sentiment summary (e.g. *Overwhelmingly Positive, 96.8%*); monitor new reviews for sentiment dashboards, bug signals and support alerts.
- **Publisher & developer lead-gen** — capture the studio/publisher, their website and support contact (where Steam publishes it) for partnerships, BD and outreach.
- **Discovery & aggregation** — power dashboards, newsletters and datasets with structured game metadata across countries, genres and charts.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Steam Scraper**, pick a **mode** (Search, App details, Charts, or Reviews), fill in the matching field, and click **Start**.
3. Watch results stream into the dataset table as each record is parsed.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

Search a keyword, sorted by user reviews, enriched with SteamSpy stats:

```json
{
    "mode": "search",
    "searchTerms": ["roguelike", "city builder"],
    "sortBy": "reviews",
    "maxAppsPerQuery": 50,
    "includeSteamSpy": true,
    "country": "us"
}
```

Pull the newest reviews for specific games, on a schedule, getting only new ones each run:

```json
{
    "mode": "reviews",
    "appIds": ["730", "292030", "https://store.steampowered.com/app/570/"],
    "maxReviewsPerApp": 500,
    "reviewsFilter": "recent",
    "monitorMode": true
}
```

- **mode** — `search`, `appDetails`, `charts`, or `reviews`. Each mode uses the field that matches it (`searchTerms`, `appIds`, `collection`, or `appIds`).
- **appIds** — numeric Steam app IDs (`730`) or full store URLs (`https://store.steampowered.com/app/292030/`); both are accepted.
- **collection** — for `charts`: `top_sellers`, `specials`, `new_releases`, or `coming_soon`.
- **sortBy / onlySpecials** — for `search`: order results (relevance, release date, reviews, price…) and optionally return only discounted games. Leave `searchTerms` empty with `onlySpecials` on to browse every game on sale store-wide.
- **fullDetails** *(default true)* — for charts, enrich each game with its full record; turn off for a faster, lighter list. Search always returns full records.
- **includeSteamSpy** *(default true)* — add owner/player/playtime/tag stats to each full game record.
- **maxReviewsPerApp / reviewsFilter / reviewLanguage / reviewType / purchaseType** — review controls (see **Reviews** below).
- **country / language** — storefront (`us`, `gb`, `de`, `br`…) and store-text language (`en`, `de`, `french`).
- **monitorMode / monitorStoreName** — emit only records not seen in previous runs (see **Monitoring** below).
- **proxyConfiguration** — proxy settings (Apify proxy by default).

### Output

One dataset; every row is tagged with a `type` (`game`, `review`, or `reviewSummary`). Use the **Games**, **Publisher leads**, and **Reviews** views to switch the columns.

A game record (`type: "game"`, abridged — 70+ fields in total, including all raw Steam fields, the derived analytics and optional SteamSpy block):

```json
{
    "type": "game",
    "appId": 292030,
    "title": "The Witcher 3: Wild Hunt",
    "appType": "game",
    "isFree": false,
    "priceFinalUsd": 39.99,
    "priceFormatted": "$39.99",
    "discountPercent": 0,
    "isDiscounted": false,
    "metacriticScore": 93,
    "recommendationsTotal": 871862,
    "genreList": ["RPG"],
    "categoryList": ["Single-player", "Steam Achievements", "Steam Cloud"],
    "platformList": ["windows", "mac", "linux"],
    "releaseDate": "May 18, 2015",
    "releaseYear": 2015,
    "achievementsCount": 78,
    "developer": {
        "developers": ["CD PROJEKT RED"],
        "publishers": ["CD PROJEKT RED"],
        "website": "https://www.thewitcher.com/witcher3",
        "supportUrl": "https://support.cdprojektred.com/",
        "supportEmail": ""
    },
    "steamSpy": {
        "owners": "20,000,000 .. 50,000,000",
        "peakConcurrentYesterday": 15893,
        "averagePlaytimeForeverMin": 4200,
        "positiveVotes": 800000,
        "negativeVotes": 20000,
        "tags": { "Open World": 12000, "RPG": 11000, "Story Rich": 9000 }
    },
    "url": "https://store.steampowered.com/app/292030",
    "scrapedAt": "2026-06-14T12:00:00.000Z"
}
```

A review record (`type: "review"`), plus one `reviewSummary` row per app:

```json
{
    "type": "review",
    "appId": 292030,
    "reviewId": "187654321",
    "votedUp": true,
    "review": "One of the best RPGs ever made…",
    "language": "english",
    "votesUp": 42,
    "votesFunny": 3,
    "weightedVoteScore": 0.86,
    "steamPurchase": true,
    "writtenDuringEarlyAccess": false,
    "createdAt": "2026-06-09T18:55:13.000Z",
    "author": {
        "steamId": "765611…",
        "numGamesOwned": 187,
        "numReviews": 24,
        "playtimeForeverMin": 936,
        "playtimeAtReviewMin": 720
    },
    "scrapedAt": "2026-06-14T12:00:00.000Z"
}
```

**Coverage notes.** Game data comes from Steam's own store endpoints, so core fields (title, price, genres, platforms, release date, developers/publishers) are near-universal; optional fields (Metacritic, achievements, support email) appear when Steam or the publisher provides them. SteamSpy owner/player figures are third-party *estimates*. A game that is region-locked or removed in the selected storefront is reported as skipped, not as an error. Empty results (e.g. a game with no reviews) are a successful run.

### Reviews — full stream + sentiment

Reviews mode returns **one `reviewSummary` row per app** — Steam's overall `reviewScoreDesc` (e.g. *Very Positive*), the positive percentage and totals — followed by the **individual reviews** themselves. Steam paginates 100 at a time via a cursor, so set `maxReviewsPerApp` high to walk the full history, or use `reviewsFilter: "recent"` with monitoring mode to capture only the newest reviews each run. Filter by `reviewLanguage`, `reviewType` (positive/negative) and `purchaseType` (Steam vs. key activations).

### Monitoring — get only new games & reviews

Turn on **`monitorMode`** to make repeat runs incremental. The actor remembers what it has already returned (app IDs for search/charts/details modes; review IDs for reviews mode) in a named key-value store (**`monitorStoreName`**) and emits **only records that are new since the last run**.

- Track the **specials chart** and get only *new discounts* as they appear.
- Track a **new-releases chart** or a **keyword** and capture only *new games*.
- Track a game's **reviews** and capture only the *newest reviews* each run — perfect for sentiment dashboards and support alerts.
- It works **alongside [Apify Schedules](https://docs.apify.com/platform/schedules)**, not against them: the schedule triggers the run on your cron; monitoring mode dedupes against earlier runs so each run yields only fresh data. Use a distinct `monitorStoreName` per tracked target so their histories stay separate.

### How much does it cost to scrape Steam?

This Actor uses Apify's **pay-per-event** pricing: you are charged only for the results it delivers, with no monthly rental and no start fee. The events it can charge are:

- **Game Scraped** - One Steam record: full store metadata - price & discount, genres, categories, platforms, metacritic, review count, release date, developers/publishers, screenshots, plus derived analytics and optional SteamSpy owner & player stats.
- **Review Scraped** - One user review: recommendation (up/down), text, language, helpful & funny votes, helpfulness score, author playtime and games owned, purchase type and dates.

The current price of each event is shown on the **Pricing** tab of this page. Set a maximum total charge on the run if you want a hard cap on spend, and use the input limits to control how much the Actor fetches.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it on a cron to keep prices, charts and reviews fresh.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/steam-scraper').call({
    mode: 'charts',
    collection: 'specials',
    fullDetails: true,
    maxAppsPerQuery: 50,
    country: 'us',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} records`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new games or price drops straight into your CRM or sheet.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored game drops in price or gets new reviews.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find the top 25 roguelikes on Steam by review score and summarise their prices and player counts" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **app/game-market & competitive-intel stack** — cover every store your market lives on:

- **[Google Play Scraper](https://apify.com/scrapesage/google-play-scraper)** — the Android app market: search, app details, charts, developer portfolios, reviews and developer-contact leads.
- **[Apple App Store Scraper](https://apify.com/scrapesage/app-store-scraper)** — the iOS app market: apps, reviews, charts and developer portfolios.
- **[Product Hunt Scraper](https://apify.com/scrapesage/product-hunt-scraper)** — new product launches, makers & maker leads.
- **[Google Ads Transparency Scraper](https://apify.com/scrapesage/google-ads-transparency-scraper)** — see exactly which ads any advertiser is running.
- **[Facebook Ad Library Scraper](https://apify.com/scrapesage/facebook-ad-library-scraper)** — competitor ad creatives on Meta & Instagram.
- **[Y Combinator Scraper](https://apify.com/scrapesage/ycombinator-scraper)** — startups, founders & jobs from the YC directory.
- **[LinkedIn Jobs Scraper](https://apify.com/scrapesage/linkedin-jobs-scraper)** — job postings as hiring-intent signals.
- **[Telegram Scraper](https://apify.com/scrapesage/telegram-scraper)** — channels, messages, media & search.

### Tips

- **Charts:** pick a `collection` (top sellers / specials / new releases / coming soon), set `country`, and keep `fullDetails` on for the complete per-game record; turn it off for a faster, lighter list when you only need names, prices and discounts.
- **Browse all sales:** set `mode: "search"`, leave `searchTerms` empty and turn on `onlySpecials` to sweep every discounted game store-wide, sorted however you like.
- **Reviews at scale:** Steam walks reviews by cursor, so set `maxReviewsPerApp` high to capture the full history — or schedule with monitoring mode to keep accumulating only new reviews.
- **SteamSpy:** keep `includeSteamSpy` on for owner estimates, concurrent players and community tags — the numbers the official store API doesn't give you.
- **Localize:** set `country` (and `language`) to match the storefront you care about; pricing and availability change by country.

### FAQ

**Do I need a Steam account or API key?** No. This actor reads Steam's public store endpoints — no login, key, or cookies.

**How many reviews can I get per app?** As many as you set in `maxReviewsPerApp` — Steam paginates by cursor, so the full review history is reachable. Use monitoring mode on a schedule to keep capturing new reviews over time.

**Where do owner and player numbers come from?** From [SteamSpy](https://steamspy.com), a third-party service that *estimates* owners and tracks concurrent players, playtime and community tags. Treat them as estimates, not official figures.

**Does it include developer/publisher contact details?** It includes the developer and publisher names, the game's website, and the support URL/email **where Steam publishes them** — many studios fill these in, some leave them blank.

**Can I scrape a specific country's store?** Yes — set `country` (and optionally `language`). Pricing, discounts and availability are all storefront-specific.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**Is scraping Steam legal?** This actor collects publicly available data only. You're responsible for using the data in compliance with applicable laws (e.g. GDPR/CCPA for personal data) and Steam's terms.

### Disclaimer

**This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Valve Corporation or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.**

"Steam" and any related marks are the property of their respective owners and are used here only in a descriptive, nominative sense - to identify the publicly accessible website from which this Actor collects data. This Actor is not an official Steam product, is not authorised or certified by Valve Corporation, and does not distribute Steam software. It collects only publicly available information; you are responsible for ensuring your use of that data complies with applicable laws, regulations and the terms of the source website.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

Pick a job. Search finds games by keyword (or browse all). App details pulls the full record for specific games. Charts lists top sellers / new releases / specials / coming soon. Reviews pulls user reviews with a sentiment summary.

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

Keywords to search the Steam store for, e.g. <code>roguelike</code>, <code>city builder</code>. One row per term. (Mode: Search.)

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

Numeric Steam app IDs (e.g. <code>730</code>, <code>292030</code>) or full store URLs (e.g. <code>https://store.steampowered.com/app/292030/</code>). Used by the App details and Reviews modes.

## `collection` (type: `string`):

Which Steam chart to pull. (Mode: Charts.)

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

Ordering for the Search mode discovery results.

## `onlySpecials` (type: `boolean`):

In Search mode, return only games currently on sale. Leave Search terms empty with this on to browse ALL discounted games store-wide.

## `maxAppsPerQuery` (type: `integer`):

Cap the number of games returned per search term or chart.

## `fullDetails` (type: `boolean`):

For Charts, open each game for the complete record (full description, genres, categories, platforms, metacritic, release date, screenshots…). Off = a faster, lighter list (name, price, discount). Search always returns full records.

## `includeSteamSpy` (type: `boolean`):

Add SteamSpy enrichment to each full game record: estimated owners, peak concurrent players, average/median playtime, positive/negative votes and community tags — data the official store API does not expose.

## `maxReviewsPerApp` (type: `integer`):

How many reviews to fetch per app (Mode: Reviews). Steam paginates 100 at a time via a cursor; set high to capture the full history.

## `reviewsFilter` (type: `string`):

How reviews are ordered. <code>recent</code> = newest first (best for monitoring), <code>updated</code> = recently updated, <code>all</code> = Steam's relevance ranking. (Mode: Reviews.)

## `reviewLanguage` (type: `string`):

Steam language code to filter reviews (e.g. <code>english</code>, <code>schinese</code>, <code>russian</code>), or <code>all</code> for every language. (Mode: Reviews.)

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

Limit reviews to positive, negative, or all. (Mode: Reviews.)

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

Limit reviews to Steam purchasers, non-Steam (key) activations, or all. (Mode: Reviews.)

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

Two-letter country code (e.g. <code>us</code>, <code>gb</code>, <code>de</code>, <code>br</code>). Affects pricing and availability.

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

Steam language for store text (e.g. <code>en</code>, <code>de</code>, <code>french</code>). Affects descriptions, genres and category labels.

## `monitorMode` (type: `boolean`):

Remember what was already returned and emit ONLY records not seen in previous runs (new games for a search/chart, or new reviews for an app). Pairs with Apify Schedules to track changes over time.

## `monitorStoreName` (type: `string`):

Named key-value store that holds the 'already seen' ids for monitoring mode. Use a different name per tracked target/query to keep their histories separate.

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

Maximum parallel requests. Lower it if you hit rate limits on very large runs.

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

Proxy settings. Steam's public store endpoints have no hard anti-bot, so the default Apify proxy is plenty; rotating IPs avoids per-IP rate limits on large runs.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "roguelike"
  ],
  "appIds": [
    "730"
  ],
  "collection": "top_sellers",
  "sortBy": "relevance",
  "onlySpecials": false,
  "maxAppsPerQuery": 50,
  "fullDetails": true,
  "includeSteamSpy": true,
  "maxReviewsPerApp": 100,
  "reviewsFilter": "recent",
  "reviewLanguage": "all",
  "reviewType": "all",
  "purchaseType": "all",
  "country": "us",
  "language": "en",
  "monitorMode": false,
  "monitorStoreName": "steam-monitor",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped records in the default dataset. Game rows carry full metadata, prices, derived analytics, publisher leads and optional SteamSpy stats; review rows carry the user feedback.

# 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 = {
    "searchTerms": [
        "roguelike"
    ],
    "appIds": [
        "730"
    ]
};

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

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

```

## MCP server setup

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