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

**Category:** 🎮 Gaming  
**Repository:** https://github.com/Grinv/steam-games-mcp  
**GitHub Stars:** 4  
**npm Downloads (last month):** 3245  
**Views:** 5  
**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 (game/dlc/…) and a clickable store_url. 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 500 appids; if you also need review %, hardware compatibility or tags, use get_items instead (max 100 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 500 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).
- **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 200; check `returned` vs `total` — most games have far fewer). 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). 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. 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 `count` — 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"]
  }
}
```

## Documentation

## What Grinv/steam-games-mcp MCP server does

Grinv/steam-games-mcp MCP server connects an MCP client to Steam’s store and official Steam Web API. Its read-only tools cover catalog lookup, product details, prices, discounts, reviews, review history, news, current player counts, achievements, and hardware compatibility for Steam Deck, SteamOS, Steam Machine, and Steam Frame.

The server also supports account-oriented queries when a Steam Web API key is available. These include player summaries, bans, owned and recently played games, wishlists, followed games, friends, shared ownership, friend ownership, player achievement progress, vanity-name resolution, and personalized recommendations. It does not log users in or perform writes, purchases, trades, posts, or game launches.

## How it works

Start with `search_games` when a tool needs an appid. `get_game` can instead resolve a title to the closest store match, but most other game tools expect the numeric appid. For catalog-wide filtering, `discover_games` can combine discount, release recency, native operating system, review, tag, and compatibility criteria. `get_items` is intended for checking a known list of appids, while `get_prices` handles larger price-only batches.

Store and discovery requests require no API key. Account and detailed achievement requests use the official Steam Web API and require `STEAM_API_KEY`; many also require a public profile or public game details. A configured `STEAM_ID` lets prompts refer to the configured player as “my” account, while individual tools can accept a SteamID64. `resolve_vanity_url` converts a custom profile name to that numeric identifier.

Some responses are deliberately capped. Examples include the first page of title search results, top games by playtime, recent reviews, achievement lists, wishlist results, and friend results. Trend and catalog tools also use bounded scans or recent windows, so a stricter filter may require a larger requested count and may still miss less popular titles.

## Setup and configuration

Install the Grinv/steam-games-mcp MCP server through an MCP client using the package command `npx -y steam-games-mcp`. Store tools can be used with an empty environment configuration. To enable player features, create a free Steam Web API key and set `STEAM_API_KEY`. Set `STEAM_ID` to a 17-digit SteamID64 or a vanity profile name if the client should use a default player.

Optional `STEAM_COUNTRY` and `STEAM_LANGUAGE` values control the store price region and language. The repository also documents a source-based setup that builds with `npm ci && npm run build` and starts the generated Node entry point, but the package-based command is the direct installation path.

For account libraries, achievements, wishlists, and recommendations, the relevant Steam profile and game-details visibility generally must be public. Ban status and some profile information remain available under different visibility rules described by the individual tools.

## Tools and capabilities

- Search titles and retrieve detailed store cards with pricing, genres, platforms, release information, ratings, DLC, requirements, and highlighted achievements.
- Find discounted, recent, well-reviewed, tagged, or hardware-compatible games across the catalog.
- Compare current prices, review percentages, tags, native platforms, VR support, and Steam hardware compatibility for batches of appids.
- Inspect review snapshots, historical review trends, front-page specials, featured sections, patch notes, global achievement rarity, and live concurrent players.
- Query player profiles, bans, libraries, recent play, wishlists, follows, friends, shared games, friend ownership, recommendations, and achievement progress.

The Grinv/steam-games-mcp MCP server returns structured results for these operations through MCP rather than exposing a separate interactive login flow.

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