# Grinv/steam-games-mcp [Health: Active]

**Category:** 🎮 Gaming  
**Repository:** https://github.com/Grinv/steam-games-mcp  
**GitHub Stars:** 5  
**npm Downloads (last month):** 1324  
**Views:** 6  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/grinv-steam-games-mcp

## Description
Search Steam's store/catalog (deals, reviews, Steam Deck/SteamOS/Machine/Frame compatibility) with no API key, plus player profiles, libraries, achievements and friends via the official Steam Web API (free key).

## Tools
Capabilities this server exposes over MCP:

- **search_games** — 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), price, Metacritic score, platforms, type and a clickable store_url. Note `type` is Steam's storesearch value, which is 'app' for every store item — it does NOT distinguish a game from its DLC or soundtrack; call get_game on the appid for the real type (game/dlc/music/…). Returns only Steam's own first page of matches (~10, no pagination) — refine the term if the game you want isn't listed. No API key required.
- **get_game** — Get full store details for one game: description, price/discount, genres, platforms, release date, developers/publishers, Metacritic, age rating, DLC, 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 closest store match. No API key required.
- **get_game_reviews** — Get the review summary (score label, positive/negative counts, %) and a few recent reviews for a game by appid. Review text over 600 characters is truncated. For long-term trend instead of a snapshot, use get_review_histogram. Get the appid from search_games. No API key required.
- **get_review_histogram** — 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'. 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.
- **get_prices** — 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 (unavailable ones marked available:false, never dropped). Each row has the final/initial price and discount_percent (or is_free). No API key required. Get appids from search_games or get_wishlist.
- **get_specials** — 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.
- **get_featured** — 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.
- **get_game_news** — Get recent news / patch notes for a game by appid (title, date, author, excerpt, link). 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.
- **get_global_achievements** — 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, or one with no achievement schema (e.g. a DLC/soundtrack), comes back as an empty list rather than an error, the same as get_game_news. Get the appid from search_games. No API key required.
- **get_items** — 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 comes back as its own row marked available:false (never dropped from the list), same as get_prices. 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.
- **discover_games** — 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. 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). Note: min_discount is filtered server-side and re-checked client-side (so it holds at any value); setting released_after/released_within_days excludes not-yet-released games server-side, but the exact date cutoff — plus compat, platform, review and tag filtering — has no server-side support in the Steam catalog API, so those are scanned popularity-first and applied afterward over that same window — great for popular titles; a niche match may fall outside the top `count` (raise count for stricter filters). At most 60 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.
- **get_current_players** — 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.
- **get_followed_games** — 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. Returns appids + store_url only (no price/name), capped at the first 200 (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).
- **get_wishlist** — List a player's Steam wishlist by SteamID64. No API key required, but the wishlist/profile must be public — otherwise it returns found:false. 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 60 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. Steam itself only attaches store data to roughly the first 100 wishlist entries per call — on a bigger wishlist, `enriched` reports how many of `total` got checked, and `note` explains when some were skipped (their filter/price data isn't available at all, not that they don't match). Convert a vanity name with resolve_vanity_url first (that conversion itself needs STEAM_API_KEY, even though this tool doesn't).
- **get_game_achievements** — 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 means this appid has no achievement schema at all — a DLC, soundtrack, tool or demo, or an appid that doesn't exist; the two are not reported separately here, so use get_game to confirm the appid is a real base game. 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.
- **resolve_vanity_url** — 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.
- **get_friend_list** — 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. 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.
- **find_friends_who_own** — 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 which caps its own list at the top 50 games by playtime — 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. A friend's individually private library is a different, per-friend case: that friend is listed in private_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, private_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 the first 200 friends are looked up at all (one Steam call per friend would otherwise run past an MCP client's request timeout) — 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.
- **compare_players** — 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 which caps its own list at the top 50 by playtime — 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 — otherwise it returns found:false. Omit steamid to compare against yourself (STEAM_ID).
- **get_player_summary** — Get a player's profile by SteamID64: display name, online state, country, account age, Steam level, and the game they're currently in. 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.
- **get_player_bans** — 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. Requires STEAM_API_KEY.
- **get_owned_games** — List the games a player owns with playtime (hours), most-played first (the `games` list is capped to the top 50 by playtime — a lightly-played or unplayed game may not appear there). 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. Get the SteamID64 from resolve_vanity_url.
- **get_recently_played** — 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 all-time top games by playtime instead (capped to the top 50), use get_owned_games. Requires STEAM_API_KEY and a public profile with game-details visibility (same requirement as get_owned_games) — otherwise it returns found:false.
- **get_recommended_games** — 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. 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. Requires STEAM_API_KEY and a public profile with game-details visible (same requirement as get_owned_games) — found:false is also returned if the player owns no games at all, or if too few of their played games have resolvable tags to build a taste profile.
- **get_player_achievements** — 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 (also returned if the game has no achievements at all).

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "steam-games-mcp": {
    "command": "npx",
    "args": ["-y","steam-games-mcp"],
    "env": {
      "STEAM_API_KEY": "",
      "STEAM_ID": "",
      "STEAM_COUNTRY": "",
      "STEAM_LANGUAGE": ""
    }
  }
}
```

**Requires environment variables:** `STEAM_API_KEY`, `STEAM_ID`, `STEAM_COUNTRY`, `STEAM_LANGUAGE` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What Grinv/steam-games-mcp does

Grinv/steam-games-mcp exposes Steam store and player-account operations as MCP tools for clients such as Claude Desktop, Claude Code, Cursor, VS Code, and Cline. Store and catalog features work without credentials, including title search, full store details, current prices, discounts, reviews, review trends, news, featured sections, hardware compatibility, tags, release filters, achievement rarity, and live concurrent player counts.

Player features use Steam Web API data. They cover profiles, bans, owned and recently played games, wishlists, followed games, friends, shared ownership, personalized recommendations, and player achievement progress. The server does not log users in or perform write actions such as trading, posting, launching games, or purchasing.

## How it works

Connect the server to an MCP client over stdio, then ask the client to call the relevant tool. Most game-oriented workflows begin with `search_games`, which returns Steam appids for follow-up calls. `get_game` can also resolve a title to its closest store match. Batch tools such as `get_prices` and `get_items` reduce the number of requests when checking a list of games, while `discover_games` searches the broader catalog using discount, release, review, platform, compatibility, and tag filters.

Player tools accept SteamID64 values. A configured `STEAM_ID` can represent the default player, and `resolve_vanity_url` converts a custom Steam profile name to SteamID64. Public profile and game-detail visibility are required for many library, friend, and achievement operations; profile and ban lookups have broader visibility coverage.

## Setup and configuration

For an MCP client using the npm package, configure a stdio entry that runs `npx -y steam-games-mcp`. The source-build alternative runs the generated `dist/index.js` with Node after installing dependencies and building the project.

Set `STEAM_API_KEY` to a free Steam Web API key to enable key-gated player tools. Set `STEAM_ID` to a SteamID64 or vanity name when you want commands about a default account. `STEAM_COUNTRY` selects the store price region, and `STEAM_LANGUAGE` selects the store language. Store search and discovery can run without these values. Claude Desktop also supports installation through the published `.mcpb` package and an install form for the optional settings.

## Tools and capabilities

- Search titles and retrieve store descriptions, pricing, genres, platforms, release data, requirements, publishers, developers, ratings, DLC, and highlighted achievements.
- Find catalog-wide deals and new releases using discount, review, tag, native-platform, and Steam Deck, SteamOS, Steam Machine, or Steam Frame compatibility filters.
- Compare current reviews with historical review movement, inspect recent news, view featured store sections, and check live player counts.
- Batch-check prices or richer item cards for lists such as wishlists and libraries, including discounts, review percentages, tags, compatibility, VR support, and discount expiration.
- Read public player profiles, libraries, wishlists, follows, friends, bans, achievements, recommendations, and shared games.

## Limitations and notes

Results have tool-specific caps. Examples include 250 appids for `get_prices`, 50 for `get_items`, 60 catalog results from `discover_games`, 100 wishlist entries in the default list, and 50 games in several library views. Response fields such as `returned`, `matched`, or `total` indicate when a result set was capped. Catalog filters beyond discount and release-window selection may be applied after a popularity-first scan, so increasing the requested count can help surface narrower matches.

Steam privacy settings affect account data. Private libraries, game details, wishlists, or friends lists can produce `found:false`, while some calls return partial results for inaccessible friends. Achievement data also differs by tool: global rarity is available without a key, whereas full achievement definitions and player progress require the Steam Web API key.

_Full upstream README: https://allmcps.com/mcp/grinv-steam-games-mcp/readme_