Steam MCP

A read-only Model Context Protocol server for the

public Steam Web API and storefront — 37 tools, 5 prompts, and 2 resources that let

any MCP client (Claude Desktop, Claude Code, Cursor, …) answer questions about Steam:

your friends, games, playtime, and achievements, plus account-independent things like

sales, reviews, live player counts, Steam Deck compatibility, discovery,

recommendations, and co-op planning.

Read-only · official Steam APIs only · open source. Nobody logs in, and the server

never writes, trades, posts, launches games, or makes purchases.

Quick start — no API key needed

Install `uv`, then:

Claude Code

claude mcp add steam -- uvx steam-mcp

That's the whole setup. 15 of the 37 tools work with no credential at all — anything

about the store or a game itself:

> *"Is Baldur's Gate 3 worth buying, and how are its recent reviews trending?"*

> *"What co-op games are on sale under £20 right now?"*

> *"How many people are playing Helldivers 2 this minute?"*

> *"Will Hades II run properly on my Steam Deck?"*

The three game-finders (`steam_discover`, `steam_should_i_buy`, `steam_recommend`) work

without a key too, as long as you don't personalize them.

Adding your own account

A free Steam Web API key (a minute to get)

unlocks the other 22 — the ones that read a *specific account*: library, playtime,

friends, achievements, wishlist, inventory. Add `STEAM_USER` too and "my"/"I" default to

you, so you never have to paste a SteamID:

claude mcp add steam --env STEAM_API_KEY=YOUR_KEY --env STEAM_USER=your_steam_name -- uvx steam-mcp

> Tip: this defaults to the current project. Add `--scope user` only if you want

> Steam in *every* project — that keeps its tools in context everywhere, so prefer

> per-project scope unless Steam is cross-cutting for you.

Claude Desktop — download `steam-mcp.mcpb` from the

latest release and open it

(Settings → Extensions). Both fields are optional; leave them blank for the keyless

tools and fill them in later.

Cursor / Cline / Windsurf and the manual `pip` setup are under Setup below.

> Without a key, the account tools are still listed but marked

> `[unavailable: needs STEAM_API_KEY]`, so your assistant knows to reach for a keyless

> tool instead of failing at one it can't use.

What it can answer

Account / profile (needs a public profile; set `STEAM_USER` and "my"/"I" default

to you — no SteamID needed):

• "Who's on my friends list, and who's online right now?"
• "Which of my friends own *Helldivers 2* — and who's playing it now?"
• "It's game night — what co-op games do my online friends and I all own?"
• "Analyze my library — my backlog, and what I loved but abandoned."
• "Which achievements am I missing in *Hollow Knight*, and which are my rarest?"
• "What's on my wishlist, and is any of it on sale?"
• "Based on what I play most, what should I check out next?"
• "What's in my CS2 inventory, and which items are marketable?"

Account-independent (works for any game, no SteamID needed):

• "Is *Baldur's Gate 3* worth buying — and how are its recent reviews trending?"
• "What's on sale right now, and what are the current top sellers?"
• "How many people are playing *Counter-Strike 2* this minute?"
• "Will *Hades II* run on my Steam Deck?"
• "What's the Community Market price of a Field-Tested AK-47 | Redline?"
• "Is *Elden Ring* a soulslike? What are its community tags?"
• "Find well-reviewed co-op roguelikes under $20."
• "Recommend games like *Hollow Knight* that I don't already own."

Tools

Every tool supports `response_format: "markdown"` (default) or `"json"`, and all are

annotated `readOnlyHint: true`. Prefer the composite tools (`steam_should_i_buy`,

`steam_recommend`, `steam_discover`, `steam_plan_coop_night`) over chaining several

calls, and ask for `json` only when you need to parse fields. Tools that read

localized text accept a `language` parameter — a Steam language name like `french` or

`schinese` (default `english`).

> \* `steam_discover`, `steam_should_i_buy`, and `steam_recommend` need no key for

> the store data; their personalization (passing a `steamid` to use a user's

> library/taste) requires a key and a public profile.

>

> † `steam_get_inventory` reads a keyless endpoint, but it still has to know *whose*

> inventory — and turning a vanity name (or `STEAM_USER`) into a SteamID64 is itself a

> keyed call. Pass a raw 17-digit SteamID64 and it works with no key.

Prompts & resources

Beyond tools, the server ships prompts (guided one-click flows that orchestrate

the tools) and resources (reference Steam entities by URI):

• Prompts: `what_should_i_play`, `is_it_worth_buying`, `plan_game_night`,

`steam_deals`, `game_overview`.

• Resources: `steam://app/{appid}` (store details) and `steam://user/{steamid}`

(profile + live status).

> Recent reviews: Steam's API only exposes a *lifetime* review summary — there

> is no "last 30 days" field. So `steam_get_app_reviews` with

> `review_filter='recent'` computes that score itself by paginating the newest

> reviews within `day_range` days (default 30). For games with a very high volume

> of recent reviews it counts up to ~600 and marks the result `sampled: true`.

> Market prices: `steam_get_market_price` uses Steam's Community Market

> endpoints, which are undocumented and tightly rate-limited. Results are cached

> briefly; an item with no current listings reports its price as unavailable.

Setup

1. Get a free Steam Web API key *(optional)*

Skip this if you only want the 15 keyless tools — the server runs fine without a

key and the account tools simply advertise themselves as unavailable.

To unlock the account tools, visit , sign in,

register a domain (any domain you control works; `localhost` is commonly used for

personal keys), and copy the key. Usage is governed by the

Steam Web API Terms of Use.

2. Install

The published package needs no checkout (Python 3.10+):

uvx steam-mcp          # zero-install via uv (recommended)
# or
pip install steam-mcp  # run as: python -m steam_mcp.server

Both MCP Python SDK majors work (`mcp>=1.28`). On the v2 SDK the server speaks

spec revision 2026-07-28 — stateless, no `initialize` handshake — advertises

cache hints on its tool/prompt/resource listings, and can ask you which Steam

account is yours when `STEAM_USER` isn't set (once per session, and only if your

client supports elicitation). On the v1.x line it serves the `initialize`

handshake that modern clients fall back to anyway. Nothing to configure either

way.

> TLS note: the HTTP client is `httpx2`, which verifies certificates against

> your operating system's trust store rather than a bundled CA list. If you

> run this somewhere minimal (a slim container with no system CA store, or behind

> a private CA), point `SSL_CERT_FILE` or `SSL_CERT_DIR` at a CA bundle.

3. Add it to your MCP client

Both settings are optional. `STEAM_API_KEY` unlocks the account tools; `STEAM_USER`

(your Steam vanity name, SteamID64, or profile URL) makes those tools default to *you*

whenever you don't name a user, so you never paste a SteamID. It's a public profile

name, not a secret, and you can still pass a `steamid` to any call to override it.

Configure neither and you get the keyless server; configure both and you get everything.

Claude Code

claude mcp add steam --env STEAM_API_KEY=YOUR_KEY --env STEAM_USER=your_steam_name -- uvx steam-mcp

> `STEAM_USER` is optional — drop the second `--env` if you'd rather give a

> SteamID to each call.

Claude Desktop — install `steam-mcp.mcpb` from the

latest release via

Settings → Extensions and paste your key (and, optionally, your Steam name).

Everything else (Claude Desktop config, Cursor, Cline, Windsurf, VS Code, …) —

drop this block into the client's MCP config file:

{
  "mcpServers": {
    "steam": {
      "command": "uvx",
      "args": ["steam-mcp"],
      "env": {
        "STEAM_API_KEY": "YOUR_KEY_HERE",
        "STEAM_USER": "your_steam_name"
      }
    }
  }
}

Config locations: Claude Desktop `claude_desktop_config.json` (`%APPDATA%\Claude\`

on Windows, `~/Library/Application Support/Claude/` on macOS); Cursor

`.cursor/mcp.json`; Cline `cline_mcp_settings.json`. Restart the client and the

Steam tools appear. Running from a source checkout instead? Use

`"command": "python", "args": ["-m", "steam_mcp.server"]`.

Security

Read-only, official-Steam-only, and bring-your-own-key. In short:

• Read-only — never writes, trades, posts, launches games, or buys anything.
• Your key stays yours — read from `STEAM_API_KEY`; never written to disk,

logged, cached, or put in output (and redacted from error messages).

• Official hosts only — the request layer refuses any host that isn't

`api.steampowered.com` / `store.steampowered.com` / `steamcommunity.com` (SSRF

guard), with per-host rate limiting and retry/backoff.

• Typed, validated inputs (`extra="forbid"`); no data kept between requests

beyond a small TTL cache of non-user store data.

Full details and how to report issues are in SECURITY.md.

Versioning & stability

`steam-mcp` follows Semantic Versioning. As of 1.0, the

following are the stable public surface — they won't change without a major

(2.0) release:

• Tool names and their input parameters (names, types, whether required,

defaults)

• JSON output fields (`response_format: "json"`) — names, types, and structure
• Prompt names/arguments and resource URI templates

(`steam://app/{appid}`, `steam://user/{steamid}`)

• Core semantics: read-only, bring-your-own-key, prices in cents / playtime in

minutes, and errors returned as strings

Within a major version, minor releases may *add* tools, prompts, resources,

optional parameters, and JSON fields; patch releases are bug fixes only. The

Markdown output wording, internal implementation, caching behavior, and which

Steam endpoints back a given tool may change at any time and are not part of

the contract.

License

MIT. Not affiliated with Valve. "Steam" is a trademark of Valve Corporation.