Steam MCP Server
Steam MCP Server is a read-only MCP server for exploring Steam store data and public player profiles/libraries via official Steam APIs, with most store/search tools requiring no key.
Search games by title and retrieve appids, prices, Metacritic scores, platforms, and item types.
Get full store details by appid or name: price/discount, genres, platforms, release date, developers/publishers, age rating, DLC, requirements, and achievement highlights.
Batch-check prices, discounts, review percentages, tags, release dates, and Steam Deck/SteamOS/Steam Machine/Steam Frame compatibility for many games.
Discover catalog games by discount, release recency, tags, review quality, native OS, and hardware compatibility.
Read review summaries, helpful or recent reviews, and review trends/histograms over time.
View current Steam specials, featured sections, top sellers, new releases, coming soon, charts, and live concurrent player counts.
Fetch game news and patch notes, global achievement rarity, and full achievement lists.
Access public wishlists and followed-games lists without an API key, including filtered wishlist store cards.
With a free Steam Web API key: resolve vanity URLs, read player profiles and ban status, libraries, recently played games, friends lists, friend ownership checks, library comparisons, player achievement progress, and personalized recommendations.
Use guided prompts for recommendations, buy/wait/skip verdicts, and deal digests.
Runs over stdio with any MCP client and never writes, trades, posts, launches games, or makes purchases.
Provides tools for searching games, retrieving store details, prices, reviews, discounts, news, player profiles, libraries, achievements, and more via the Steam Web API.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Steam MCP Server show me the current top sellers on Steam"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Steam MCP Server
An MCP server for Steam: search games and read store details, prices, reviews, discounts and news (no key), plus player profiles, libraries and achievements via the official Steam Web API (free key).
Read-only · official Steam APIs only · most tools need no key · open source.
Nobody logs in; the only credential is a free Steam Web API key you set yourself, and the server never writes, trades, posts, launches games, or makes purchases.
Works with any MCP client (Claude Desktop/Code, Cursor, VS Code, Cline, …) over stdio.
Once it's connected, just ask your agent in natural language.
No credentials needed (store, search & discovery):
"Find Hollow Knight and tell me its price, genres and age rating."
"What are recent reviews saying about Baldur's Gate 3?"
"Have Cyberpunk 2077's reviews recovered since launch?"
"Which games are >80% off right now with 90%+ positive reviews?"
"Find roguelike deckbuilders on sale."
"What discounted games run natively on macOS?"
"Which recent, well-reviewed games run on Steam Deck?"
"What well-reviewed games run on SteamOS?"
"Any games verified for the Steam Machine on sale?"
"Any Steam Frame-Verified VR games on sale?"
"What's discounted on Steam's front page right now?"
"Show me Steam's top sellers and newest releases."
"Any recent patch notes for No Man's Sky?"
"How rare is each achievement in Elden Ring?"
"How many people are playing Counter-Strike 2 right now?"
"What are the most played games on Steam right now?"
"Get current prices for appids 620, 413150 and 1145360."
"For appids 1245620 and 1086940, show price, review % and Deck / SteamOS / Machine / Frame status."With a free API key + your STEAM_ID (your account; see Getting your credentials):
"Show my Steam profile."
"List my games by playtime."
"What have I played in the last two weeks?"
"Recommend something I'd like based on my library, on a good discount."
"Do I already own Hollow Knight and Hades?"
"What's on my wishlist that's discounted and well-reviewed?"
"List Hollow Knight's achievements and how rare each one is."
"How far am I through Elden Ring's achievements?"
"What's the SteamID64 for the profile name 'gabelogannewell'?"
"Which of my friends own Portal 2, and how many hours have they played?"
"What games do my friend and I both own, and who's played them more?"
"Show me my Steam friends list."
"Is SteamID 76561197960287930 VAC banned?"
"What games am I following that aren't on my wishlist?"Install
Add it to your MCP client's config. Store/search tools work with no credentials; player tools need a free Steam Web API key.
{
"mcpServers": {
"steam": {
"command": "npx",
"args": ["-y", "steam-games-mcp"],
"env": {
"STEAM_API_KEY": "your-steam-web-api-key (optional — enables player tools)",
"STEAM_ID": "your-steamid64-or-vanity-name (optional — default 'you' for player tools)",
"STEAM_COUNTRY": "US (optional — store price region)",
"STEAM_LANGUAGE": "english (optional — store language, Steam's own name, e.g. russian)"
}
}
}
}Replace each value with your own; remove the optional lines you don't need. A free key comes from https://steamcommunity.com/dev/apikey. From source:
npm ci && npm run build, then use"command": "node","args": ["/ABS/PATH/steam-games-mcp/dist/index.js"].
One-click install (Claude Desktop)
Download steam-games-mcp.mcpb
(always the latest release) and open it in Claude Desktop (Settings → Extensions), then
fill the optional fields (API key, Steam ID, country, language) in the install form. No JSON editing.
Also listed in the MCP Registry
as io.github.Grinv/steam-games-mcp.
Related MCP server: steam-mcp
Getting your credentials
Store, search and discovery tools need nothing; skip this section if that's
all you want. The player tools (profile, library, achievements)
need a free API key, and most also need a public profile — though get_wishlist
and get_followed_games need no key, and profile/ban lookups work on private
profiles. Three short steps:
Get a free Steam Web API key. Sign in at https://steamcommunity.com/dev/apikey, enter any domain (e.g.
localhost), and copy the key intoSTEAM_API_KEY.Find your Steam ID. Set
STEAM_IDto either:your vanity name: the custom part of your profile URL
steamcommunity.com/id/YOUR_NAME→YOUR_NAME(resolved automatically), oryour 17-digit SteamID64 (
steamcommunity.com/profiles/7656…; or look it up at https://steamid.io).
With
STEAM_IDset you can just ask "my wishlist / library"; without it, give the agent a SteamID64 each time (useresolve_vanity_urlto convert a name).Make your profile public (for your own library/achievements): Steam → profile → Edit Profile → Privacy Settings → set My profile and Game details to Public.
The key and Steam ID go in your MCP client config (the
envblock above). See docs/clients.md for per-client examples. Never commit them.
Tools
Key: – no credentials · K Steam Web API key.
Tool | Key | Purpose |
| – | Find games by title → appid (with price, Metacritic, type) — up to 100 matches |
| – | Store details by appid or name: price, genres, platforms, Metacritic, age rating, DLC, requirements |
| – | Batch store card (price, review %, Deck/SteamOS/Machine/Frame compat, native platforms, tags) — up to 50 appids |
| – | Find games catalog-wide by discount, recency, Deck/SteamOS/Machine/Frame, platform, tags, rating |
| – | Review summary + the most helpful (any window up to a year) or newest reviews |
| – | Review trend over time (history + recent) |
| – | Batch current price/discount — up to 250 appids |
| – | Steam front-page discounts |
| – | Featured sections (top sellers, new releases, …) |
| – | Recent news, or only the developer's posts / patch notes |
| – | Global achievement unlock rates (rarity) — top 200 |
| – | Live concurrent player count |
| – | What's popular now: weekly top sellers (global or per country, any past week), most played (also on Steam Deck), live concurrent top 100 (ranks + appids) |
| – | A player's wishlist — appids, or full cards + on-sale filter with |
| – | A player's followed games (Steam's "follow" feature, separate from the wishlist) — appids (public profiles) |
| K | Achievement list (names, descriptions) + rarity — first 150, definition order |
| K | Custom profile name → SteamID64 |
| K | Player public profile (incl. Steam level) |
| K | VAC/game/community/economy ban status (works even on private profiles) |
| K | A player's games + playtime (50 by playtime, |
| K | Games played in the last two weeks (top 50 by recent playtime) |
| K | Personalized picks from playtime-weighted tags + review quality, excluding owned games |
| K | A player's achievement progress in a game — achievement list capped at top 200, unlocked first |
| K | A player's friends — name, online state, current game (public friends list) |
| K | Which friends own given appid(s) + their playtime — each friend's FULL library, first 200 friends ( |
| K | Games two players both own, with each one's playtime — checks each player's FULL library, not just top 50 |
Two tiers. Store/search + discovery tools (store/api.steampowered.com)
need no credentials — including catalog-wide discovery (discover_games:
deals, new releases, Deck / SteamOS / Machine / Frame compatibility, tags, rating) and batch
price/review checks (get_items).
Player tools need a free
STEAM_API_KEY and a public profile; they return a clear message when the
key is unset. The two exceptions are get_wishlist and get_followed_games,
marked – above: they work with no key at all. Set STEAM_ID (a SteamID64
or vanity name — a vanity name resolves without a key too) to make those tools
default to you, so "my wishlist / library" works without passing an ID each time.
No third-party services: deal discovery and reviews come from Steam's own (keyless) store APIs. SteamDB is not used (no public API + scraping disallowed). Steam has no price-history API, so that isn't offered. Not affiliated with Valve.
A failed call returns isError with an actionable message for the model; a
client application also gets the failure as an RFC 9457 problem in the result's
_meta — see
docs/errors.md.
Prompts
Guided one-shot prompts that orchestrate several tools for a common question. Use these when your client exposes MCP prompts, instead of describing the steps yourself:
Prompt | Args | What it does |
|
| Recommends catalog games from your library/taste, excluding what you own |
|
| Price, review trend and Steam Deck compatibility → a buy/wait/skip verdict |
|
| A curated list of well-reviewed discounted games |
Develop
npm install
npm run build # type-check + bundle to dist/index.js
npm test # node:test (mocked, offline)
npm run lint
npm run format
npm run check:api # live upstream health-check (key-gated checks need STEAM_API_KEY; a public STEAM_ID verifies player fields)
npm run inspector # run under the MCP InspectorRuntime requires Node ≥ 22.18. Contributor/agent guidance: AGENTS.md. Security policy: SECURITY.md. Per-client config and all tunables: docs/clients.md.
Updating
npx: unpinned
npx -y steam-games-mcpfetches the latest on the next run..mcpbbundle: download the new bundle from the releases page and reinstall.From source:
git pull && npm ci && npm run build.
Privacy Policy
steam-games-mcp runs entirely on your own machine and collects no data of
its own. See PRIVACY.md for exactly what it sends to Steam and
what (if anything) it stores locally.
License
MIT © Grinv
Available Tools
26 toolscompare_playersCompare two players' librariesARead-only
Find games two players both own, with each one's playtime — 'what can my friend and I both play', 'do we have anything in common'. Checks each player's FULL library to find every shared game, unlike get_owned_games whose own list stops at 50 by playtime by default — but the returned list here is itself capped at the top 50 shared games by combined playtime (check returned vs shared_count). Requires STEAM_API_KEY and both profiles' game-details to be public. A private profile, or a SteamID64 with no account behind it, returns found:false; an upstream failure returns a tool error worth retrying. Omit steamid to compare against yourself (STEAM_ID).
Inputs: other_steamid (required), steamid. Returns: object
discover_gamesDiscover gamesARead-only
Find games across the whole Steam catalog (keyless), filtered by ANY combination of: discount (min_discount — for 'what's on sale'), release recency (released_after / released_within_days — for 'new games'), hardware compatibility (steam_deck/steam_os/steam_machine/steam_frame — see each field's own description), native OS build (platform — windows/mac/linux), review quality (min_review / min_reviews), and user tags (tags — e.g. ['Roguelike', 'Deckbuilding'] for 'games like X'). Each result returns price/discount, review %, all four compat statuses, a vr_support flag (none/supported/required), popular tags, a clickable store_url, discount_end (when a deal expires) and release date in one call. Examples: '>80% off with 90%+ reviews' → set min_discount + min_review; 'recent well-reviewed games that run on Steam Deck' → set released_within_days + steam_deck + min_review; 'roguelike deckbuilders on sale' → tags:['Roguelike','Deckbuilding'] + min_discount. Base games only: DLC, soundtracks, demos and tools are filtered out, so a 'find DLC on sale' question returns nothing here — price a known DLC appid with get_items instead. No appids needed — unlike get_items, which prices a list you already have. For 'games like X' from a SINGLE named title, get its tags via get_items and pass them here; for taste inferred from the player's WHOLE library instead, use get_recommended_games (key-gated). Filtering: min_discount, released_after/released_within_days, tags, min_review and ONE of steam_deck/steam_machine/steam_frame are applied by Steam across the whole catalog, so a niche combination still finds its games: the page fetched is Steam's most popular matches (total_matching is Steam's count of them). steam_os, platform, min_reviews and a second hardware filter have no server-side form and are applied afterwards to the count entries fetched, so those can return fewer — raise count for them. min_review only counts games with a Steam rating (10+ reviews). At most 50 results come back per call, best discount first: compare returned against matched to see whether the list was capped, and narrow the filters or page with start for the rest.
Inputs: tags, count, start, country, +11 more. Returns: deals, notes, matched, returned, +1 more
find_friends_who_ownFind friends who own a gameARead-only
Check which of a player's Steam friends own one or more games by appid, with each owner's playtime_hours — 'which of my friends have Portal 2 and how long have they played'. Checks each friend's FULL library, unlike get_owned_games whose own list stops at 50 games by playtime by default — so a friend's rarely-played or unplayed copy is never missed (its playtime_hours may still be low or 0). For the PLAYER'S OWN ownership instead of a friend's, use get_owned_games's check_appids. Requires STEAM_API_KEY and the player's OWN friends list to be public — otherwise the whole call returns found:false, which also covers a SteamID64 with no account behind it; read reason. A friend whose library Steam didn't return (Steam doesn't say why: usually its game details are private) is a different, per-friend case: that friend is listed in not_shown_friends (can't be checked) rather than silently counted as a non-owner. Likewise, a friend whose own library lookup failed (e.g. rate-limited) lands in unavailable_friends with a reason instead of failing the whole call — every other friend's result still comes through. Each of owners, not_shown_friends and unavailable_friends is capped at 100 entries (a sibling _total field appears only when it was actually truncated). On a big account only 200 friends are looked up at all (one Steam call per friend would otherwise run past an MCP client's request timeout), and they are the most-recently-added ones — the same ordering and the same prefix get_friend_list shows, so 'the friends checked' is a set you can actually name — compare friends_checked against total_friends, and treat a friend missing from all three lists as unchecked, not as a non-owner. Get appids from search_games.
Inputs: appids (required), steamid. Returns: object
get_chartsGet Steam chartsARead-only
Get what is popular on Steam right now as a ranked list. chart picks one: top_sellers (weekly best-sellers, with weeks on chart), most_played (top 100 by peak players on the last full day, with the rank a week earlier), most_played_deck (top 100 played on Steam Deck in the past week, with the previous week's rank) or concurrent_players (top 100 by players in game right now, live). Use for 'what's hot / top selling / most played on Steam (Deck)'; for one known game's live count use get_current_players, for the store front page's curated sections (also hardware and bundles) use get_featured, to FILTER the catalog by discount, tags or compat use discover_games. Returns only rank, appid, name, store_url and chart metrics (no price/reviews/Deck status) — pass the appids to get_items for those. last_week_rank null means a new entry; concurrent_players has none. Results are cached for a few minutes. top_sellers is global by default; give country for that country's own best-sellers and week for a past week. The other three are global rankings of the current period only. No API key required.
Inputs: chart (required), week, limit, country. Returns: object
get_current_playersGet current player countARead-only
Get how many people are playing a game right now (live concurrent player count) by appid. Get the appid from search_games. No API key required. Errors clearly if the appid is unknown/invalid rather than returning a null count.
Inputs: appid (required). Returns: appid, notes, player_count
get_featuredGet featured store sectionsARead-only
Get the Steam store's featured sections: specials, top sellers, new releases and coming soon (each a list of games with appid and price), all in one call — for a general 'what's on the store front page' overview. For just current discounts use get_specials (lighter), or discover_games for catalog-wide deals with filters. No API key required.
Inputs: country, language. Returns: notes, specials, coming_soon, top_sellers, +1 more
get_followed_gamesGet a player's followed gamesARead-only
List the games a player 'follows' on the Steam store, by SteamID64 — a lighter opt-in (get sale/update notifications) that's separate from the wishlist; many players follow more games than they wishlist. No API key required, but the follows/profile must be public — otherwise it returns found:false, which is ALSO what a public account following nothing returns: Steam answers the two alike. reason names what narrows it down (a private or missing profile); a public profile's hidden and empty follows can't be told apart. Returns appids + store_url only (no price/name), capped at 200 in whatever order Steam sends them — unlike the ranked lists here there is no ranking, so a game past the cut is not 'less followed' (check returned vs total); pass the appids to get_items for price, review % and compat. Convert a vanity name with resolve_vanity_url first (that conversion itself needs STEAM_API_KEY, even though this tool doesn't).
Inputs: steamid. Returns: object
get_friend_listGet a player's friend listARead-only
List a player's Steam friends by SteamID64: name, online state, current game and how long they've been friends, most-recently-added first (capped at the 100 most-recently-added; check returned vs total). Requires STEAM_API_KEY and the friends list to be public — otherwise it returns found:false, which also covers a SteamID64 with no account behind it; read reason. For 'which of my friends own game X', use find_friends_who_own instead — it checks each friend's full library, not just this list. Get the SteamID64 from resolve_vanity_url.
Inputs: steamid. Returns: object
get_gameGet game detailsARead-only
Get full store details for one game: description, price/discount, genres, platforms, release date, developers/publishers, Metacritic, age rating, DLC (the dlc appid list is capped at 50 — read dlc_total for the real count, and pass the appids to get_items for names and prices), PC requirements and a small highlighted-achievements sample (achievements_highlighted). Identify the game by appid (from search_games) OR by name — a title is resolved to the store item with exactly that title (ignoring case, punctuation, symbols like ™ and accents like é), else to Steam's closest search match, so check the returned name. Both forms error rather than returning an empty result when nothing matches, and an appid can fail for different reasons: it may not exist or have been removed from the store, or it may not be sold in the given country. The error names the country and these causes — retry with another country before concluding the game is gone. No API key required.
Inputs: name, appid, country, language. Returns: dlc, name, type, appid, +29 more
get_game_achievementsGet a game's full achievement listARead-only
List a game's achievements by appid with their names, descriptions, hidden flag and global unlock % (rarity), in the game's own definition order (capped at the first 150; check returned vs total — most games have far fewer). An empty achievements list with total:0 (and game null) means Steam lists no achievements for the app — e.g. a DLC, which has no achievement schema; an appid Steam rejects (normally no such app) is an error (get_game shows whether it exists). Requires STEAM_API_KEY (the achievement schema needs a key). For just the rarity by internal id without a key, use get_global_achievements; for a few named highlights, see get_game's achievements_highlighted; for a specific player's own unlock progress instead of the catalog-wide list, use get_player_achievements. Get the appid from search_games.
Inputs: appid (required), language. Returns: game, notes, total, returned, +1 more
get_game_newsGet game newsARead-only
Get recent news / patch notes for a game by appid (title, date, author, excerpt, link). By default this mixes the developer's announcements with third-party press feeds; set kind='official' for the developer's own posts only, or kind='patch_notes' for update notes only (posts the developer tagged as patch notes — if that comes back empty, try 'official'). Each excerpt is the first ~400 characters of the post with HTML stripped — follow url for the full text. An unknown/unassigned appid comes back as an empty list rather than an error, the same as get_global_achievements. Get the appid from search_games. No API key required.
Inputs: appid (required), kind, limit. Returns: items, notes
get_game_reviewsGet game reviewsARead-only
Get the review summary (score label, positive/negative counts, %) and a few reviews for a game by appid — by default the most helpful ones posted in the last 30 days; set order for the newest or most recently edited instead, or within_days to widen/narrow the helpful window. Review text over 600 characters is truncated. An unknown appid comes back with a null summary and counts and no reviews rather than an error; confirm the appid with get_game if that matters. For long-term trend instead of a snapshot, use get_review_histogram. Get the appid from search_games. No API key required.
Inputs: appid (required), type, limit, order, +2 more. Returns: notes, reviews, summary, positive_pct, +3 more
get_global_achievementsGet global achievement ratesARead-only
Get the global unlock percentage of each achievement in a game by appid — how rare each achievement is across all players. Returns each achievement's internal name and its unlock percent (no display names/descriptions — for those, use get_game_achievements), most-common first, capped at the first 200 (check returned vs count — most games have far fewer). An unknown appid, one with no achievement schema (e.g. a DLC/soundtrack) and a game without achievements all come back as an empty list rather than an error (Steam answers the three alike), the same as get_game_news. Get the appid from search_games. No API key required.
Inputs: appid (required). Returns: count, notes, returned, achievements
get_itemsBatch store card for many gamesARead-only
Get price/discount, review % (positive), hardware compatibility, popular user tags and release date for a LIST of games by appid in ONE keyless call. The efficient way to price-, rating-, tag- and compat-check a wishlist or library without a request per game. For a bigger batch (up to 250 appids) when you only need price, use get_prices instead. An unknown/invalid appid, or one not sold in that country, comes back as its own row marked available:false — rows stay in the order you passed them, one per id, never dropped; available:null (explained in notes, as in get_prices) means Steam's answer didn't settle that row. Each item carries four compatibility fields, each verified/playable/unsupported/unknown: steam_deck (Steam Deck), steam_os (SteamOS in general), steam_machine (the Steam Machine console specifically), and steam_frame (Steam Frame VR headset); a vr_support flag (none/supported/required — distinct from steam_frame, which is a Steam Frame HARDWARE compat rating, not whether the game itself has a VR mode); a tags list (top user tags like 'Roguelike', 'Souls-like', most-relevant first); a clickable store_url to the game's Steam page; and, when on sale, discount_end (ISO UTC time the discount expires — for 'how long is this deal valid'). To find NEW games by filter (discount, rating, tags, compat) instead of pricing a list you already have, use discover_games instead. Get appids from search_games / get_wishlist / get_owned_games.
Inputs: appids (required), country, language. Returns: count, items, notes
get_owned_gamesGet owned gamesARead-only
List the games a player owns with playtime (hours), ordered by playtime — most-played first by default, least-played first with sort='playtime_asc' (the games list is capped to 50 entries by default, so the far end of that ordering may not appear there; raise limit to widen the cap, or flip sort to keep the never-played end instead, which is what a 'what have I never got round to playing' question needs). To reliably check whether the player owns one or more SPECIFIC appids regardless of that cap — 'do I own game X' — pass check_appids; the owns field then checks the FULL, uncapped library, with each result's own playtime_hours (null if not owned). For the last two weeks of play instead of the all-time library, use get_recently_played. For checking a FRIEND's ownership instead of the player's own, use find_friends_who_own. Requires STEAM_API_KEY and a public profile + game-details visibility; a private profile, or a SteamID64 with no account behind it, returns found:false. Get the SteamID64 from resolve_vanity_url.
Inputs: sort, limit, steamid, check_appids. Returns: object
get_player_achievementsGet a player's achievementsARead-only
Get a player's achievement progress for one game (unlocked count, % complete, per-achievement unlock dates) by SteamID64 + appid — unlocked/completion_pct always reflect the full list, but the per-achievement achievements array is capped at 200, unlocked first (check returned vs total — most games have far fewer). For the game's full achievement list (names, descriptions, global rarity) independent of any player, use get_game_achievements instead; for just the rarity without a key, use get_global_achievements. Requires STEAM_API_KEY and a public profile with game-details visibility — otherwise it returns found:false — which is also what a game the player doesn't own, a SteamID64 with no account behind it, or no such appid at all returns; a game without achievements comes back as found:false or as found:true with total:0, as Steam answers it. Steam doesn't tell most of these apart, so reason says what it didn't return and which tools establish why (get_player_summary, get_owned_games' check_appids, get_game).
Inputs: appid (required), steamid, language. Returns: object
get_player_bansGet a player's ban statusARead-only
Check a player's VAC, game, community and economy (trade) ban status by SteamID64 — 'is this player banned', useful before trading or adding a friend. Ban status is always public — this works even when the rest of the profile is private. days_since_last_ban is null for a player who has never been banned — Steam sends 0 there, which would otherwise read as 'banned today'. Requires STEAM_API_KEY.
Inputs: steamid. Returns: object
get_player_summaryGet player profileARead-only
Get a player's profile by SteamID64: display name, online state, country, account age, Steam level (a separate lookup that degrades to null on failure, independently of profile privacy), and the game they're currently in. found:false here means exactly one thing — no account with that SteamID64 — since this tool reads private profiles fine. Requires STEAM_API_KEY, but works even for a private profile (visibility reports 'private') — country, account age and the current game only populate when the profile is public. For VAC/game/trade ban status instead, use get_player_bans.
Inputs: steamid. Returns: object
get_pricesGet prices for many gamesARead-only
Get current price and discount for a batch of games by appid in one call — efficient for checking a whole list (e.g. a wishlist) for deals. Handles up to 250 appids; if you also need review %, hardware compatibility or tags, use get_items instead (max 50 appids). Rows come back in the same order as the given appids, one per id, never dropped: available:false when there's no such appid or it isn't sold in that country, available:null when Steam failed to answer for it (see notes; retry). A priced row carries final/initial price and discount_percent. A row marked priced:false has no price block at all, which is how BOTH free-to-play and not-yet-released titles come back: this endpoint cannot tell them apart, so never report priced:false as 'free' — pass those appids to get_items, whose is_free/coming_soon do separate them. No API key required. Get appids from search_games or get_wishlist.
Inputs: appids (required), country. Returns: count, notes, prices
get_recently_playedGet recently played gamesARead-only
List the games a player has played in the last two weeks, with recent and total playtime, most-played-in-those-two-weeks first (capped at 50; check returned vs total) — the ordering is what decides which games the cap keeps, and it is playtime, not recency. For the all-time library by playtime instead (capped at 50 entries by default, either end of that ordering via sort), use get_owned_games. Requires STEAM_API_KEY and a public profile with game-details visibility (same requirement as get_owned_games). found:false means Steam returned no list, which it does for a hidden profile, a SteamID64 with no account, and some public profiles too, without saying why; reason names what narrows it down; for a public profile, nothing does.
Inputs: steamid. Returns: object
get_recommended_gamesGet personalized game recommendationsARead-only
Recommend unowned Steam catalog games personalized to this player: tags on their own most-played owned games become weighted preferences (more playtime on a tag = more weight), discounted by each candidate's review score so a tag match on a poorly-received game doesn't outrank a better one, then ranked against a broad catalog page, excluding anything already owned. based_on_tags shows which of the player's own top tags drove the ranking; each result carries matched_tags and match_score alongside the usual price/review/compat card. Set exclude_tags to steer away from a genre despite it matching by playtime, and/or min_discount for a minimum deal size (e.g. 'suggest games on sale, not RPGs or shooters' → exclude_tags:['RPG','Shooter','FPS'], min_discount:30). Different from discover_games (which needs YOU to name the filters) — this infers taste from the player's WHOLE library instead, for 'what should I play next' / 'recommend me something'. For 'something like THIS ONE game' (a single named title), get its tags via get_items and call discover_games with them instead. Recommends base games only — DLC, soundtracks and demos are never suggested, the same filter discover_games applies. Note: taste is weighted from only the player's 30 most-played owned games, and candidates come from a fixed 300-entry catalog scan, so a heavy exclude_tags/min_discount combination can return fewer than limit — there's no larger scan to fall back to; a candidate without a review score (no reviews yet) is left out too. Requires STEAM_API_KEY and a public profile with game-details visible (same requirement as get_owned_games) — found:false is also returned for a SteamID64 with no account behind it, if the player owns no games at all, or if too few of their played games have resolvable tags to build a taste profile.
Inputs: limit, steamid, exclude_tags, min_discount. Returns: object
get_review_histogramGet review trend over timeARead-only
Get how a game's reviews trend over time by appid: a long-term history (rollup_type reports each entry's granularity, e.g. 'week' or 'month', chosen server-side by Steam; capped at the most recent 24 entries) and the recent per-day breakdown (capped at the most recent 30 days), each with positive/negative counts and positive %. Good for 'are reviews improving / did an update hurt reception'. An unknown appid comes back as empty history/recent arrays rather than an error — Steam answers success for any id — so an empty result means either no such appid or a game nobody has reviewed yet; confirm the appid with get_game if that distinction matters. For a current summary and example review text instead of a trend, use get_game_reviews. Get the appid from search_games. No API key required.
Inputs: appid (required). Returns: notes, recent, history, rollup_type
get_specialsGet current discountsARead-only
List games currently on special (discounted) on the Steam store front page, with the discount % and original/final price. For ALL catalog discounts (not just the front page), use discover_games with min_discount. No API key required.
Inputs: country, language. Returns: notes, specials
get_wishlistGet a player's wishlistARead-only
List a player's Steam wishlist by SteamID64. No API key required, but the wishlist/profile must be public — otherwise it returns found:false, which is ALSO what an empty but public wishlist returns: Steam answers the two alike. reason names what narrows it down (a private or missing profile); a public profile's hidden and empty wishlist can't be told apart. By default returns a light list of appids (sorted by priority, no names), capped at the first 100 (check returned vs total). Set include_details for full store cards in ONE call (name, price/discount, review %, Deck/SteamOS/Machine/Frame compat, vr_support, tags, release) — no need to follow up with get_items. Narrow it in the SAME call with tags (e.g. ['Metroidvania']), platform (NATIVE windows/mac/linux build), steam_deck/steam_os/steam_machine/steam_frame (Proton compatibility — see each field), min_review, min_discount / on_sale_only, or country / language. Any of these filters switches to the detailed card view, since the light appid list has no price/tags/compat to filter on. Filters apply before the output cap (the detailed card list returns at most 50 items), so a deeply-discounted niche match past the display cap is never hidden by it (e.g. 'top metroidvanias on my wishlist with a good discount and reviews' → tags:['Metroidvania'] + min_discount + min_review). Results ranked by discount when a discount filter is set, else by wishlist priority; matched reports the pre-cap count. tags, steam_deck, mac/linux and the discount floor are applied by Steam over the whole wishlist; min_review, the exact own-package discount and the other compat/platform filters are checked by this server over up to 1000 matching entries, and note says when a bigger match set left some unchecked, and names entries Steam doesn't show in country (removed, or not sold there) or gave no usable card. Convert a vanity name with resolve_vanity_url first (that conversion itself needs STEAM_API_KEY, even though this tool doesn't).
Inputs: tags, country, steamid, language, +9 more. Returns: object
resolve_vanity_urlResolve vanity URL to SteamIDARead-only
Convert a Steam custom (vanity) profile name — the part after /id/ in a profile URL — into the 17-digit SteamID64 that the player tools need. Requires STEAM_API_KEY. Returns found:false if the name doesn't resolve to a profile.
Inputs: vanity (required). Returns: object
search_gamesSearch gamesARead-only
Search the Steam store by title — term can be partial or approximate, not an exact match; returns matches with their appid (needed by the other game tools), the game's own price, Metacritic score, platforms, type (game, dlc, music for a soundtrack, demo, …) and a clickable store_url, in Steam's relevance order. total is Steam's full match count; limit returns up to 100 of them (there is no paging past that, so refine the term if the game you want isn't listed). Prices are Steam's formatted strings with the currency symbol (no separate currency code); null for free-to-play or unpriced games. Returns games only by default; set games_only=false to include DLC, soundtracks, demos and other store items. For review %, Steam Deck status or tags, pass the appids to get_items. No API key required.
Inputs: term (required), limit, country, language, +1 more. Returns: notes, total, results, returned
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 26 tools
Despite several family clusters (three achievement tools, three batch-price tools, multiple discovery/deals tools), every description explicitly states when to use a sibling instead (e.g. get_global_achievements vs get_game_achievements vs get_player_achievements; get_prices vs get_items vs discover_games). Resource+action boundaries are crisp and reinforced with concrete examples, so an agent can select correctly without guesswork.
Names follow a predictable verb_noun snake_case pattern throughout (get_game, get_wishlist, get_review_histogram, resolve_vanity_url, find_friends_who_own, compare_players, discover_games). No camelCase mixing or stray vague verbs; prefixes (get_/search_/find_/discover_/compare_) consistently signal read vs lookup vs analysis.
26 tools exceeds the comfortable 3-15 band and feels heavy, but the surface genuinely spans distinct sub-domains (store catalog, deals/discovery, reviews/news, achievements, player library, social/friends). Each tool covers a real operation rather than padding, so the count is defensible but on the bloated side.
Covers the full lifecycle for its domain: store search/details/pricing/deals/discovery/charts, reviews with both snapshot and trend, news, three levels of achievement data, and a deep player surface (profile, owned, recent, wishlist, follows, friends, ownership intersection, recommendations, bans, vanity resolution). Keyless vs key-gated variants are both provided, and DLC/bundle pricing is reachable via get_items, leaving no obvious dead ends.
Maintenance
Related MCP Connectors
Steam profiles, SteamID conversion, bans, FACEIT stats, friends and comparisons. Free, no API key.
Read-only Steam wishlist, sales and refund data for game developers, from Steamworks.
Live Steam Market API docs, schemas, products, games, markets and endpoint search.
Live Steam market data for AI agents: top sellers, deals, player counts. Paid per call via x402.
Related MCP Servers
- AlicenseBqualityDmaintenanceProvides tools for interacting with the Steam Web API to access player profiles, game libraries, achievements, statistics, inventories, and game information through natural language.345MIT
- AlicenseAqualityCmaintenanceExposes Steam Web API tools as MCP resources for Claude Code, Claude Desktop, and Gemini CLI, enabling profile lookups, game searches, achievement tracking, and more.1124 npm1MIT
- AlicenseAqualityDmaintenanceIntegrates with Steam Web API to enable querying user profiles, game libraries, store data, and community features like reviews and workshop items.16MIT
- AlicenseNot gradedqualityCmaintenanceProvides Steam Web API integration for querying owned games, player achievements, app news, and store details. Part of the Pipeworx MCP gateway enabling natural language queries to Steam data.315 npmMIT