# Steam MCP Server (npm · steam-games-mcp)

Steam store/game data (no key) plus player profiles, libraries and achievements (Steam Web API).

- Trust score: 80/100 (high trust)
- Change this week: +39
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- mcpb · `steam-games-mcp.mcpb`: 47/100, [markdown](https://verifymcp.io/servers/grinv-steam-games-mcp/https-github-com-grinv-steam-games-mcp-releases-download-v0-12-2-steam-games-mcp.md), [page](https://verifymcp.io/servers/grinv-steam-games-mcp/https-github-com-grinv-steam-games-mcp-releases-download-v0-12-2-steam-games-mcp)
- npm · `steam-games-mcp`: 80/100 (this document), [markdown](https://verifymcp.io/servers/grinv-steam-games-mcp/steam-games-mcp.md), [page](https://verifymcp.io/servers/grinv-steam-games-mcp/steam-games-mcp)

## Channel facts

- Registry: `npm`
- Package: `steam-games-mcp`
- Version: `0.12.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 88/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 3 of 3 dependencies flagged as unhealthy (3 deprecated).
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to Grinv/steam-games-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 2 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 77/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 6473 tokens (~258/item across 25 items; 25 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### Claude

```bash
claude mcp add grinv-steam-games-mcp -- npx -y steam-games-mcp
```

### Codex

```bash
codex mcp add grinv-steam-games-mcp -- npx -y steam-games-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "grinv-steam-games-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "steam-games-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add grinv-steam-games-mcp --command npx --arg -y --arg steam-games-mcp
```

### Hermes

```yaml
mcp_servers:
  grinv-steam-games-mcp:
    command: "npx"
    args: ["-y", "steam-games-mcp"]
```

### Other

```json
{
  "mcpServers": {
    "grinv-steam-games-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "steam-games-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 80, −3)

- [functional regression] Dependency health: 1.00 → 0.00

### 2026-08-02 (score 83, +22)

- [security improvement] Malware scan: unverified → pass
- [functional improvement] Schema quality: unverified → excellent

### 2026-08-01 (score 61, +27)

- [functional regression] Schema quality: excellent → unverified
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Stability: unverified → 0.20
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] MCP protocol: unverified → pass

### 2026-07-31 (score 34, −7)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 41, 0)

- [functional] Package version: 0.10.5 → 0.12.1

### 2026-07-29 (score 41, −34)

- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional] Package version: 0.10.5 → 0.11.0

### 2026-07-28 (score 75, +34)

- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Schema quality: unverified → 100

### 2026-07-27 (score 41, −35)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

## MCP tools (25)

### `search_games` (~155 tokens)

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.

Input parameters:

- `country` (string): Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
- `language` (string): Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.
- `term` (string, required): Game title to search for.

Output parameters:

- `results` (array)
- `total` (number)

### `get_game` (~196 tokens)

Get game details

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.

Input parameters:

- `appid` (integer): Steam appid (from search_games). Provide appid OR name.
- `country` (string): Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
- `language` (string): Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.
- `name` (string): Game title to look up instead of an appid — resolved to the closest store match. Provide appid OR name; appid wins if both are given.

Output parameters:

- `account_notice`
- `achievements_highlighted` (array): A small keyless sample of named achievements Steam highlights for this game, not the full list — for every achievement with rarity and a hidden flag, use get_game_achievements instead.
- `achievements_total`
- `appid` (number)
- `base_game`
- `categories` (array)
- `coming_soon` (boolean)
- `content_descriptors` (object)
- `controller_support`
- `demos` (array)
- `developers` (array)
- `dlc` (array)
- `drm_notice`
- `genres` (array)
- `header_image`
- `is_free` (boolean)
- `metacritic`
- `metacritic_url`
- `name` (string)
- `pc_requirements_min`
- `platforms` (array)
- `price`
- `publishers` (array)
- `recommendations`
- `release_date`
- `required_age`
- `short_description`
- `store_url`
- `supported_languages`
- `type`
- `website`

### `get_game_reviews` (~182 tokens)

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.

Input parameters:

- `appid` (integer, required): Steam application id (appid). Get it from search_games.
- `limit` (integer): How many recent reviews (1-20). Default 5.
- `review_language` (string): Filter reviews by language, e.g. 'english'. Default 'all'.
- `type` (string): Only positive or negative reviews. Default 'all'. Steam only computes the summary (score label, totals, %) for 'all' — filtering to positive/negative nulls those fields out, leaving only the review e…

Output parameters:

- `positive_pct`
- `reviews` (array)
- `summary`
- `total_negative`
- `total_positive`
- `total_reviews`

### `get_review_histogram` (~151 tokens)

Get review trend over time

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.

Input parameters:

- `appid` (integer, required): Steam application id (appid). Get it from search_games.

Output parameters:

- `history` (array)
- `recent` (array)
- `rollup_type`: Granularity of each `history` entry's date bucket, e.g. 'week' or 'month' — chosen server-side by Steam and passed through as a free-form string (not validated or enumerated here), so don't assume a…

### `get_prices` (~171 tokens)

Get prices for many games

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.

Input parameters:

- `appids` (array, required): Steam appids to price (1-500).
- `country` (string): Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.

Output parameters:

- `count` (number)
- `prices` (array)

### `get_specials` (~106 tokens)

Get current discounts

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.

Input parameters:

- `country` (string): Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
- `language` (string): Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.

Output parameters:

- `specials` (array)

### `get_featured` (~132 tokens)

Get featured store sections

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.

Input parameters:

- `country` (string): Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
- `language` (string): Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.

Output parameters:

- `coming_soon` (array)
- `new_releases` (array)
- `specials` (array)
- `top_sellers` (array)

### `get_game_news` (~109 tokens)

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.

Input parameters:

- `appid` (integer, required): Steam application id (appid). Get it from search_games.
- `limit` (integer): How many news items (1-20). Default 5.

Output parameters:

- `items` (array)

### `get_global_achievements` (~159 tokens)

Get global achievement rates

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.

Input parameters:

- `appid` (integer, required): Steam application id (appid). Get it from search_games.

Output parameters:

- `achievements` (array)
- `count` (number)
- `returned` (number)

### `get_items` (~373 tokens)

Batch store card for many games

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.

Input parameters:

- `appids` (array, required): Steam appids (1-100).
- `country` (string): Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
- `language` (string): Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.

Output parameters:

- `count` (number)
- `items` (array)

### `discover_games` (~983 tokens)

Discover games (deals, new releases, Steam Deck, rating)

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).

Input parameters:

- `count` (integer): How many catalog entries to scan (1-200). Default 50. Raise for stricter filters.
- `country` (string): Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
- `language` (string): Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.
- `min_discount` (integer): Minimum discount %, e.g. 80 for '80%+ off' — this is the 'deals' filter. Omit to include full-price games.
- `min_review` (integer): Minimum positive-review %, e.g. 85. Applied over the returned page.
- `min_reviews` (integer): Minimum review count (filters out games with too few reviews).
- `platform` (string): NATIVE-build filter: keep only games shipping a native build for this OS (windows/mac/linux). 'linux' = a native Linux/SteamOS port. This is NOT Proton — for games that run via Proton compatibility u…
- `released_after` (string): Keep only games released on/after this date (YYYY-MM-DD).
- `released_within_days` (integer): Alternative to released_after: released within the last N days.
- `start` (integer): Pagination offset into the catalog (default 0).
- `steam_deck` (string): Steam Deck compatibility (runs via Proton): 'verified' = Deck-Verified only; 'playable' = Playable or Verified. Not a native Linux build — see `platform` for that.
- `steam_frame` (string): Steam Frame (VR headset) compatibility: 'verified' = Frame-Verified only; 'playable' = Playable or Verified.
- `steam_machine` (string): Steam Machine (Valve's console) compatibility (via Proton): 'verified' = Steam-Machine-Verified only; 'playable' = Playable or Verified. Its own rating, distinct from the general steam_os one.
- `steam_os` (string): SteamOS compatibility — how well it runs on SteamOS in general (via Proton): 'verified' = SteamOS-Verified only; 'playable' = Playable or Verified. For a NATIVE Linux build instead, use platform:'lin…
- `tags` (array): Keep only games carrying ALL of these user tags (case-insensitive), e.g. ['Roguelike','Deckbuilding']. Use exact Steam tag names — a misspelled/unrecognized one isn't an error, it just matches nothin…

Output parameters:

- `deals` (array)
- `returned` (number): How many results survived every filter, out of the scanned window (see `count`).
- `total_matching`: Count from whichever filters Steam actually applies server-side — min_discount, and (if released_after/released_within_days was set) excluding not-yet-released games — or the whole catalog's size if…

### `get_current_players` (~78 tokens)

Get current player count

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.

Input parameters:

- `appid` (integer, required): Steam application id (appid). Get it from search_games.

Output parameters:

- `appid` (number)
- `player_count`

### `get_followed_games` (~182 tokens)

Get a player's 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).

Input parameters:

- `steamid` (string): 17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

### `get_wishlist` (~931 tokens)

Get a player's 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).

Input parameters:

- `country` (string): Country (cc) for prices; overrides STEAM_COUNTRY. Implies include_details.
- `include_details` (boolean): Return full store cards (name, price, discount, reviews, compatibility, tags) per item in one call, instead of just appids. Implied by any filter below.
- `language` (string): Store language; overrides STEAM_LANGUAGE. Implies include_details.
- `min_discount` (integer): Keep only items discounted at least this %, ranked by discount. Implies include_details.
- `min_review` (integer): Keep only items with at least this positive-review %. Implies include_details.
- `on_sale_only` (boolean): Only wishlist items currently discounted, ranked by discount %. Implies include_details.
- `platform` (string): NATIVE-build filter: keep only games shipping a native build for this OS (windows/mac/linux). 'linux' = a native Linux/SteamOS port. This is NOT Proton — for games that run via Proton compatibility u…
- `steam_deck` (string): Steam Deck compatibility (runs via Proton): 'verified' = Deck-Verified only; 'playable' = Playable or Verified. Not a native Linux build — see `platform` for that.
- `steam_frame` (string): Steam Frame (VR headset) compatibility: 'verified' = Frame-Verified only; 'playable' = Playable or Verified.
- `steam_machine` (string): Steam Machine (Valve's console) compatibility (via Proton): 'verified' = Steam-Machine-Verified only; 'playable' = Playable or Verified. Its own rating, distinct from the general steam_os one.
- `steam_os` (string): SteamOS compatibility — how well it runs on SteamOS in general (via Proton): 'verified' = SteamOS-Verified only; 'playable' = Playable or Verified. For a NATIVE Linux build instead, use platform:'lin…
- `steamid` (string): 17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.
- `tags` (array): Keep only wishlist items carrying ALL of these user tags (case-insensitive), e.g. ['Metroidvania']. Use exact Steam tag names — a misspelled/unrecognized one isn't an error, it just matches nothing.…

### `get_game_achievements` (~176 tokens)

Get a game's full achievement list

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.

Input parameters:

- `appid` (integer, required): Steam application id (appid). Get it from search_games.
- `language` (string): Language for achievement names/descriptions; overrides STEAM_LANGUAGE.

Output parameters:

- `achievements` (array)
- `game`: The game's name from Valve's achievement schema — occasionally an internal dev codename rather than the store title (e.g. 'Fiber' for Persona 5 Royal). Treat the appid you passed as the reliable iden…
- `returned` (number)
- `total` (number)

### `resolve_vanity_url` (~94 tokens)

Resolve vanity URL to SteamID

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.

Input parameters:

- `vanity` (string, required): Vanity name, e.g. 'gabelogannewell' from steamcommunity.com/id/gabelogannewell.

### `get_friend_list` (~162 tokens)

Get a player's 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.

Input parameters:

- `steamid` (string): 17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

### `find_friends_who_own` (~317 tokens)

Find friends who own a game

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.

Input parameters:

- `appids` (array, required): Steam appids to check (1-10).
- `steamid` (string): 17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

### `compare_players` (~206 tokens)

Compare two players' libraries

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).

Input parameters:

- `other_steamid` (string, required): The other player's 17-digit SteamID64 to compare against. Convert a vanity/custom profile name with resolve_vanity_url first.
- `steamid` (string): 17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

### `get_player_summary` (~130 tokens)

Get player profile

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.

Input parameters:

- `steamid` (string): 17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

### `get_player_bans` (~108 tokens)

Get a player's ban status

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.

Input parameters:

- `steamid` (string): 17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

### `get_owned_games` (~274 tokens)

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.

Input parameters:

- `check_appids` (array): Steam appids to reliably check ownership of (1-50), regardless of the top-50-by-playtime cap on `games`. Adds an `owns` field: [{appid, owned, playtime_hours}].
- `steamid` (string): 17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

### `get_recently_played` (~122 tokens)

Get recently played games

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.

Input parameters:

- `steamid` (string): 17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

### `get_recommended_games` (~526 tokens)

Get personalized game recommendations

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.

Input parameters:

- `count` (integer): How many recommendations to return (1-25). Default 10.
- `exclude_tags` (array): Drop any candidate carrying ANY of these tags (case-insensitive), e.g. ['Souls-like'] for 'recommend me something except Souls-like'. Use exact Steam tag names — a misspelled/unrecognized one isn't a…
- `min_discount` (integer): Minimum discount %, e.g. 30 for '30%+ off'. Omit to include full-price games too. Filtered server-side and re-checked client-side, so it holds at any value including 100.
- `steamid` (string): 17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

### `get_player_achievements` (~240 tokens)

Get a player's 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).

Input parameters:

- `appid` (integer, required): Steam application id (appid). Get it from search_games.
- `language` (string): Language for achievement names/descriptions; overrides STEAM_LANGUAGE.
- `steamid` (string): 17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/grinv-steam-games-mcp/steam-games-mcp#diagnostics

## Score history

- 2026-08-03: 80
- 2026-08-02: 83
- 2026-08-01: 61
- 2026-07-31: 34
- 2026-07-30: 41
- 2026-07-29: 41
- 2026-07-28: 75
- 2026-07-27: 41
- 2026-07-26: 76

## Links

- npm package: https://www.npmjs.com/package/steam-games-mcp
- Socket report: https://socket.dev/npm/package/steam-games-mcp
- Repository: https://github.com/Grinv/steam-games-mcp
- Changelog RSS feed: https://verifymcp.io/servers/grinv-steam-games-mcp/steam-games-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/grinv-steam-games-mcp/steam-games-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/grinv-steam-games-mcp/steam-games-mcp