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 https://steamcommunity.com/dev/apikey, 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.