What can you do with this server?

The steam-mcp server lets you explore the Steam store, discover deals, and access player data — no credentials needed for most features, with a free Steam Web API key unlocking player-specific tools. Store, Search & Discovery (No API Key Required) * Search for games by title to get appids, prices, Metacritic scores, and platform info * Get full game details: description, price/discount, genres, platforms, release date, developers, age rating, DLC, and PC requirements * Browse reviews: summaries, recent review excerpts, and historical trend data (improving/declining reception) * Check prices in bulk for up to 500 games at once — great for scanning wishlists for deals * Batch store cards for up to 100 games with price, review %, Steam Deck compatibility, and release date in one call * Discover games catalog-wide using filters: discount %, release recency, Steam Deck compatibility, review score, tags, and platform * Browse Steam front-page specials and featured sections (top sellers, new releases, coming soon) * Fetch game news and patch notes by appid * View global achievement unlock rates (rarity across all players) * Get live concurrent player counts for any game * Retrieve a player's public wishlist (no key needed if profile is public) Player Tools (Requires Free Steam Web API Key + Public Profile) * Resolve vanity profile names to SteamID64 * View a player's public profile: display name, online status, country, account age, current game * List owned games sorted by playtime * See recently played games (last two weeks) with recent and total playtime * Get full achievement lists for any game with names, descriptions, hidden flags, and global rarity * Track a player's achievement progress: unlocked count, completion %, and unlock dates 15 out of 19 tools require no credentials at all.

Which integrations are available for this server?

Provides tools for searching games, retrieving store details, prices, reviews, discounts, news, player profiles, libraries, achievements, and more via the Steam Web API.

How do I use Steam MCP Server?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. 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

by Grinv

Overview Schema Source Related Servers Discussions Admin

TypeScript

Remote

Steam MCP Server

npm version license: MIT MCP Registry steam-games-mcp 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?"
"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)"
      }
    }
  }
}

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, your wishlist) need a free API key and a public profile. 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 into STEAM_API_KEY.
Find your Steam ID. Set STEAM_ID to either:
- your vanity name: the custom part of your profile URL steamcommunity.com/id/YOUR_NAME → YOUR_NAME (resolved automatically), or
- your 17-digit SteamID64 (steamcommunity.com/profiles/7656…; or look it up at https://steamid.io).
With STEAM_ID set you can just ask "my wishlist / library"; without it, give the agent a SteamID64 each time (use resolve_vanity_url to 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 env block above). See docs/clients.md for per-client examples. Never commit them.

Tools

Key: – no credentials · K Steam Web API key.

Tool	Key	Purpose
`search_games`	–	Find games by title → appid (with price)
`get_game`	–	Store details by appid or name: price, genres, platforms, Metacritic, age rating, DLC, requirements
`get_items`	–	Batch store card (price, review %, Deck/SteamOS/Machine/Frame compat, native platforms, tags) — up to 50 appids
`discover_games`	–	Find games catalog-wide by discount, recency, Deck/SteamOS/Machine/Frame, platform, tags, rating
`get_game_reviews`	–	Review summary + recent reviews
`get_review_histogram`	–	Review trend over time (history + recent)
`get_prices`	–	Batch current price/discount — up to 250 appids
`get_specials`	–	Steam front-page discounts
`get_featured`	–	Featured sections (top sellers, new releases, …)
`get_game_news`	–	Recent news / patch notes
`get_global_achievements`	–	Global achievement unlock rates (rarity) — top 200
`get_current_players`	–	Live concurrent player count
`get_wishlist`	–	A player's wishlist — appids, or full cards + on-sale filter with `include_details` (public profiles)
`get_followed_games`	–	A player's followed games (Steam's "follow" feature, separate from the wishlist) — appids (public profiles)
`get_game_achievements`	K	Achievement list (names, descriptions) + rarity — first 150, definition order
`resolve_vanity_url`	K	Custom profile name → SteamID64
`get_player_summary`	K	Player public profile (incl. Steam level)
`get_player_bans`	K	VAC/game/community/economy ban status (works even on private profiles)
`get_owned_games`	K	A player's games + playtime (top 50 by playtime; `check_appids` reliably checks specific appids past that cap)
`get_recently_played`	K	Games played in the last two weeks (top 50 by recent playtime)
`get_recommended_games`	K	Personalized picks from playtime-weighted tags + review quality, excluding owned games
`get_player_achievements`	K	A player's achievement progress in a game — achievement list capped at top 200, unlocked first
`get_friend_list`	K	A player's friends — name, online state, current game (public friends list)
`find_friends_who_own`	K	Which friends own given appid(s) + their playtime — each friend's FULL library, first 200 friends (`friends_checked`)
`compare_players`	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: given a raw SteamID64 they work with no key at all (only resolving a vanity name to an ID needs one). Set STEAM_ID (a SteamID64 or vanity name) 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.

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
`what_should_i_play`	`steamid`, `budget`, `tags` (all optional)	Recommends catalog games from your library/taste, excluding what you own
`is_it_worth_buying`	`game` (title or appid, optional, autocompletes; asks if omitted)	Price, review trend and Steam Deck compatibility → a buy/wait/skip verdict
`deals_digest`	`min_discount`, `min_review`, `tags` (all optional)	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 (Storefront keyless; player check needs STEAM_API_KEY)
npm run inspector    # run under the MCP Inspector

Runtime requires Node ≥ 20.11. 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-mcp fetches the latest on the next run.
.mcpb bundle: 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

25 tools

compare_playersCompare two players' librariesA

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

ParametersJSON Schema

Name	Required	Description	Default
`steamid`	No	17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.
`other_steamid`	Yes	The other player's 17-digit SteamID64 to compare against. Convert a vanity/custom profile name with resolve_vanity_url first.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnlyHint/openWorldHint annotations, the description discloses the full-library scanning behavior, the returned-list cap at top 50 by combined playtime, the need to compare `returned` vs `shared_count`, and the self-compare behavior when steamid is omitted. No contradiction with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, each packed with distinct value: purpose, comparison/limitation, prerequisites and self-compare. Front-loaded with the primary purpose, no wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity and existing schema/annotations, the description fully covers selection, behavior, limitations, and edge cases (self-compare, public-profile requirement). The output schema likely handles return-value details, so the description is complete enough.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3. The description repeats the self-compare idea already in schema ('Omit to use the STEAM_ID configured on the server') but adds no new parameter syntax or format details beyond what the schema provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb: 'Find games two players both own, with each one's playtime'—clearly identifying the resource (two players' libraries) and differentiating from sibling get_owned_games. It also quotes user intents ('what can my friend and I both play'), making the tool's purpose unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly contrasts with get_owned_games, noting this tool checks full libraries while that caps at top 50, helping agents choose the right tool. It states prerequisites (STEAM_API_KEY, public profiles) and the failure condition (found:false), giving clear when-to-use and when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

discover_gamesDiscover games (deals, new releases, Steam Deck, rating)A

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

ParametersJSON Schema

Name	Required	Description
`tags`	No	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 nothing. Applied over the scanned popularity window, so raise `count` when combining niche tags.
`count`	No	How many catalog entries to SCAN (1-200). Default 50. Not a result count — the filters below are applied over this window, so a strict combination can return far fewer than this; raise it for stricter filters. (Tools that cap what they RETURN call that `limit`.)
`start`	No	Pagination offset into the catalog (default 0).
`country`	No	Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
`language`	No	Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.
`platform`	No	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 use steam_os / steam_deck instead. Each result's `platforms` field lists its native builds, while steam_os/steam_deck report Proton compatibility, so native vs Proton stay distinct.
`steam_os`	No	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:'linux'; for the Steam Machine console specifically, use steam_machine.
`min_review`	No	Minimum positive-review %, e.g. 85. Applied over the returned page.
`steam_deck`	No	Steam Deck compatibility (runs via Proton): 'verified' = Deck-Verified only; 'playable' = Playable or Verified. Not a native Linux build — see `platform` for that.
`min_reviews`	No	Minimum review count (filters out games with too few reviews).
`steam_frame`	No	Steam Frame (VR headset) compatibility: 'verified' = Frame-Verified only; 'playable' = Playable or Verified.
`min_discount`	No	Minimum discount %, e.g. 80 for '80%+ off' — this is the 'deals' filter. Omit to include full-price games.
`steam_machine`	No	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.
`released_after`	No	Keep only games released on/after this date (YYYY-MM-DD).
`released_within_days`	No	Alternative to released_after: released within the last N days.

Output Schema

ParametersJSON Schema

Name	Required	Description
`deals`	Yes
`matched`	Yes	How many results survived every filter, out of the scanned window (see `count`).
`returned`	Yes	How many of `matched` are in `deals` below. Lower than `matched` when the result was capped for response size — narrow the filters (or page with `start`) to see the rest.
`total_matching`	Yes	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 neither was given. NOT the number of games matching tags/platform/compat/review/the exact release-date cutoff, which have no server-side filter and this tool applies only over the scanned `count`-sized window below. Don't read this as 'N games match all my filters' — use `returned` for that instead.

TDQS

A5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Discloses key behavioral traits: keyless operation, server-side vs client-side filtering, popularity-first scanning with potential niche misses, 60-result cap, and the need to compare returned vs matched. This goes well beyond the readOnlyHint/openWorldHint annotations, giving agents realistic expectations about result sparsity and pagination.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Though long, the description is tightly structured: core function, examples, sibling distinction, then caveats. No redundant sentences; every clause carries operational meaning for a 15-parameter tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 15-parameter discovery tool with output schema, the description covers filtering semantics, pagination, result cap, and alternative tools. It even addresses edge cases like misspelled tags and Proton-vs-native distinctions. Missing nothing critical for selecting and invoking the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema already has 100% parameter coverage; the description adds cross-parameter meaning via examples (e.g., min_discount + min_review for '>80% off with 90%+ reviews'), explains that count is a scan window not a result limit, and clarifies server-side enforcement for min_discount and released_after. This is substantial added value beyond schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description opens with 'Find games across the whole Steam catalog (keyless)' – a specific verb + resource + scope. It enumerates all filter dimensions and explicitly contrasts itself with get_items and get_recommended_games, distinguishing it from siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly names alternatives: 'unlike get_items...' and 'use get_recommended_games' for library-based taste. Provides concrete use-case examples and clarifies when to use this tool vs others, including key-gating caveats.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

find_friends_who_ownFind friends who own a gameA

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

ParametersJSON Schema

Name	Required	Description	Default
`appids`	Yes	Steam appids to check (1-10).
`steamid`	No	17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description goes well beyond the readOnlyHint and openWorldHint annotations. It discloses dependencies (STEAM_API_KEY, public friends list), failure modes (found:false, per-friend private_library, rate-limited lookups), caps (100 entries per list, 200-friend lookup limit), and the timeout rationale. This is rich, behavior-critical context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Though lengthy, the description is tightly packed and front-loaded with the core purpose. Each subsequent sentence addresses a distinct edge case or behavioral caveat, so every sentence earns its place. The structure uses clear separators and comparative language to keep it readable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Even with an output schema present, the description explains the meaning of key output fields (owners, private_friends, unavailable_friends, friends_checked, total_friends) and truncation behavior. It also covers operational context like timeouts and limits, making it fully complete for agent decision-making.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already provides 100% coverage for both parameters (appids and steamid), including descriptions. The tool description does not add new parameter-level semantics beyond referencing appids and mentioning source via search_games; it focuses on tool behavior rather than parameter syntax.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Check which of a player's Steam friends own one or more games by appid, with each owner's playtime_hours'. It immediately distinguishes itself from get_owned_games and other sibling tools by clarifying scope ('a player's friends' vs 'own ownership').

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit guidance is given: 'For the PLAYER'S OWN ownership instead of a friend's, use get_owned_games's check_appids' and 'Get appids from search_games.' It also explains when the tool should not be used or how to interpret missing friends ('treat a friend missing from all three lists as unchecked, not as a non-owner').

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_current_playersGet current player countA

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

ParametersJSON Schema

Name	Required	Description	Default
`appid`	Yes	Steam application id (appid). Get it from search_games.

Output Schema

ParametersJSON Schema

Name	Required	Description
`appid`	Yes
`player_count`	Yes

TDQS

A4.5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds meaningful behavioral context beyond the annotations: it notes 'No API key required' (authentication requirement) and 'Errors clearly if the appid is unknown/invalid rather than returning a null count' (error handling behavior). These details are not provided by annotations, so the description enhances transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no filler. It front-loads the primary purpose, then adds necessary prerequisite and error behavior in a compact manner.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple (one param, no nested objects) and comes with an output schema, so the description does not need to explain return values. The description covers purpose, prerequisite, authentication, and error handling, making it complete for an agent to use correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage for the single parameter 'appid' is 100%, and the schema already describes it as a Steam application id with a reference to search_games. The tool description repeats this guidance without adding new semantic value beyond what schema provides, so baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Get how many people are playing a game right now (live concurrent player count) by appid.' This is a specific verb-resource pair with clear scope, and it clearly distinguishes itself from sibling tools like get_game or get_prices.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit context for when to use this tool ('right now') and includes a cross-reference to 'Get the appid from search_games' for obtaining the required parameter. However, it does not explicitly state when not to use the tool or list alternatives, so it falls short of full exclusionary guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_featuredGet featured store sectionsA

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

ParametersJSON Schema

Name	Required	Description	Default
`country`	No	Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
`language`	No	Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.

Output Schema

ParametersJSON Schema

Name	Required	Description
`specials`	Yes
`coming_soon`	Yes
`top_sellers`	Yes
`new_releases`	Yes

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=true, establishing a safe read-only profile. The description adds value by noting 'No API key required' and clarifying that the response is a comprehensive bundle ('all in one call') of multiple lists, which goes beyond the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences: the first packs the tool's purpose, scope, and return contents; the second provides alternatives and the auth note. No waste, front-loaded with the core action, and easily scannable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, the description doesn't need to detail return structure, but it still mentions the key return elements (games with appid and price). It covers use case, alternatives, auth, and the fact that it's a single call, making it fully self-sufficient for an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% with both parameters (country and language) already described as overrides. The description does not add further parameter details but also doesn't need to, as the schema handles semantics fully. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb ('Get'), a specific resource ('Steam store's featured sections'), and enumerates the exact contents (specials, top sellers, new releases, coming soon) with return details (list of games with appid and price). It also distinguishes itself from siblings by framing it as a single-call front-page overview.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states the primary use case (general store front page overview) and provides clear alternatives for narrower needs: 'For just current discounts use get_specials (lighter), or discover_games for catalog-wide deals with filters.' This tells the agent exactly when to choose this tool versus siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_followed_gamesGet a player's followed gamesA

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

ParametersJSON Schema

Name	Required	Description	Default
`steamid`	No	17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnlyHint and openWorldHint annotations, the description discloses specific behaviors: returns only appids and store_url, no price/name, capped at 200 items with a 'returned' vs 'total' check, and returns found:false on private profiles. This significantly enriches the agent's understanding of what to expect.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is dense but every sentence contributes unique value: purpose, distinction, prerequisites, output format, pagination, and next steps. It is front-loaded with the primary function and avoids redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's low complexity and existing output schema, the description covers all essential aspects: input, output, failure mode, pagination, and related tools. It is complete enough for an agent to select and invoke the tool correctly without additional lookups.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already fully describes the steamid parameter, including format and optional omission. The description essentially repeats this information and adds no new parameter-specific semantics; the only extra detail concerns the resolve_vanity_url prerequisite, which is a cross-tool note rather than parameter meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists a player's followed games by SteamID64, using a specific verb (list) and resource (followed games). It explicitly distinguishes this from the wishlist, making the scope unambiguous and differentiating it from sibling tools like get_wishlist.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit when-to-use guidance: mentions using resolve_vanity_url to convert vanity names, passing appids to get_items for additional data, and notes that the profile must be public. It also clarifies that no API key is required for this tool while the conversion does, giving clear context for usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_friend_listGet a player's friend listA

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

ParametersJSON Schema

Name	Required	Description	Default
`steamid`	No	17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Discloses that list is capped at 100 most-recently-added, provides check via 'returned' vs 'total', and explains failure case (found:false if not public). Annotations (readOnlyHint, openWorldHint) are complemented.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single paragraph, front-loaded with core functionality, followed by caveats and alternative. Every sentence adds value; no fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers all needed context: output fields, pagination hint, error conditions, and prerequisite steps. Output schema exists, so return details are optional but description adds extra clarity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Description adds meaning beyond schema: explains that omitting steamid uses server-configured ID, and advises converting vanity URLs via resolve_vanity_url. Schema coverage is 100%.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'List', the resource 'a player's Steam friends', and includes specific fields (name, online state, current game, friendship duration). It also distinguishes from sibling tool find_friends_who_own.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says when to use the alternative tool (find_friends_who_own), mentions prerequisites (STEAM_API_KEY, public friends list), and instructs to convert vanity URLs using resolve_vanity_url.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_gameGet game detailsA

Read-only

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.

ParametersJSON Schema

Name	Required	Description
`name`	No	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.
`appid`	No	Steam appid (from search_games). Provide appid OR name.
`country`	No	Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
`language`	No	Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.

Output Schema

ParametersJSON Schema

Name	Required	Description
`dlc`	Yes	Appids of this game's DLC, capped — a DLC-heavy game can list hundreds, which would dwarf every other field. Compare against dlc_total, and pass the appids to get_items for their names and prices.
`name`	No
`type`	Yes
`appid`	No
`demos`	Yes
`price`	Yes
`genres`	Yes
`is_free`	Yes
`website`	Yes
`base_game`	Yes
`dlc_total`	Yes	How many DLC this game has in total, before the `dlc` cap.
`platforms`	Yes
`store_url`	Yes
`categories`	Yes
`developers`	Yes
`drm_notice`	Yes
`metacritic`	Yes
`publishers`	Yes
`coming_soon`	Yes
`header_image`	Yes
`release_date`	Yes
`required_age`	Yes
`account_notice`	Yes
`metacritic_url`	Yes
`recommendations`	Yes
`short_description`	Yes
`achievements_total`	Yes
`controller_support`	Yes
`content_descriptors`	Yes
`pc_requirements_min`	Yes
`supported_languages`	Yes
`achievements_highlighted`	Yes	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.

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, and the description adds useful behavioral context: 'No API key required' and the name-resolution behavior ('a title is resolved to the closest store match'). It does not detail pagination or error behavior, but the output schema covers return format, so this is sufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the main purpose, and lists the included fields without unnecessary fluff. Every sentence contributes value, and the length is appropriate for the tool's complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema and annotations, the description covers the essential aspects: what data is returned, how to identify the game, and authentication requirements. It lacks explicit error handling or alternative-use guidance, but these are not critical for a read-only lookup tool with rich schema support, so it is nearly complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already provides 100% coverage with descriptions for all four parameters, including the appid-wins-if-both-given rule. The description merely restates the two identifier options without adding new syntactic or semantic details, so it does not elevate above the schema baseline.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Get') and resource ('full store details for one game'), and enumerates the specific fields included (description, price/discount, genres, etc.). It also distinguishes from sibling tools by specifying the identification methods (appid or name) and explicitly notes that it returns a highlighted-achievements sample, which is unique among the sibling list.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear context for when to use the tool ('Get full store details for one game') and provides an integration hint by mentioning 'from search_games' to obtain appid. It does not explicitly name alternative tools for other use cases (e.g., get_prices for prices only), so it falls short of the highest bar, but the intended usage is well implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_game_achievementsGet a game's full achievement listA

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

ParametersJSON Schema

Name	Required	Description	Default
`appid`	Yes	Steam application id (appid). Get it from search_games.
`language`	No	Language for achievement names/descriptions; overrides STEAM_LANGUAGE.

Output Schema

ParametersJSON Schema

Name	Required	Description
`game`	Yes	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 identifier, or get the store title from get_game.
`total`	Yes
`returned`	Yes
`achievements`	Yes

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds rich behavioral context beyond the readOnlyHint/openWorldHint annotations: the 150-cap with returned vs total, the empty-list/total:0 edge case for DLC/nonexistent games, and the API key dependency. It also clarifies what the tool does NOT report (why a list is empty), which is valuable transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is dense but every detail serves a purpose, covering scope, cap, edge cases, prerequisites, and alternatives in a compact block. Semicolons and clauses keep it readable, though it could be slightly more scannable. Still, it earns a high score for efficiency.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity, the description covers all needed context: what is returned, how to handle edge cases, the required key, and sibling differentiators. With an output schema present, the description doesn't need to detail return structures; it fully addresses the contextual gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with both parameters described. The description reinforces the appid's source and language's override behavior but doesn't add substantial meaning beyond the schema. Baseline 3 is appropriate when the schema already documents parameters well.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the tool lists a game's achievements with specific fields (names, descriptions, hidden flag, rarity) and order. It explicitly distinguishes from sibling tools like get_global_achievements and get_player_achievements, making its purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit guidance on when to use this tool versus alternatives: '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, use get_player_achievements.' Also notes the STEAM_API_KEY requirement and directs users to get appid from search_games.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_game_newsGet game newsA

Read-only

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.

ParametersJSON Schema

Name	Required	Description	Default
`appid`	Yes	Steam application id (appid). Get it from search_games.
`limit`	No	How many news items (1-20). Default 5.

Output Schema

ParametersJSON Schema

Name	Required	Description
`items`	Yes

TDQS

A4.5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations (readOnlyHint, openWorldHint), the description reveals that unknown appids return an empty list rather than an error, and that no API key is required. It also lists the output fields, adding practical context for handling results.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences achieve high density: the first defines purpose and output, the second covers edge-case behavior and input sourcing. Every sentence earns its place; no wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only tool with two parameters and an output schema, the description covers purpose, input source, edge-case behavior, auth requirements, and return fields. No significant operational gaps remain.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, with both appid and limit fully described in the input schema. The description mostly repeats appid provenance ('Get it from search_games') and adds no new parameter-level meaning beyond what the schema already provides. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves game news/patch notes by appid, using a specific verb and resource. It lists the returned fields (title, date, author, excerpt, link) and is distinct from sibling tools like get_game_reviews or get_global_achievements.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It instructs the agent to obtain the appid from search_games, a key prerequisite. It also explains that an unknown appid returns an empty list, which helps set expectations. However, it does not explicitly contrast when to prefer this tool over alternatives, so it misses the full 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_game_reviewsGet game reviewsA

Read-only

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.

ParametersJSON Schema

Name	Required	Description	Default
`type`	No	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 excerpts.	all
`appid`	Yes	Steam application id (appid). Get it from search_games.
`limit`	No	How many recent reviews (1-20). Default 5.
`review_language`	No	Filter reviews by language. Use Steam's full language name — english, russian, schinese — NOT an ISO code like en/ru/zh: Steam answers an unrecognized value with zero reviews rather than an error, so a 9M-review game reads as having none. Default 'all'. Setting this ALSO rescopes the summary counts (total_reviews / positive / negative / %) to that language — they are no longer the game's global totals. Leave it at 'all' when you want those.	all

Output Schema

ParametersJSON Schema

Name	Required	Description
`reviews`	Yes
`summary`	Yes
`positive_pct`	Yes
`total_reviews`	Yes
`total_negative`	Yes
`total_positive`	Yes

TDQS

A4.9/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnlyHint annotation, the description discloses a concrete behavioral trait: 'Review text over 600 characters is truncated.' It also notes 'No API key required,' addressing authentication expectations. There is no contradiction with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences, front-loaded with the core action, and every sentence adds distinct information: what it returns, a behavioral caveat, and usage alternatives/prerequisites. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, return values are fully described there. The description covers prerequisites, alternatives, and a key edge case (truncation), making it complete for a read-only retrieval tool. The presence of annotations and a well-described schema round out the context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already provides 100% coverage for all parameters, including detailed descriptions for type, limit, and review_language. The description adds value by telling the agent to get appid from search_games, which is a useful provenance hint not present in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly specifies the resource ('game reviews') and the exact output ('summary (score label, positive/negative counts, %) and a few recent reviews'), with a precise parameter ('by appid'). It also distinguishes this tool from get_review_histogram, making the purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly tells the agent when to use this tool (for a snapshot) and when not to (for long-term trends, use get_review_histogram). It also directs the agent to search_games for obtaining the appid and notes that no API key is required, covering prerequisites and alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_global_achievementsGet global achievement ratesA

Read-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, 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.

ParametersJSON Schema

Name	Required	Description	Default
`appid`	Yes	Steam application id (appid). Get it from search_games.

Output Schema

ParametersJSON Schema

Name	Required	Description
`count`	Yes
`returned`	Yes
`achievements`	Yes

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnlyHint annotation, the description discloses ordering (most-common first), a cap (first 200), the need to check `returned` vs `count`, error behavior (empty list for unknown/no-schema appids), and that no API key is required. This richly informs the agent's expectations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is information-dense yet well-structured. Each sentence adds unique value: purpose, return data and limitations, edge-case behavior, source of appid, and authentication. No filler or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with one parameter, an output schema, and annotations, the description covers return fields, ordering, limits, error handling, and data source. It is fully sufficient for an agent to invoke this tool correctly without additional external knowledge.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema provides 100% coverage, including a description for appid ('Steam application id (appid). Get it from search_games.'). The tool description repeats 'by appid' and 'Get the appid from search_games' but adds no new meaning beyond the schema, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Get'), a resource ('global unlock percentage of each achievement'), and a scope ('by appid'). It clearly differentiates from the sibling get_game_achievements by noting it returns internal names and unlock percentages rather than display names/descriptions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly directs users to get_game_achievements for display names/descriptions, references get_game_news for similar behavior on unknown appids, and instructs to obtain appid from search_games. This provides clear when-to-use and alternative context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_itemsBatch store card for many gamesA

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

ParametersJSON Schema

Name	Required	Description
`appids`	Yes	Steam appids (1-50). Split a longer list across calls.
`country`	No	Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
`language`	No	Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.

Output Schema

ParametersJSON Schema

Name	Required	Description
`count`	Yes
`items`	Yes

TDQS

A4.8/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With readOnlyHint and openWorldHint annotations already declaring the safety profile, the description adds substantial behavioral detail: unknown/invalid appids are returned as available:false rather than dropped, compatibility fields are explained (including the important distinction between steam_frame and vr_support), and discount_end is defined as ISO UTC time. This goes well beyond the annotations and provides critical runtime expectations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but front-loaded with the core purpose and then details each returned field, with disambiguation and alternative tool references. Every sentence serves a purpose, though some field explanations might be redundant given the output schema exists. Overall it is well-structured but slightly verbose for a tool with a full schema.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is comprehensive: it covers the purpose, batch limit (implied by schema and restated), invalid appid behavior, detailed field semantics, and points to sibling tools for discovery and price-only batches. It leaves no ambiguity about how to use this tool within the broader tool ecosystem.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already covers all three parameters with descriptions (appids 1-50, country, language), so the baseline is 3. The description adds useful input-related context: invalid appids are tolerated and returned as rows, and the 'keyless call' note clarifies no authentication is needed. However, it does not add much about country/language beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Get price/discount, review % (positive), hardware compatibility, popular user tags and release date for a LIST of games by appid in ONE keyless call.' It clearly distinguishes from siblings by emphasizing batch handling of an existing appid list, and explicitly names alternatives such as get_prices and discover_games.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit when-to-use guidance: it calls itself 'The efficient way to price-, rating-, tag- and compat-check a wishlist or library without a request per game.' It also states when to use alternatives ('For a bigger batch (up to 250 appids) when you only need price, use get_prices instead') and how to obtain appids ('Get appids from search_games / get_wishlist / get_owned_games').

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_owned_gamesGet owned gamesA

Read-only

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.

ParametersJSON Schema

Name	Required	Description	Default
`steamid`	No	17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.
`check_appids`	No	Steam appids to check ownership of (1-50), regardless of the top-50-by-playtime cap on `games`. Adds an `owns` field: [{appid, owned, playtime_hours}]. One upstream gap to know about: Steam omits free-to-play titles the player owns but has NEVER launched, so those report owned:false. A private profile reports no `owns` at all (ownership unknown) rather than a false owned:false.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnlyHint/openWorldHint annotations, the description discloses the top-50-by-playtime cap on `games`, the uncapped behavior of check_appids, the free-to-play never-launched omission, and the private-profile reporting ('no `owns` at all'). These are crucial behavioral caveats not evident from annotations alone.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Every sentence serves a purpose: main capability, cap caveat, ownership-check alternative, two sibling differentiators, requirements, and input resolution. Information-dense without redundancy, and the most important action ('List...') is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema exists and annotations cover safety, the description still adds essential context: alternatives, limits, prerequisites, and edge cases. The agent can confidently select, invoke, and interpret results without external documentation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Although the schema already describes both parameters with 100% coverage, the description enriches them with real-world usage context: check_appids is positioned as a reliable ownership test, explains the `owns` result shape, and highlights edge cases (free-to-play, private profiles). It also adds practical advice for the `steamid` parameter via resolve_vanity_url.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description opens with a specific verb+resource+scope: 'List the games a player owns with playtime (hours), most-played first.' It also explicitly contrasts with sibling tools (get_recently_played, find_friends_who_own), making its unique purpose unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit when-to-use guidance: use check_appids for specific ownership checks, use get_recently_played for two-week activity, and use find_friends_who_own for friends. Also states prerequisite visibility requirements (public profile + game-details visibility) and how to obtain the required SteamID64.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_player_achievementsGet a player's achievementsA

Read-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 (also returned if the game has no achievements at all).

ParametersJSON Schema

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

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.8/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint and openWorldHint, but the description adds key behavioral details: the achievements array caps at 200, unlocked first, and to check returned vs total; returns found:false for private profiles or games with no achievements. These go beyond the annotations and are critical for interpreting results.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two dense sentences, packed with valuable information. It is front-loaded with the core purpose, then expands on limitations, alternatives, and prerequisites. While every clause earns its place, the density and multiple parentheticals make it slightly harder to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (capped array, alternative tools, auth requirements, error cases) and the presence of an output schema, the description covers all necessary context. It explains what data is returned, the cap behavior, and when found:false appears, making it sufficiently complete for an agent to use effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so parameters are fully documented. The description adds context by highlighting the role of SteamID64 and appid, noting steamid is optional (falls back to configured STEAM_ID), and language overrides. This extra explanation is valuable but not strictly necessary given the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly specifies the tool's function: retrieving a player's achievement progress for a single game via SteamID64 and appid. It differentiates from siblings by naming get_game_achievements for the full list and get_global_achievements for rarity without a key.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to use the tool (for player-specific progress) and when to use alternatives (get_game_achievements for full game list, get_global_achievements for rarity). It also includes prerequisites (STEAM_API_KEY, public profile visibility) and the found:false outcome, giving clear usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_player_bansGet a player's ban statusA

Read-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. Requires STEAM_API_KEY.

ParametersJSON Schema

Name	Required	Description	Default
`steamid`	No	17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint and openWorldHint. The description adds valuable behavioral context: the ban status is always public and requires a Steam API key. This goes beyond the annotations without contradicting them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no filler. It front-loads the core action and scope, then adds a key differentiator and auth requirement. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema exists and the tool has a single optional parameter, the description covers purpose, usage context, public behavior, and auth requirements. Minor gaps like rate limits or error handling are acceptable for a simple read-only tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the parameter description for 'steamid' is already detailed (17-digit, optional, server default, vanity resolution). The tool description only restates 'by SteamID64' without adding new parameter-specific insights, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool checks a player's ban status, enumerating specific ban types (VAC, game, community, economy) and the resource (SteamID64). This distinguishes it from all sibling tools, none of which cover bans.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly provides a use case ('useful before trading or adding a friend') and notes that ban status is public even when the profile is private, guiding when to choose this tool. It lacks explicit when-not-to-use guidance, but no sibling tool offers an alternative for ban status.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_player_summaryGet player profileA

Read-only

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.

ParametersJSON Schema

Name	Required	Description	Default
`steamid`	No	17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnlyHint and openWorldHint annotations, the description discloses the STEAM_API_KEY requirement and the private-profile behavior where country, account age, and current game only populate for public profiles. This is valuable contextual information that enriches the agent's understanding of side effects and response variability.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences long, front-loaded with the main purpose, and every sentence adds substantive value—purpose, auth requirements, privacy caveats, and alternative tool. No filler or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only profile lookup tool with an output schema present, the description sufficiently covers the essential nuances (auth, private profiles) and the distinction from a sibling tool. The output schema handles return value details, so no further information is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already provides a full description of the steamid parameter, including format, default behavior when omitted, and conversion guidance via resolve_vanity_url. The description does not add further meaning beyond referencing the ID type, so the baseline score of 3 for high schema coverage is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies what the tool does: retrieves a player's profile using SteamID64 and enumerates the specific fields returned (display name, online state, country, account age, Steam level, current game). This explicit verb-resource structure distinguishes it from siblings like get_player_bans, which handles a different purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when not to use this tool: 'For VAC/game/trade ban status instead, use get_player_bans.' This provides a clear exclusion and names an alternative, meeting the highest bar for usage guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_pricesGet prices for many gamesA

Read-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 (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.

ParametersJSON Schema

Name	Required	Description	Default
`appids`	Yes	Steam appids to price (1-250). Split a longer list across calls.
`country`	No	Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.

Output Schema

ParametersJSON Schema

Name	Required	Description
`count`	Yes
`prices`	Yes

TDQS

A4.9/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds valuable behavioral details: rows preserve input order, unavailable appids are marked available:false and never dropped, and each row includes final/initial price and discount_percent (or is_free). It also notes no API key is required, which is non-obvious.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single dense paragraph, but every sentence adds critical information: purpose, batch capacity, alternatives, output ordering and availability handling, and API key requirements. It is front-loaded with purpose and perfectly sized for a tool with this complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, the description still goes beyond it by explaining row ordering, unavailable handling, and the exact fields returned. It also covers rate limits (250 appids), usage alternatives, and authentication requirement (none). This is complete for a batch price-lookup tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the explanation carries little burden. Still, the description adds extra context by suggesting where to get appids (search_games or get_wishlist) and implicitly explains the purpose of the batch. This is more than the schema provides, though not substantial.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with 'Get current price and discount for a batch of games by appid in one call', which is a specific verb-resource combination. It clearly distinguishes itself from siblings by contrasting with get_items for additional data like reviews or tags.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit when-to-use (checking a wishlist for deals), a hard limit (250 appids), and names an alternative (get_items for review %, hardware compatibility, tags). It also directs users on how to obtain appids via search_games or get_wishlist, fully covering usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_recently_playedGet recently played gamesA

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

ParametersJSON Schema

Name	Required	Description	Default
`steamid`	No	17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnlyHint annotation, the description adds critical behavioral details: the 50-item cap with instruction to check returned vs total, ordering by playtime not recency, and the exact requirement for public profile with game-details visibility. It also discloses the found:false response on failure, giving the agent a clear picture of behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, each earning its place: the first defines the core behavior and ordering/cap, the second provides the alternative tool, and the third covers prerequisites and failure behavior. No redundancy or fluff; information is front-loaded and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity and the presence of an output schema, the description covers all essential context: behavior, ordering, cap, alternative, authentication requirement, and failure mode. It is fully complete for an agent to decide when and how to invoke the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already fully documents the single steamid parameter with a detailed description including how to omit it and vanity URL conversion. The tool description adds no additional parameter semantics beyond implicit player context, so the baseline of 3 is appropriate given 100% schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'List' and clearly states the resource: games a player has played in the last two weeks, including recent and total playtime. It also distinguishes itself from get_owned_games by explicitly noting the difference in time window and sorting, making its purpose unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit when-to-use guidance by directing users to get_owned_games for all-time top games. It also states prerequisites (STEAM_API_KEY, public profile with game-details visibility) and the failure mode ('returns found:false'), which clearly indicates when this tool is appropriate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_recommended_gamesGet personalized game recommendationsA

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

ParametersJSON Schema

Name	Required	Description
`limit`	No	How many recommendations to return (1-25). Default 10.
`steamid`	No	17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.
`exclude_tags`	No	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 an error, it just drops nothing.
`min_discount`	No	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.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.9/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description goes well beyond the readOnlyHint and openWorldHint annotations by disclosing the weighted-tag ranking logic, discounting by review score, exclusion of owned games, the 30-game/300-catalog scan limitations, and the edge case where found:false is returned. There is no contradiction with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is detailed and every sentence contributes useful context, but it is longer than necessary. The opening sentence is dense with algorithm details, and some nuances (e.g., 're-checked client-side') could be trimmed for greater concision. Still well-structured and front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity, the description covers the algorithm, input/output behavior, failure modes, authentication requirements, and comparisons with alternatives. The presence of an output schema reduces the need to explain return values, and the description handles all other context comprehensively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Although the schema already covers 100% of parameter descriptions, the tool description adds significant semantic value: it explains how exclude_tags interacts with playtime-derived preferences, gives a concrete example ('suggest games on sale, not RPGs or shooters' → exclude_tags:['RPG','Shooter','FPS'], min_discount:30), and clarifies that exclude_tags requires exact Steam tag names and that unrecognized tags silently drop nothing.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Recommend unowned Steam catalog games personalized to this player,' followed by a precise explanation of the recommendation algorithm. It clearly differentiates from sibling discover_games by stating that this tool infers taste from the whole library rather than requiring user-named filters.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit usage guidance is given: when to use this tool ('what should I play next' / 'recommend me something') and when not to (for a single named title, use discover_games after fetching tags via get_items). It also states prerequisites (STEAM_API_KEY, public profile with game-details visible) and notes that heavy exclude_tags/min_discount combinations can return fewer than limit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_review_histogramGet review trend over timeA

Read-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'. 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.

ParametersJSON Schema

Name	Required	Description	Default
`appid`	Yes	Steam application id (appid). Get it from search_games.

Output Schema

ParametersJSON Schema

Name	Required	Description
`recent`	Yes
`history`	Yes
`rollup_type`	Yes	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 fixed set of possible values.

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations declare readOnlyHint and openWorldHint, and the description adds substantial behavioral detail beyond these: rollup_type is chosen server-side, long-term history is capped at 24 entries, per-day data at 30 days, and each entry contains positive/negative counts and positive %. It also mentions 'No API key required', which is not in the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single paragraph but every sentence earns its place: the core action, the output structure, limits, use case, alternative, and attribution. It is dense without being rambling, front-loads the verb and resource, and remains easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given a single parameter, a rich output schema, and annotations for read-only safety, the description sufficiently covers all relevant operational details: data granularity, caps, positive percentage, and the differentiator from get_game_reviews. It is complete for an agent to make an informed invocation decision.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description for the only parameter (appid) is complete and even includes the instruction to get it from search_games, so the description adds no new parameter semantics. Per the baseline rule for schema coverage >80%, a score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves review trends over time by appid, specifying two distinct data components (long-term history and per-day breakdown) with counts and positive percentages. It also explicitly distinguishes itself from sibling tool get_game_reviews, making the purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly provides use-case guidance ('Good for are reviews improving / did an update hurt reception') and names the alternative (get_game_reviews) for a different need. It also instructs the user to obtain the appid from search_games, covering all prerequisites for correct invocation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_specialsGet current discountsA

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

ParametersJSON Schema

Name	Required	Description	Default
`country`	No	Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
`language`	No	Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.

Output Schema

ParametersJSON Schema

Name	Required	Description
`specials`	Yes

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds useful context beyond annotations: scoped to the Steam store front page, returns discount percentage and original/final price, and requires no API key. This is meaningful extra behavioral disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the core purpose, followed by a targeted alternative pointer and an auth note. Every sentence adds value, no fluff or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simple list behavior, the output schema, and annotations, the description sufficiently covers scope, return content, auth requirements, and the key sibling alternative. Nothing important is missing for an agent to select and invoke this correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema covers both parameters (country, language) with descriptions, giving 100% coverage. The description doesn't add parameter-specific details but doesn't need to since the schema already explains overrides. Baseline of 3 is appropriate when schema carries the weight.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description uses a specific verb ('List') and identifies the exact resource ('games currently on special on the Steam store front page'). It clearly distinguishes itself from the sibling discover_games by contrasting front-page-only scope with the all-catalog alternative.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly provides when-to-use context: front-page specials. Names discover_games with min_discount as the alternative for broader catalog discounts, giving clear exclusion and direction. Also notes no API key required, reducing usage friction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_wishlistGet a player's wishlistA

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

ParametersJSON Schema

Name	Required	Description
`tags`	No	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. Implies include_details.
`country`	No	Country (cc) for prices; overrides STEAM_COUNTRY. Implies include_details.
`steamid`	No	17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first.
`language`	No	Store language; overrides STEAM_LANGUAGE. Implies include_details.
`platform`	No	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 use steam_os / steam_deck instead. Each result's `platforms` field lists its native builds, while steam_os/steam_deck report Proton compatibility, so native vs Proton stay distinct.
`steam_os`	No	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:'linux'; for the Steam Machine console specifically, use steam_machine.
`min_review`	No	Keep only items with at least this positive-review %. Implies include_details.
`steam_deck`	No	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`	No	Steam Frame (VR headset) compatibility: 'verified' = Frame-Verified only; 'playable' = Playable or Verified.
`min_discount`	No	Keep only items discounted at least this %, ranked by discount. Implies include_details.
`on_sale_only`	No	Only wishlist items currently discounted, ranked by discount %. Implies include_details.
`steam_machine`	No	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.
`include_details`	No	Return full store cards (name, price, discount, reviews, compatibility, tags) per item in one call, instead of just appids. Implied by any filter below.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations provide readOnlyHint and openWorldHint, and the description adds substantial behavioral context: public requirement with found:false, output caps (100 light, 60 detailed), ranking logic (priority vs discount), and the Steam limitation where only ~100 wishlist entries get enriched data, exposed via `enriched` and `note`. This goes well beyond annotations without contradicting them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

While long, every sentence serves a purpose: purpose, auth/preconditions, filtering semantics, caps, ranking, Steam's data limitation, and a pointer to a sibling tool. The flow moves from core behavior to details to edge cases, and the front-loaded first sentence gives immediate utility. No filler or redundant statements.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 13 optional parameters, 5 enums, and an output schema, the description covers all key aspects: what the tool returns (light vs detailed), how filters interact, limits, ranking, data availability quirks, and related tools. The existence of an output schema means return-value details don't need to be repeated, and the description fills all other contextual gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, but the description adds critical interpretive value beyond parameter names/types: it distinguishes platform (native) from steam_os/steam_deck (Proton), explains that filters imply include_details, notes that misspelled tags silently match nothing, and clarifies the precedence of country/language overrides. This transforms flat enum descriptions into actionable usage rules.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with 'List a player's Steam wishlist by SteamID64,' a specific verb+resource combination that clearly distinguishes it from sibling tools. It also explicitly differentiates from get_items by noting the one-call detailed mode, and mentions resolve_vanity_url for name conversion.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit when-to-use guidance: it states the public/wishlist requirement, explains when to use include_details versus the light list, and clarifies that filters switch to detailed view. It also points to the sibling tool resolve_vanity_url for vanity names and notes it requires an API key, which is helpful for choosing the right path.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

resolve_vanity_urlResolve vanity URL to SteamIDA

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

ParametersJSON Schema

Name	Required	Description	Default
`vanity`	Yes	Vanity name, e.g. 'gabelogannewell' from steamcommunity.com/id/gabelogannewell.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate readOnlyHint and openWorldHint. Description adds key behavioral details: requiring an API key and returning a specific false flag. No contradiction with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, no wasted words. First sentence informs purpose and input, second covers prerequisite and a possible output. Front-loaded with action and result.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With one parameter, 100% schema coverage, existing annotations, and an output schema present, the description covers the input format, a prerequisite, and a failure case. No gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema covers the parameter fully; description adds a concrete example ('gabelogannewell') and explains its origin from the URL. Provides meaning beyond the schema description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly specifies the action (convert/ resolve), the resource (vanity profile name), and the result (17-digit SteamID64). Distinguishes itself from sibling tools which are about games, reviews, or player lists; this is the only one that resolves vanity URLs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

States requirement for STEAM_API_KEY and describes behavior when the name doesn't resolve (found:false). Implicitly tells when to use (when you have a vanity URL part) but could be more explicit about when not to use (e.g., if already have SteamID64).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_gamesSearch gamesA

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

ParametersJSON Schema

Name	Required	Description
`term`	Yes	Game title to search for.
`country`	No	Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call.
`language`	No	Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call.

Output Schema

ParametersJSON Schema

Name	Required	Description
`total`	Yes
`results`	Yes

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate read-only and open-world (public), but the description adds critical behavioral detail: the 'type' caveat, lack of pagination, ~10 result cap, and no API key requirement. This goes well beyond the annotations without contradicting them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Every sentence carries essential information: the action, return fields, important caveat about type, pagination limitation, and auth requirement. No filler, well front-loaded with the core purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is a search endpoint with moderate complexity; the description covers return fields, limitations, the relationship to sibling tools, and authentication. With an output schema present, return values don't need repeating, making this fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema descriptions cover all 3 parameters, but the description adds meaningful semantics for 'term' (partial/approximate, not exact match). This exceeds the baseline for high schema coverage and gives the agent the needed search behavior context.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States the exact action ('Search the Steam store by title') and clearly differentiates from siblings by noting it returns appids needed by other game tools, plus the specific fields. This is a specific verb+resource+scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides clear context for use including partial/approximate matching, pagination limits, and refining query terms. Explicitly points to an alternative (get_game) for obtaining the real type, though it does not explicitly say 'use this when you have a title but not an appid'.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

17 tool updatesv0.13.1Aug 17, 2026

Changedcompare_players1 field changed

changedInput schema / properties / other_steamid / description

Previous value: -"The other player's 17-digit SteamID64 to compare against."New value: +"The other player's 17-digit SteamID64 to compare against. Convert a vanity/custom profile name with resolve_vanity_url first."

Changeddiscover_games4 fields changed

changedInput schema / properties / count / description

Previous value: -"How many catalog entries to scan (1-200). Default 50. Raise for stricter filters."New value: +"How many catalog entries to SCAN (1-200). Default 50. Not a result count — the filters below are applied over this window, so a strict combination can return far fewer than this; raise it for stricter filters. (Tools that cap what they RETURN call that `limit`.)"

addedOutput schema / properties / matched

Added value: +{
+  "description": "How many results survived every filter, out of the scanned window (see `count`).",
+  "type": "number"
+}

changedOutput schema / properties / returned / description

Previous value: -"How many results survived every filter, out of the scanned window (see `count`)."New value: +"How many of `matched` are in `deals` below. Lower than `matched` when the result was capped for response size — narrow the filters (or page with `start`) to see the rest."

changedOutput schema / required

Previous value: -[
-  "total_matching",
-  "returned",
-  "deals"
-]New value: +[
+  "total_matching",
+  "matched",
+  "returned",
+  "deals"
+]

Changedfind_friends_who_own1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "reason": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "reason"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "matches": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "owners": {
-              "items": {
-                "additionalProperties": false,
-                "properties": {
-                  "name": {
-                    "anyOf": [
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "null"
-                      }
-                    ]
-                  },
-                  "playtime_hours": {
-                    "anyOf": [
-                      {
-                        "type": "number"
-                      },
-                      {
-                        "type": "null"
-                      }
-                    ]
-                  },
-                  "steamid": {
-                    "type": "string"
-                  }
-                },
-                "required": [
-                  "steamid",
-                  "name",
-                  "playtime_hours"
-                ],
-                "type": "object"
-              },
-              "type": "array"
-            },
-            "owners_total": {
-              "type": "number"
-            }
-          },
-          "required": [
-            "appid",
-            "owners"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "private_friends": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "name": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "steamid": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "steamid",
-            "name"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "private_friends_total": {
-        "type": "number"
-      },
-      "total_friends": {
-        "type": "number"
-      },
-      "unavailable_friends": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "name": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "reason": {
-              "type": "string"
-            },
-            "steamid": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "steamid",
-            "name",
-            "reason"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "unavailable_friends_total": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "total_friends",
-      "matches",
-      "private_friends",
-      "unavailable_friends"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "friends_checked": {
+        "description": "How many of `total_friends` were actually looked up. Lower than total_friends on a very large friend list, where checking every one would exceed an MCP client's request timeout — the unchecked friends are simply absent from all three lists below, so treat a gap here as 'not checked', never as 'doesn't own it'.",
+        "type": "number"
+      },
+      "matches": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "owners": {
+              "items": {
+                "additionalProperties": false,
+                "properties": {
+                  "name": {
+                    "anyOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ]
+                  },
+                  "playtime_hours": {
+                    "anyOf": [
+                      {
+                        "type": "number"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ]
+                  },
+                  "steamid": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "steamid",
+                  "name",
+                  "playtime_hours"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "owners_total": {
+              "type": "number"
+            }
+          },
+          "required": [
+            "appid",
+            "owners"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "private_friends": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "name": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "steamid": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "steamid",
+            "name"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "private_friends_total": {
+        "type": "number"
+      },
+      "total_friends": {
+        "type": "number"
+      },
+      "unavailable_friends": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "name": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "reason": {
+              "type": "string"
+            },
+            "steamid": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "steamid",
+            "name",
+            "reason"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "unavailable_friends_total": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "total_friends",
+      "friends_checked",
+      "matches",
+      "private_friends",
+      "unavailable_friends"
+    ],
+    "type": "object"
+  }
+]

Changedget_featured4 fields changed

addedOutput schema / properties / coming_soon / items / properties / final_price / description

Added value: +"Current price, or null when this section's payload carries no price — which is every `coming_soon` entry (not yet priced, NOT free) and any free-to-play title. Call get_game or get_items on the appid when you need to tell those two apart."

addedOutput schema / properties / new_releases / items / properties / final_price / description

Added value: +"Current price, or null when this section's payload carries no price — which is every `coming_soon` entry (not yet priced, NOT free) and any free-to-play title. Call get_game or get_items on the appid when you need to tell those two apart."

addedOutput schema / properties / specials / items / properties / final_price / description

Added value: +"Current price, or null when this section's payload carries no price — which is every `coming_soon` entry (not yet priced, NOT free) and any free-to-play title. Call get_game or get_items on the appid when you need to tell those two apart."

addedOutput schema / properties / top_sellers / items / properties / final_price / description

Added value: +"Current price, or null when this section's payload carries no price — which is every `coming_soon` entry (not yet priced, NOT free) and any free-to-play title. Call get_game or get_items on the appid when you need to tell those two apart."

Changedget_game3 fields changed

addedOutput schema / properties / dlc / description

Added value: +"Appids of this game's DLC, capped — a DLC-heavy game can list hundreds, which would dwarf every other field. Compare against dlc_total, and pass the appids to get_items for their names and prices."

addedOutput schema / properties / dlc_total

Added value: +{
+  "description": "How many DLC this game has in total, before the `dlc` cap.",
+  "type": "number"
+}

changedOutput schema / required

Previous value: -[
-  "type",
-  "short_description",
-  "is_free",
-  "price",
-  "release_date",
-  "coming_soon",
-  "developers",
-  "publishers",
-  "genres",
-  "categories",
-  "platforms",
-  "metacritic",
-  "metacritic_url",
-  "recommendations",
-  "required_age",
-  "controller_support",
-  "achievements_total",
-  "achievements_highlighted",
-  "supported_languages",
-  "dlc",
-  "demos",
-  "content_descriptors",
-  "base_game",
-  "drm_notice",
-  "account_notice",
-  "pc_requirements_min",
-  "website",
-  "header_image",
-  "store_url"
-]New value: +[
+  "type",
+  "short_description",
+  "is_free",
+  "price",
+  "release_date",
+  "coming_soon",
+  "developers",
+  "publishers",
+  "genres",
+  "categories",
+  "platforms",
+  "metacritic",
+  "metacritic_url",
+  "recommendations",
+  "required_age",
+  "controller_support",
+  "achievements_total",
+  "achievements_highlighted",
+  "supported_languages",
+  "dlc",
+  "dlc_total",
+  "demos",
+  "content_descriptors",
+  "base_game",
+  "drm_notice",
+  "account_notice",
+  "pc_requirements_min",
+  "website",
+  "header_image",
+  "store_url"
+]

Changedget_game_achievements1 field changed

addedOutput schema / properties / game / description

Added value: +"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 identifier, or get the store title from get_game."

Changedget_game_reviews2 fields changed

changedInput schema / properties / review_language / description

Previous value: -"Filter reviews by language, e.g. 'english'. Default 'all'."New value: +"Filter reviews by language. Use Steam's full language name — english, russian, schinese — NOT an ISO code like en/ru/zh: Steam answers an unrecognized value with zero reviews rather than an error, so a 9M-review game reads as having none. Default 'all'. Setting this ALSO rescopes the summary counts (total_reviews / positive / negative / %) to that language — they are no longer the game's global totals. Leave it at 'all' when you want those."

addedInput schema / properties / review_language / minLength
```
Added value: +1
```

Changedget_items3 fields changed

changedInput schema / properties / appids / description

Previous value: -"Steam appids (1-100)."New value: +"Steam appids (1-50). Split a longer list across calls."

changedInput schema / properties / appids / maxItems
```
Previous value: -100New value: +50
```

changedOutput schema / properties / items / items / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "appid": {
-        "type": "number"
-      },
-      "available": {
-        "const": false,
-        "type": "boolean"
-      }
-    },
-    "required": [
-      "appid",
-      "available"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "appid": {
-        "type": "number"
-      },
-      "coming_soon": {
-        "type": "boolean"
-      },
-      "is_free": {
-        "type": "boolean"
-      },
-      "name": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "platforms": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "price": {
-        "anyOf": [
-          {
-            "anyOf": [
-              {
-                "additionalProperties": false,
-                "properties": {
-                  "discount_end": {
-                    "anyOf": [
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "null"
-                      }
-                    ]
-                  },
-                  "discount_pct": {
-                    "type": "number"
-                  },
-                  "final": {
-                    "anyOf": [
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "null"
-                      }
-                    ]
-                  },
-                  "original": {
-                    "anyOf": [
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "null"
-                      }
-                    ]
-                  }
-                },
-                "required": [
-                  "discount_pct",
-                  "discount_end",
-                  "final",
-                  "original"
-                ],
-                "type": "object"
-              },
-              {
-                "additionalProperties": false,
-                "properties": {
-                  "is_free": {
-                    "const": true,
-                    "type": "boolean"
-                  }
-                },
-                "required": [
-                  "is_free"
-                ],
-                "type": "object"
-              }
-            ]
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "release_date": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "review_count": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "review_label": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "review_percent": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "steam_deck": {
-        "enum": [
-          "unknown",
-          "unsupported",
-          "playable",
-          "verified"
-        ],
-        "type": "string"
-      },
-      "steam_frame": {
-        "enum": [
-          "unknown",
-          "unsupported",
-          "playable",
-          "verified"
-        ],
-        "type": "string"
-      },
-      "steam_machine": {
-        "enum": [
-          "unknown",
-          "unsupported",
-          "playable",
-          "verified"
-        ],
-        "type": "string"
-      },
-      "steam_os": {
-        "enum": [
-          "unknown",
-          "unsupported",
-          "playable",
-          "verified"
-        ],
-        "type": "string"
-      },
-      "store_url": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "tags": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "vr_support": {
-        "enum": [
-          "none",
-          "supported",
-          "required"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "appid",
-      "name",
-      "store_url",
-      "review_percent",
-      "review_count",
-      "review_label",
-      "platforms",
-      "steam_deck",
-      "steam_os",
-      "steam_machine",
-      "steam_frame",
-      "vr_support",
-      "tags",
-      "release_date",
-      "is_free",
-      "price",
-      "coming_soon"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "description": "No store data for this appid: either it doesn't exist, or it isn't sold in the requested country. Never dropped from the list, so rows line up with the given appids.",
+    "properties": {
+      "appid": {
+        "type": "number"
+      },
+      "available": {
+        "const": false,
+        "type": "boolean"
+      }
+    },
+    "required": [
+      "appid",
+      "available"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "appid": {
+        "type": "number"
+      },
+      "available": {
+        "const": true,
+        "type": "boolean"
+      },
+      "coming_soon": {
+        "type": "boolean"
+      },
+      "is_free": {
+        "type": "boolean"
+      },
+      "name": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "platforms": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "price": {
+        "anyOf": [
+          {
+            "anyOf": [
+              {
+                "additionalProperties": false,
+                "properties": {
+                  "discount_end": {
+                    "anyOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ]
+                  },
+                  "discount_pct": {
+                    "type": "number"
+                  },
+                  "final": {
+                    "anyOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ]
+                  },
+                  "original": {
+                    "anyOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ]
+                  }
+                },
+                "required": [
+                  "discount_pct",
+                  "discount_end",
+                  "final",
+                  "original"
+                ],
+                "type": "object"
+              },
+              {
+                "additionalProperties": false,
+                "properties": {
+                  "is_free": {
+                    "const": true,
+                    "type": "boolean"
+                  }
+                },
+                "required": [
+                  "is_free"
+                ],
+                "type": "object"
+              }
+            ]
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "description": "null does NOT mean free: Steam returns no price block when the game isn't sold in the requested country, isn't released yet, or has no purchase option. Check is_free and coming_soon before concluding anything, and re-check under another `country`."
+      },
+      "release_date": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "review_count": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "review_label": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "review_percent": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "steam_deck": {
+        "enum": [
+          "unknown",
+          "unsupported",
+          "playable",
+          "verified"
+        ],
+        "type": "string"
+      },
+      "steam_frame": {
+        "enum": [
+          "unknown",
+          "unsupported",
+          "playable",
+          "verified"
+        ],
+        "type": "string"
+      },
+      "steam_machine": {
+        "enum": [
+          "unknown",
+          "unsupported",
+          "playable",
+          "verified"
+        ],
+        "type": "string"
+      },
+      "steam_os": {
+        "enum": [
+          "unknown",
+          "unsupported",
+          "playable",
+          "verified"
+        ],
+        "type": "string"
+      },
+      "store_url": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "tags": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "vr_support": {
+        "enum": [
+          "none",
+          "supported",
+          "required"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "appid",
+      "name",
+      "store_url",
+      "review_percent",
+      "review_count",
+      "review_label",
+      "platforms",
+      "steam_deck",
+      "steam_os",
+      "steam_machine",
+      "steam_frame",
+      "vr_support",
+      "tags",
+      "release_date",
+      "available",
+      "is_free",
+      "price",
+      "coming_soon"
+    ],
+    "type": "object"
+  }
+]

Changedget_owned_games2 fields changed

changedInput schema / properties / check_appids / description

Previous value: -"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}]."New value: +"Steam appids to check ownership of (1-50), regardless of the top-50-by-playtime cap on `games`. Adds an `owns` field: [{appid, owned, playtime_hours}]. One upstream gap to know about: Steam omits free-to-play titles the player owns but has NEVER launched, so those report owned:false. A private profile reports no `owns` at all (ownership unknown) rather than a false owned:false."

changedOutput schema / oneOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "game_count": {
-        "type": "null"
-      },
-      "games": {
-        "items": {
-          "not": {}
-        },
-        "type": "array"
-      },
-      "owns": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "owned": {
-              "const": false,
-              "type": "boolean"
-            }
-          },
-          "required": [
-            "appid",
-            "owned"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "reason": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "reason",
-      "game_count",
-      "games"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "game_count": {
-        "type": "number"
-      },
-      "games": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "name": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "playtime_2weeks_hours": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "playtime_hours": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          },
-          "required": [
-            "name",
-            "playtime_hours",
-            "playtime_2weeks_hours"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "owns": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "owned": {
-              "type": "boolean"
-            },
-            "playtime_hours": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          },
-          "required": [
-            "appid",
-            "owned",
-            "playtime_hours"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "returned": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "game_count",
-      "returned",
-      "games"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "game_count": {
+        "type": "null"
+      },
+      "games": {
+        "items": {
+          "not": {}
+        },
+        "type": "array"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason",
+      "game_count",
+      "games"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "game_count": {
+        "type": "number"
+      },
+      "games": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "name": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "playtime_2weeks_hours": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "playtime_hours": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "name",
+            "playtime_hours",
+            "playtime_2weeks_hours"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "owns": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "owned": {
+              "type": "boolean"
+            },
+            "playtime_hours": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "appid",
+            "owned",
+            "playtime_hours"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "returned": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "game_count",
+      "returned",
+      "games"
+    ],
+    "type": "object"
+  }
+]

Changedget_player_achievements1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "reason": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "reason"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "achievements": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "achieved": {
-              "type": "boolean"
-            },
-            "name": {
-              "type": "string"
-            },
-            "unlocked_at": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          },
-          "required": [
-            "achieved",
-            "unlocked_at"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "completion_pct": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "game": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "returned": {
-        "type": "number"
-      },
-      "total": {
-        "type": "number"
-      },
-      "unlocked": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "game",
-      "total",
-      "unlocked",
-      "completion_pct",
-      "returned",
-      "achievements"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "achievements": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "achieved": {
+              "type": "boolean"
+            },
+            "name": {
+              "description": "Display name, falling back to the achievement's internal api name when Valve's schema has no localized title for it.",
+              "type": "string"
+            },
+            "unlocked_at": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "achieved",
+            "unlocked_at"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "completion_pct": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "game": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "description": "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 identifier, or get the store title from get_game."
+      },
+      "returned": {
+        "type": "number"
+      },
+      "total": {
+        "type": "number"
+      },
+      "unlocked": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "game",
+      "total",
+      "unlocked",
+      "completion_pct",
+      "returned",
+      "achievements"
+    ],
+    "type": "object"
+  }
+]

Changedget_player_bans1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      }
-    },
-    "required": [
-      "found"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "community_banned": {
-        "type": "boolean"
-      },
-      "days_since_last_ban": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "economy_ban": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "game_ban_count": {
-        "type": "number"
-      },
-      "steamid": {
-        "type": "string"
-      },
-      "vac_ban_count": {
-        "type": "number"
-      },
-      "vac_banned": {
-        "type": "boolean"
-      }
-    },
-    "required": [
-      "found",
-      "vac_banned",
-      "vac_ban_count",
-      "game_ban_count",
-      "community_banned",
-      "economy_ban",
-      "days_since_last_ban"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "community_banned": {
+        "type": "boolean"
+      },
+      "days_since_last_ban": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "economy_ban": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "game_ban_count": {
+        "type": "number"
+      },
+      "steamid": {
+        "type": "string"
+      },
+      "vac_ban_count": {
+        "type": "number"
+      },
+      "vac_banned": {
+        "type": "boolean"
+      }
+    },
+    "required": [
+      "found",
+      "vac_banned",
+      "vac_ban_count",
+      "game_ban_count",
+      "community_banned",
+      "economy_ban",
+      "days_since_last_ban"
+    ],
+    "type": "object"
+  }
+]

Changedget_player_summary1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      }
-    },
-    "required": [
-      "found"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "avatar": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "country": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "created": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "in_game": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "level": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "name": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "profile_url": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "real_name": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "state": {
-        "enum": [
-          "offline",
-          "online",
-          "busy",
-          "away",
-          "snooze",
-          "looking to trade",
-          "looking to play"
-        ],
-        "type": "string"
-      },
-      "steamid": {
-        "type": "string"
-      },
-      "visibility": {
-        "enum": [
-          "public",
-          "private"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "name",
-      "real_name",
-      "state",
-      "visibility",
-      "country",
-      "level",
-      "created",
-      "in_game",
-      "profile_url",
-      "avatar"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "avatar": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "country": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "created": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "in_game": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "level": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "name": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "profile_url": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "real_name": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "state": {
+        "enum": [
+          "offline",
+          "online",
+          "busy",
+          "away",
+          "snooze",
+          "looking to trade",
+          "looking to play"
+        ],
+        "type": "string"
+      },
+      "steamid": {
+        "type": "string"
+      },
+      "visibility": {
+        "enum": [
+          "public",
+          "private"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "name",
+      "real_name",
+      "state",
+      "visibility",
+      "country",
+      "level",
+      "created",
+      "in_game",
+      "profile_url",
+      "avatar"
+    ],
+    "type": "object"
+  }
+]

Changedget_prices2 fields changed

changedInput schema / properties / appids / description

Previous value: -"Steam appids to price (1-500)."New value: +"Steam appids to price (1-250). Split a longer list across calls."

changedInput schema / properties / appids / maxItems
```
Previous value: -500New value: +250
```

Changedget_recently_played1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "games": {
-        "items": {
-          "not": {}
-        },
-        "type": "array"
-      },
-      "reason": {
-        "type": "string"
-      },
-      "total": {
-        "const": 0,
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "reason",
-      "total",
-      "games"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "games": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "name": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "playtime_2weeks_hours": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "playtime_hours": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          },
-          "required": [
-            "name",
-            "playtime_hours",
-            "playtime_2weeks_hours"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "total": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "total",
-      "games"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "games": {
+        "items": {
+          "not": {}
+        },
+        "type": "array"
+      },
+      "reason": {
+        "type": "string"
+      },
+      "total": {
+        "const": 0,
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "reason",
+      "total",
+      "games"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "games": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "name": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "playtime_2weeks_hours": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "playtime_hours": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "name",
+            "playtime_hours",
+            "playtime_2weeks_hours"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "returned": {
+        "type": "number"
+      },
+      "total": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "total",
+      "returned",
+      "games"
+    ],
+    "type": "object"
+  }
+]

Changedget_recommended_games3 fields changed

removedInput schema / properties / count

Removed value: -{
-  "default": 10,
-  "description": "How many recommendations to return (1-25). Default 10.",
-  "exclusiveMinimum": 0,
-  "maximum": 25,
-  "type": "integer"
-}

addedInput schema / properties / limit

Added value: +{
+  "default": 10,
+  "description": "How many recommendations to return (1-25). Default 10.",
+  "exclusiveMinimum": 0,
+  "maximum": 25,
+  "type": "integer"
+}

changedInput schema / properties / min_discount / description

Previous value: -"Minimum discount %, e.g. 30 for '30%+ off'. Omit to include full-price games too."New value: +"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."

Changedget_specials1 field changed

addedOutput schema / properties / specials / items / properties / final_price / description

Added value: +"Current price, or null when this section's payload carries no price — which is every `coming_soon` entry (not yet priced, NOT free) and any free-to-play title. Call get_game or get_items on the appid when you need to tell those two apart."

Changedget_wishlist2 fields changed

changedInput schema / properties / country / description

Previous value: -"Country (cc) for prices; overrides STEAM_COUNTRY. Only meaningful for store cards, so setting it implies include_details — the light appid list carries no price."New value: +"Country (cc) for prices; overrides STEAM_COUNTRY. Implies include_details."

changedInput schema / properties / language / description

Previous value: -"Store language; overrides STEAM_LANGUAGE. Only meaningful for store cards, so setting it implies include_details — the light appid list carries no price."New value: +"Store language; overrides STEAM_LANGUAGE. Implies include_details."

25 tool updatesv0.12.1Jul 30, 2026

Changedcompare_players3 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```

removedOutput schema / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "reason": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "reason"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "games": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "name": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "playtime_hours_a": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "playtime_hours_b": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          },
-          "required": [
-            "name",
-            "playtime_hours_a",
-            "playtime_hours_b"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "returned": {
-        "type": "number"
-      },
-      "shared_count": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "shared_count",
-      "returned",
-      "games"
-    ],
-    "type": "object"
-  }
-]

addedOutput schema / oneOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "games": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "name": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "playtime_hours_a": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "playtime_hours_b": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "name",
+            "playtime_hours_a",
+            "playtime_hours_b"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "returned": {
+        "type": "number"
+      },
+      "shared_count": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "shared_count",
+      "returned",
+      "games"
+    ],
+    "type": "object"
+  }
+]

Changeddiscover_games12 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```
addedInput schema / properties / count / default
```
Added value: +50
```

changedInput schema / properties / count / description

Previous value: -"How many catalog entries to scan (default 50). Raise for stricter filters."New value: +"How many catalog entries to scan (1-200). Default 50. Raise for stricter filters."

addedInput schema / properties / count / exclusiveMinimum
```
Added value: +0
```
removedInput schema / properties / count / minimum
```
Removed value: -1
```
addedInput schema / properties / min_discount / exclusiveMinimum
```
Added value: +0
```
removedInput schema / properties / min_discount / minimum
```
Removed value: -1
```
addedInput schema / properties / released_within_days / exclusiveMinimum
```
Added value: +0
```
removedInput schema / properties / released_within_days / minimum
```
Removed value: -1
```
addedInput schema / properties / start / default
```
Added value: +0
```

changedInput schema / properties / start / description

Previous value: -"Pagination offset into the catalog."New value: +"Pagination offset into the catalog (default 0)."

changedInput schema / properties / tags / description

Previous value: -"Keep only games carrying ALL of these user tags (case-insensitive), e.g. ['Roguelike','Deckbuilding']. Use exact Steam tag names. Applied over the scanned popularity window, so raise `count` when combining niche tags."New value: +"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 nothing. Applied over the scanned popularity window, so raise `count` when combining niche tags."

Changedfind_friends_who_own3 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```

removedOutput schema / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "reason": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "reason"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "matches": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "owners": {
-              "items": {
-                "additionalProperties": false,
-                "properties": {
-                  "name": {
-                    "anyOf": [
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "null"
-                      }
-                    ]
-                  },
-                  "playtime_hours": {
-                    "anyOf": [
-                      {
-                        "type": "number"
-                      },
-                      {
-                        "type": "null"
-                      }
-                    ]
-                  },
-                  "steamid": {
-                    "type": "string"
-                  }
-                },
-                "required": [
-                  "steamid",
-                  "name",
-                  "playtime_hours"
-                ],
-                "type": "object"
-              },
-              "type": "array"
-            },
-            "owners_total": {
-              "type": "number"
-            }
-          },
-          "required": [
-            "appid",
-            "owners"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "private_friends": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "name": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "steamid": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "steamid",
-            "name"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "private_friends_total": {
-        "type": "number"
-      },
-      "total_friends": {
-        "type": "number"
-      },
-      "unavailable_friends": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "name": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "reason": {
-              "type": "string"
-            },
-            "steamid": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "steamid",
-            "name",
-            "reason"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "unavailable_friends_total": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "total_friends",
-      "matches",
-      "private_friends",
-      "unavailable_friends"
-    ],
-    "type": "object"
-  }
-]

addedOutput schema / oneOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "matches": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "owners": {
+              "items": {
+                "additionalProperties": false,
+                "properties": {
+                  "name": {
+                    "anyOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ]
+                  },
+                  "playtime_hours": {
+                    "anyOf": [
+                      {
+                        "type": "number"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ]
+                  },
+                  "steamid": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "steamid",
+                  "name",
+                  "playtime_hours"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "owners_total": {
+              "type": "number"
+            }
+          },
+          "required": [
+            "appid",
+            "owners"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "private_friends": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "name": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "steamid": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "steamid",
+            "name"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "private_friends_total": {
+        "type": "number"
+      },
+      "total_friends": {
+        "type": "number"
+      },
+      "unavailable_friends": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "name": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "reason": {
+              "type": "string"
+            },
+            "steamid": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "steamid",
+            "name",
+            "reason"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "unavailable_friends_total": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "total_friends",
+      "matches",
+      "private_friends",
+      "unavailable_friends"
+    ],
+    "type": "object"
+  }
+]

Changedget_current_players1 field changed
- addedInput schema / additionalProperties
```
Added value: +false
```
Changedget_featured1 field changed
- addedInput schema / additionalProperties
```
Added value: +false
```

Changedget_followed_games3 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```

removedOutput schema / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "games": {
-        "items": {
-          "not": {}
-        },
-        "type": "array"
-      },
-      "reason": {
-        "type": "string"
-      },
-      "total": {
-        "const": 0,
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "reason",
-      "total",
-      "games"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "games": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "store_url": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          },
-          "required": [
-            "appid",
-            "store_url"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "returned": {
-        "type": "number"
-      },
-      "total": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "total",
-      "returned",
-      "games"
-    ],
-    "type": "object"
-  }
-]

addedOutput schema / oneOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "games": {
+        "items": {
+          "not": {}
+        },
+        "type": "array"
+      },
+      "reason": {
+        "type": "string"
+      },
+      "total": {
+        "const": 0,
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "reason",
+      "total",
+      "games"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "games": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "store_url": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "appid",
+            "store_url"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "returned": {
+        "type": "number"
+      },
+      "total": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "total",
+      "returned",
+      "games"
+    ],
+    "type": "object"
+  }
+]

Changedget_friend_list3 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```

removedOutput schema / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "reason": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "reason"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "friends": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "friends_since": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "in_game": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "name": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "profile_url": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "state": {
-              "type": "string"
-            },
-            "steamid": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "name",
-            "state",
-            "in_game",
-            "profile_url",
-            "friends_since"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "returned": {
-        "type": "number"
-      },
-      "total": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "total",
-      "returned",
-      "friends"
-    ],
-    "type": "object"
-  }
-]

addedOutput schema / oneOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "friends": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "friends_since": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "in_game": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "name": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "profile_url": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "state": {
+              "enum": [
+                "offline",
+                "online",
+                "busy",
+                "away",
+                "snooze",
+                "looking to trade",
+                "looking to play"
+              ],
+              "type": "string"
+            },
+            "steamid": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "name",
+            "state",
+            "in_game",
+            "profile_url",
+            "friends_since"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "returned": {
+        "type": "number"
+      },
+      "total": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "total",
+      "returned",
+      "friends"
+    ],
+    "type": "object"
+  }
+]

Changedget_game3 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```

addedOutput schema / properties / achievements_highlighted / description

Added value: +"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."

changedOutput schema / properties / price / anyOf

Previous value: -[
-  {
-    "anyOf": [
-      {
-        "additionalProperties": false,
-        "properties": {
-          "is_free": {
-            "const": true,
-            "type": "boolean"
-          }
-        },
-        "required": [
-          "is_free"
-        ],
-        "type": "object"
-      },
-      {
-        "additionalProperties": false,
-        "properties": {
-          "currency": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ]
-          },
-          "discount_percent": {
-            "type": "number"
-          },
-          "final": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ]
-          },
-          "initial": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ]
-          },
-          "is_free": {
-            "const": false,
-            "type": "boolean"
-          }
-        },
-        "required": [
-          "currency",
-          "final",
-          "initial",
-          "discount_percent",
-          "is_free"
-        ],
-        "type": "object"
-      }
-    ]
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "oneOf": [
+      {
+        "additionalProperties": false,
+        "properties": {
+          "is_free": {
+            "const": true,
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "is_free"
+        ],
+        "type": "object"
+      },
+      {
+        "additionalProperties": false,
+        "properties": {
+          "currency": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "discount_percent": {
+            "type": "number"
+          },
+          "final": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "initial": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "is_free": {
+            "const": false,
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "currency",
+          "final",
+          "initial",
+          "discount_percent",
+          "is_free"
+        ],
+        "type": "object"
+      }
+    ]
+  },
+  {
+    "type": "null"
+  }
+]

Changedget_game_achievements1 field changed
- addedInput schema / additionalProperties
```
Added value: +false
```
Changedget_game_news4 fields changed
- addedInput schema / additionalProperties
```
Added value: +false
```
- addedInput schema / properties / limit / default
```
Added value: +5
```
- addedInput schema / properties / limit / exclusiveMinimum
```
Added value: +0
```
- removedInput schema / properties / limit / minimum
```
Removed value: -1
```
Changedget_game_reviews6 fields changed
- addedInput schema / additionalProperties
```
Added value: +false
```
- addedInput schema / properties / limit / default
```
Added value: +5
```
- addedInput schema / properties / limit / exclusiveMinimum
```
Added value: +0
```
- removedInput schema / properties / limit / minimum
```
Removed value: -1
```
- addedInput schema / properties / review_language / default
```
Added value: +"all"
```
- addedInput schema / properties / type / default
```
Added value: +"all"
```
Changedget_global_achievements1 field changed
- addedInput schema / additionalProperties
```
Added value: +false
```
Changedget_items1 field changed
- addedInput schema / additionalProperties
```
Added value: +false
```

Changedget_owned_games3 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```

removedOutput schema / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "game_count": {
-        "type": "null"
-      },
-      "games": {
-        "items": {
-          "not": {}
-        },
-        "type": "array"
-      },
-      "owns": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "owned": {
-              "const": false,
-              "type": "boolean"
-            }
-          },
-          "required": [
-            "appid",
-            "owned"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "reason": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "reason",
-      "game_count",
-      "games"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "game_count": {
-        "type": "number"
-      },
-      "games": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "name": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "playtime_2weeks_hours": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "playtime_hours": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          },
-          "required": [
-            "name",
-            "playtime_hours",
-            "playtime_2weeks_hours"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "owns": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "owned": {
-              "type": "boolean"
-            },
-            "playtime_hours": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          },
-          "required": [
-            "appid",
-            "owned",
-            "playtime_hours"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "returned": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "game_count",
-      "returned",
-      "games"
-    ],
-    "type": "object"
-  }
-]

addedOutput schema / oneOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "game_count": {
+        "type": "null"
+      },
+      "games": {
+        "items": {
+          "not": {}
+        },
+        "type": "array"
+      },
+      "owns": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "owned": {
+              "const": false,
+              "type": "boolean"
+            }
+          },
+          "required": [
+            "appid",
+            "owned"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason",
+      "game_count",
+      "games"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "game_count": {
+        "type": "number"
+      },
+      "games": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "name": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "playtime_2weeks_hours": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "playtime_hours": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "name",
+            "playtime_hours",
+            "playtime_2weeks_hours"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "owns": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "owned": {
+              "type": "boolean"
+            },
+            "playtime_hours": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "appid",
+            "owned",
+            "playtime_hours"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "returned": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "game_count",
+      "returned",
+      "games"
+    ],
+    "type": "object"
+  }
+]

Changedget_player_achievements3 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```

removedOutput schema / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "reason": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "reason"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "achievements": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "achieved": {
-              "type": "boolean"
-            },
-            "name": {
-              "type": "string"
-            },
-            "unlocked_at": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          },
-          "required": [
-            "achieved",
-            "unlocked_at"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "completion_pct": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "game": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "returned": {
-        "type": "number"
-      },
-      "total": {
-        "type": "number"
-      },
-      "unlocked": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "game",
-      "total",
-      "unlocked",
-      "completion_pct",
-      "returned",
-      "achievements"
-    ],
-    "type": "object"
-  }
-]

addedOutput schema / oneOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "achievements": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "achieved": {
+              "type": "boolean"
+            },
+            "name": {
+              "type": "string"
+            },
+            "unlocked_at": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "achieved",
+            "unlocked_at"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "completion_pct": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "game": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "returned": {
+        "type": "number"
+      },
+      "total": {
+        "type": "number"
+      },
+      "unlocked": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "game",
+      "total",
+      "unlocked",
+      "completion_pct",
+      "returned",
+      "achievements"
+    ],
+    "type": "object"
+  }
+]

Changedget_player_bans3 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```

removedOutput schema / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      }
-    },
-    "required": [
-      "found"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "community_banned": {
-        "type": "boolean"
-      },
-      "days_since_last_ban": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "economy_ban": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "game_ban_count": {
-        "type": "number"
-      },
-      "steamid": {
-        "type": "string"
-      },
-      "vac_ban_count": {
-        "type": "number"
-      },
-      "vac_banned": {
-        "type": "boolean"
-      }
-    },
-    "required": [
-      "found",
-      "vac_banned",
-      "vac_ban_count",
-      "game_ban_count",
-      "community_banned",
-      "economy_ban",
-      "days_since_last_ban"
-    ],
-    "type": "object"
-  }
-]

addedOutput schema / oneOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      }
+    },
+    "required": [
+      "found"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "community_banned": {
+        "type": "boolean"
+      },
+      "days_since_last_ban": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "economy_ban": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "game_ban_count": {
+        "type": "number"
+      },
+      "steamid": {
+        "type": "string"
+      },
+      "vac_ban_count": {
+        "type": "number"
+      },
+      "vac_banned": {
+        "type": "boolean"
+      }
+    },
+    "required": [
+      "found",
+      "vac_banned",
+      "vac_ban_count",
+      "game_ban_count",
+      "community_banned",
+      "economy_ban",
+      "days_since_last_ban"
+    ],
+    "type": "object"
+  }
+]

Changedget_player_summary3 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```

removedOutput schema / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      }
-    },
-    "required": [
-      "found"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "avatar": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "country": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "created": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "in_game": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "level": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "name": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "profile_url": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "real_name": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "state": {
-        "type": "string"
-      },
-      "steamid": {
-        "type": "string"
-      },
-      "visibility": {
-        "enum": [
-          "public",
-          "private"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "name",
-      "real_name",
-      "state",
-      "visibility",
-      "country",
-      "level",
-      "created",
-      "in_game",
-      "profile_url",
-      "avatar"
-    ],
-    "type": "object"
-  }
-]

addedOutput schema / oneOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      }
+    },
+    "required": [
+      "found"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "avatar": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "country": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "created": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "in_game": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "level": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "name": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "profile_url": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "real_name": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "state": {
+        "enum": [
+          "offline",
+          "online",
+          "busy",
+          "away",
+          "snooze",
+          "looking to trade",
+          "looking to play"
+        ],
+        "type": "string"
+      },
+      "steamid": {
+        "type": "string"
+      },
+      "visibility": {
+        "enum": [
+          "public",
+          "private"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "name",
+      "real_name",
+      "state",
+      "visibility",
+      "country",
+      "level",
+      "created",
+      "in_game",
+      "profile_url",
+      "avatar"
+    ],
+    "type": "object"
+  }
+]

Changedget_prices1 field changed
- addedInput schema / additionalProperties
```
Added value: +false
```

Changedget_recently_played3 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```

removedOutput schema / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "games": {
-        "items": {
-          "not": {}
-        },
-        "type": "array"
-      },
-      "reason": {
-        "type": "string"
-      },
-      "total": {
-        "const": 0,
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "reason",
-      "total",
-      "games"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "games": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "name": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "playtime_2weeks_hours": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "playtime_hours": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          },
-          "required": [
-            "name",
-            "playtime_hours",
-            "playtime_2weeks_hours"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "total": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "total",
-      "games"
-    ],
-    "type": "object"
-  }
-]

addedOutput schema / oneOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "games": {
+        "items": {
+          "not": {}
+        },
+        "type": "array"
+      },
+      "reason": {
+        "type": "string"
+      },
+      "total": {
+        "const": 0,
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "reason",
+      "total",
+      "games"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "games": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "name": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "playtime_2weeks_hours": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "playtime_hours": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "name",
+            "playtime_hours",
+            "playtime_2weeks_hours"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "total": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "total",
+      "games"
+    ],
+    "type": "object"
+  }
+]

Changedget_recommended_games10 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```
addedInput schema / properties / count / default
```
Added value: +10
```

changedInput schema / properties / count / description

Previous value: -"How many recommendations to return (default 10)."New value: +"How many recommendations to return (1-25). Default 10."

addedInput schema / properties / count / exclusiveMinimum
```
Added value: +0
```
removedInput schema / properties / count / minimum
```
Removed value: -1
```

changedInput schema / properties / exclude_tags / description

Previous value: -"Drop any candidate carrying ANY of these tags (case-insensitive), e.g. ['Souls-like'] for 'recommend me something except Souls-like'."New value: +"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 an error, it just drops nothing."

addedInput schema / properties / min_discount / exclusiveMinimum
```
Added value: +0
```
removedInput schema / properties / min_discount / minimum
```
Removed value: -1
```

removedOutput schema / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "reason": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "reason"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "based_on_tags": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "count": {
-        "type": "number"
-      },
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "recommendations": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "appid": {
-              "type": "number"
-            },
-            "discount_end": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "discount_pct": {
-              "type": "number"
-            },
-            "match_score": {
-              "description": "An internal ranking weight (playtime-on-matched-tags, discounted by review score) — not a percentage or 0-100 scale. Only meaningful relative to the other scores in this same response, to explain why one pick outranks another.",
-              "type": "number"
-            },
-            "matched_tags": {
-              "items": {
-                "type": "string"
-              },
-              "type": "array"
-            },
-            "name": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "original": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "platforms": {
-              "items": {
-                "type": "string"
-              },
-              "type": "array"
-            },
-            "price": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "release_date": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "review_count": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "review_label": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "review_percent": {
-              "anyOf": [
-                {
-                  "type": "number"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "steam_deck": {
-              "enum": [
-                "unknown",
-                "unsupported",
-                "playable",
-                "verified"
-              ],
-              "type": "string"
-            },
-            "steam_frame": {
-              "enum": [
-                "unknown",
-                "unsupported",
-                "playable",
-                "verified"
-              ],
-              "type": "string"
-            },
-            "steam_machine": {
-              "enum": [
-                "unknown",
-                "unsupported",
-                "playable",
-                "verified"
-              ],
-              "type": "string"
-            },
-            "steam_os": {
-              "enum": [
-                "unknown",
-                "unsupported",
-                "playable",
-                "verified"
-              ],
-              "type": "string"
-            },
-            "store_url": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "tags": {
-              "items": {
-                "type": "string"
-              },
-              "type": "array"
-            },
-            "vr_support": {
-              "enum": [
-                "none",
-                "supported",
-                "required"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "appid",
-            "name",
-            "store_url",
-            "review_percent",
-            "review_count",
-            "review_label",
-            "platforms",
-            "steam_deck",
-            "steam_os",
-            "steam_machine",
-            "steam_frame",
-            "vr_support",
-            "tags",
-            "release_date",
-            "discount_pct",
-            "discount_end",
-            "original",
-            "price",
-            "matched_tags",
-            "match_score"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      }
-    },
-    "required": [
-      "found",
-      "based_on_tags",
-      "count",
-      "recommendations"
-    ],
-    "type": "object"
-  }
-]

addedOutput schema / oneOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "based_on_tags": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "count": {
+        "type": "number"
+      },
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "recommendations": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "appid": {
+              "type": "number"
+            },
+            "discount_end": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "discount_pct": {
+              "type": "number"
+            },
+            "match_score": {
+              "description": "An internal ranking weight (playtime-on-matched-tags, discounted by review score) — not a percentage or 0-100 scale. Only meaningful relative to the other scores in this same response, to explain why one pick outranks another.",
+              "type": "number"
+            },
+            "matched_tags": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "name": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "original": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "platforms": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "price": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "release_date": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "review_count": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "review_label": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "review_percent": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "steam_deck": {
+              "enum": [
+                "unknown",
+                "unsupported",
+                "playable",
+                "verified"
+              ],
+              "type": "string"
+            },
+            "steam_frame": {
+              "enum": [
+                "unknown",
+                "unsupported",
+                "playable",
+                "verified"
+              ],
+              "type": "string"
+            },
+            "steam_machine": {
+              "enum": [
+                "unknown",
+                "unsupported",
+                "playable",
+                "verified"
+              ],
+              "type": "string"
+            },
+            "steam_os": {
+              "enum": [
+                "unknown",
+                "unsupported",
+                "playable",
+                "verified"
+              ],
+              "type": "string"
+            },
+            "store_url": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "tags": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "vr_support": {
+              "enum": [
+                "none",
+                "supported",
+                "required"
+              ],
+              "type": "string"
+            }
+          },
+          "required": [
+            "appid",
+            "name",
+            "store_url",
+            "review_percent",
+            "review_count",
+            "review_label",
+            "platforms",
+            "steam_deck",
+            "steam_os",
+            "steam_machine",
+            "steam_frame",
+            "vr_support",
+            "tags",
+            "release_date",
+            "discount_pct",
+            "discount_end",
+            "original",
+            "price",
+            "matched_tags",
+            "match_score"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      }
+    },
+    "required": [
+      "found",
+      "based_on_tags",
+      "count",
+      "recommendations"
+    ],
+    "type": "object"
+  }
+]

Changedget_review_histogram1 field changed
- addedInput schema / additionalProperties
```
Added value: +false
```
Changedget_specials1 field changed
- addedInput schema / additionalProperties
```
Added value: +false
```

Changedget_wishlist4 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```
addedInput schema / properties / min_discount / exclusiveMinimum
```
Added value: +0
```
removedInput schema / properties / min_discount / minimum
```
Removed value: -1
```

changedInput schema / properties / tags / description

Previous value: -"Keep only wishlist items carrying ALL of these user tags (case-insensitive), e.g. ['Metroidvania']. Implies include_details."New value: +"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. Implies include_details."

Changedresolve_vanity_url3 fields changed

addedInput schema / additionalProperties
```
Added value: +false
```

removedOutput schema / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "reason": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "reason"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "steamid": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "steamid"
-    ],
-    "type": "object"
-  }
-]

addedOutput schema / oneOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "steamid": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "steamid"
+    ],
+    "type": "object"
+  }
+]

Changedsearch_games1 field changed
- addedInput schema / additionalProperties
```
Added value: +false
```

4 tool updatesv0.10.5Jul 28, 2026
- Addedget_friend_list
- Addedget_owned_games
- Addedget_specials
- Addedresolve_vanity_url
9 tool updatesv0.10.4Jul 26, 2026
- Addeddiscover_games
- Addedfind_friends_who_own
- Addedget_featured
- Addedget_followed_games
- Removedget_friend_list
- Removedget_owned_games
- Addedget_prices
- Addedget_review_histogram
- Removedget_specials

13 tool updatesv0.10.4Jul 26, 2026

Removedfind_friends_who_own
Addedget_game

Changedget_game_achievements2 fields changed

addedOutput schema / properties / returned
```
Added value: +{
+  "type": "number"
+}
```

changedOutput schema / required

Previous value: -[
-  "game",
-  "total",
-  "achievements"
-]New value: +[
+  "game",
+  "total",
+  "returned",
+  "achievements"
+]

Addedget_game_news
Addedget_global_achievements
Addedget_items
Addedget_owned_games

Changedget_player_achievements1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "found": {
-        "const": false,
-        "type": "boolean"
-      },
-      "reason": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "found",
-      "reason"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "achievements": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "achieved": {
-              "type": "boolean"
-            },
-            "name": {
-              "type": "string"
-            },
-            "unlocked_at": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          },
-          "required": [
-            "achieved",
-            "unlocked_at"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "completion_pct": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "found": {
-        "const": true,
-        "type": "boolean"
-      },
-      "game": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "total": {
-        "type": "number"
-      },
-      "unlocked": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "found",
-      "game",
-      "total",
-      "unlocked",
-      "completion_pct",
-      "achievements"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "found": {
+        "const": false,
+        "type": "boolean"
+      },
+      "reason": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "found",
+      "reason"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "achievements": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "achieved": {
+              "type": "boolean"
+            },
+            "name": {
+              "type": "string"
+            },
+            "unlocked_at": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "achieved",
+            "unlocked_at"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "completion_pct": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "found": {
+        "const": true,
+        "type": "boolean"
+      },
+      "game": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "returned": {
+        "type": "number"
+      },
+      "total": {
+        "type": "number"
+      },
+      "unlocked": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "found",
+      "game",
+      "total",
+      "unlocked",
+      "completion_pct",
+      "returned",
+      "achievements"
+    ],
+    "type": "object"
+  }
+]

Removedget_prices
Addedget_recommended_games
Addedget_specials
Addedget_wishlist
Removedresolve_vanity_url

12 tool updatesv0.10.2Jul 22, 2026
- Addedcompare_players
- Removeddiscover_games
- Addedfind_friends_who_own
- Removedget_featured
- Removedget_followed_games
- Addedget_game_achievements
- Addedget_game_reviews
- Removedget_items
- Addedget_player_achievements
- Removedget_recommended_games
- Removedget_wishlist
- Addedsearch_games

13 tool updatesv0.10.2Jul 22, 2026

Changeddiscover_games2 fields changed

changedInput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false,
+  "properties": {
+    "deals": {
+      "items": {
+        "additionalProperties": false,
+        "properties": {
+          "appid": {
+            "type": "number"
+          },
+          "discount_end": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "discount_pct": {
+            "type": "number"
+          },
+          "name": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "original": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "platforms": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "price": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "release_date": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "review_count": {
+            "anyOf": [
+              {
+                "type": "number"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "review_label": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "review_percent": {
+            "anyOf": [
+              {
+                "type": "number"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "steam_deck": {
+            "enum": [
+              "unknown",
+              "unsupported",
+              "playable",
+              "verified"
+            ],
+            "type": "string"
+          },
+          "steam_frame": {
+            "enum": [
+              "unknown",
+              "unsupported",
+              "playable",
+              "verified"
+            ],
+            "type": "string"
+          },
+          "steam_machine": {
+            "enum": [
+              "unknown",
+              "unsupported",
+              "playable",
+              "verified"
+            ],
+            "type": "string"
+          },
+          "steam_os": {
+            "enum": [
+              "unknown",
+              "unsupported",
+              "playable",
+              "verified"
+            ],
+            "type": "string"
+          },
+          "store_url": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "tags": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "vr_support": {
+            "enum": [
+              "none",
+              "supported",
+              "required"
+            ],
+            "type": "string"
+          }
+        },
+        "required": [
+          "appid",
+          "name",
+          "store_url",
+          "review_percent",
+          "review_count",
+          "review_label",
+          "platforms",
+          "steam_deck",
+          "steam_os",
+          "steam_machine",
+          "steam_frame",
+          "vr_support",
+          "tags",
+          "release_date",
+          "discount_pct",
+          "discount_end",
+          "original",
+          "price"
+        ],
+        "type": "object"
+      },
+      "type": "array"
+    },
+    "returned": {
+      "description": "How many results survived every filter, out of the scanned window (see `count`).",
+      "type": "number"
+    },
+    "total_matching": {
+      "anyOf": [
+        {
+          "type": "number"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "description": "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 neither was given. NOT the number of games matching tags/platform/compat/review/the exact release-date cutoff, which have no server-side filter and this tool applies only over the scanned `count`-sized window below. Don't read this as 'N games match all my filters' — use `returned` for that instead."
+    }
+  },
+  "required": [
+    "total_matching",
+    "returned",
+    "deals"
+  ],
+  "type": "object"
+}

Addedget_current_players
Addedget_featured
Addedget_followed_games
Addedget_friend_list
Addedget_items
Addedget_player_bans
Addedget_player_summary
Addedget_prices
Addedget_recently_played
Addedget_recommended_games
Addedget_wishlist
Addedresolve_vanity_url

13 tool updatesv0.9.0Jul 18, 2026
- Addeddiscover_games
- Removedget_featured
- Removedget_friend_list
- Removedget_game
- Removedget_game_news
- Removedget_game_reviews
- Removedget_global_achievements
- Removedget_prices
- Removedget_recently_played
- Removedget_review_histogram
- Removedget_specials
- Removedresolve_vanity_url
- Removedsearch_games
4 tool updatesv0.8.1Jul 18, 2026
- Removedcompare_players
- Addedget_friend_list
- Removedget_items
- Addedresolve_vanity_url
8 tool updatesv0.8.0Jul 17, 2026
- Addedcompare_players
- Removeddiscover_games
- Removedget_current_players
- Addedget_game
- Addedget_game_reviews
- Addedget_recently_played
- Addedget_review_histogram
- Addedsearch_games
15 tool updatesv0.8.0Jul 17, 2026
- Removedfind_friends_who_own
- Removedget_followed_games
- Removedget_friend_list
- Removedget_game
- Removedget_game_achievements
- Removedget_game_reviews
- Removedget_owned_games
- Removedget_player_achievements
- Removedget_player_bans
- Removedget_player_summary
- Removedget_recently_played
- Removedget_review_histogram
- Removedget_wishlist
- Removedresolve_vanity_url
- Removedsearch_games

4 tool updatesv0.7.0Jul 16, 2026

Changeddiscover_games2 fields changed

addedInput schema / properties / steam_machine

Added value: +{
+  "description": "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.",
+  "enum": [
+    "playable",
+    "verified"
+  ],
+  "type": "string"
+}

changedInput schema / properties / steam_os / description

Previous value: -"SteamOS compatibility — how well it runs on SteamOS / the Steam Machine (via Proton): 'verified' = SteamOS-Verified only; 'playable' = Playable or Verified. For a NATIVE Linux build instead, use platform:'linux'."New value: +"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:'linux'; for the Steam Machine console specifically, use steam_machine."

Addedget_followed_games
Addedget_player_bans

Changedget_wishlist2 fields changed

addedInput schema / properties / steam_machine

Added value: +{
+  "description": "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.",
+  "enum": [
+    "playable",
+    "verified"
+  ],
+  "type": "string"
+}

changedInput schema / properties / steam_os / description

Previous value: -"SteamOS compatibility — how well it runs on SteamOS / the Steam Machine (via Proton): 'verified' = SteamOS-Verified only; 'playable' = Playable or Verified. For a NATIVE Linux build instead, use platform:'linux'."New value: +"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:'linux'; for the Steam Machine console specifically, use steam_machine."

2 tool updatesv0.6.0Jul 13, 2026
- Addedfind_friends_who_own
- Addedget_friend_list

3 tool updatesv0.5.0Jul 9, 2026

Changeddiscover_games7 fields changed

changedInput schema / properties / country / description

Previous value: -"Country (cc) for prices; overrides STEAM_COUNTRY."New value: +"Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call."

changedInput schema / properties / language / description

Previous value: -"Store language; overrides STEAM_LANGUAGE."New value: +"Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call."

addedInput schema / properties / platform

Added value: +{
+  "description": "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 use steam_os / steam_deck instead. Each result's `platforms` field lists its native builds, while steam_os/steam_deck report Proton compatibility, so native vs Proton stay distinct.",
+  "enum": [
+    "windows",
+    "mac",
+    "linux"
+  ],
+  "type": "string"
+}

changedInput schema / properties / steam_deck / description

Previous value: -"Keep only Deck-capable games: 'verified' = Deck-Verified only; 'playable' = Playable or Verified."New value: +"Steam Deck compatibility (runs via Proton): 'verified' = Deck-Verified only; 'playable' = Playable or Verified. Not a native Linux build — see `platform` for that."

addedInput schema / properties / steam_frame

Added value: +{
+  "description": "Steam Frame (VR headset) compatibility: 'verified' = Frame-Verified only; 'playable' = Playable or Verified.",
+  "enum": [
+    "playable",
+    "verified"
+  ],
+  "type": "string"
+}

addedInput schema / properties / steam_os

Added value: +{
+  "description": "SteamOS compatibility — how well it runs on SteamOS / the Steam Machine (via Proton): 'verified' = SteamOS-Verified only; 'playable' = Playable or Verified. For a NATIVE Linux build instead, use platform:'linux'.",
+  "enum": [
+    "playable",
+    "verified"
+  ],
+  "type": "string"
+}

addedInput schema / properties / tags

Added value: +{
+  "description": "Keep only games carrying ALL of these user tags (case-insensitive), e.g. ['Roguelike','Deckbuilding']. Use exact Steam tag names. Applied over the scanned popularity window, so raise `count` when combining niche tags.",
+  "items": {
+    "minLength": 1,
+    "type": "string"
+  },
+  "minItems": 1,
+  "type": "array"
+}

Changedget_items2 fields changed

changedInput schema / properties / country / description

Previous value: -"Country (cc) for prices; overrides STEAM_COUNTRY."New value: +"Country (cc) for prices/currency; overrides STEAM_COUNTRY for this call."

changedInput schema / properties / language / description

Previous value: -"Store language; overrides STEAM_LANGUAGE."New value: +"Store language (e.g. english, russian); overrides STEAM_LANGUAGE for this call."

Changedget_wishlist11 fields changed

addedInput schema / properties / country

Added value: +{
+  "description": "Country (cc) for prices; overrides STEAM_COUNTRY. Only meaningful for store cards, so setting it implies include_details — the light appid list carries no price.",
+  "pattern": "^[A-Za-z]{2}$",
+  "type": "string"
+}

addedInput schema / properties / include_details

Added value: +{
+  "description": "Return full store cards (name, price, discount, reviews, compatibility, tags) per item in one call, instead of just appids. Implied by any filter below.",
+  "type": "boolean"
+}

addedInput schema / properties / language

Added value: +{
+  "description": "Store language; overrides STEAM_LANGUAGE. Only meaningful for store cards, so setting it implies include_details — the light appid list carries no price.",
+  "minLength": 2,
+  "type": "string"
+}

addedInput schema / properties / min_discount

Added value: +{
+  "description": "Keep only items discounted at least this %, ranked by discount. Implies include_details.",
+  "maximum": 100,
+  "minimum": 1,
+  "type": "integer"
+}

addedInput schema / properties / min_review

Added value: +{
+  "description": "Keep only items with at least this positive-review %. Implies include_details.",
+  "maximum": 100,
+  "minimum": 0,
+  "type": "integer"
+}

addedInput schema / properties / on_sale_only

Added value: +{
+  "description": "Only wishlist items currently discounted, ranked by discount %. Implies include_details.",
+  "type": "boolean"
+}

addedInput schema / properties / platform

Added value: +{
+  "description": "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 use steam_os / steam_deck instead. Each result's `platforms` field lists its native builds, while steam_os/steam_deck report Proton compatibility, so native vs Proton stay distinct.",
+  "enum": [
+    "windows",
+    "mac",
+    "linux"
+  ],
+  "type": "string"
+}

addedInput schema / properties / steam_deck

Added value: +{
+  "description": "Steam Deck compatibility (runs via Proton): 'verified' = Deck-Verified only; 'playable' = Playable or Verified. Not a native Linux build — see `platform` for that.",
+  "enum": [
+    "playable",
+    "verified"
+  ],
+  "type": "string"
+}

addedInput schema / properties / steam_frame

Added value: +{
+  "description": "Steam Frame (VR headset) compatibility: 'verified' = Frame-Verified only; 'playable' = Playable or Verified.",
+  "enum": [
+    "playable",
+    "verified"
+  ],
+  "type": "string"
+}

addedInput schema / properties / steam_os

Added value: +{
+  "description": "SteamOS compatibility — how well it runs on SteamOS / the Steam Machine (via Proton): 'verified' = SteamOS-Verified only; 'playable' = Playable or Verified. For a NATIVE Linux build instead, use platform:'linux'.",
+  "enum": [
+    "playable",
+    "verified"
+  ],
+  "type": "string"
+}

addedInput schema / properties / tags

Added value: +{
+  "description": "Keep only wishlist items carrying ALL of these user tags (case-insensitive), e.g. ['Metroidvania']. Implies include_details.",
+  "items": {
+    "minLength": 1,
+    "type": "string"
+  },
+  "minItems": 1,
+  "type": "array"
+}

8 tool updatesv0.3.0Jun 30, 2026

Removeddiscover_deals
Addeddiscover_games

Changedget_game3 fields changed

changedInput schema / properties / appid / description

Previous value: -"Steam application id (appid). Get it from search_games."New value: +"Steam appid (from search_games). Provide appid OR name."

addedInput schema / properties / name

Added value: +{
+  "description": "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.",
+  "minLength": 1,
+  "type": "string"
+}

removedInput schema / required
```
Removed value: -[
-  "appid"
-]
```

Changedget_owned_games2 fields changed

changedInput schema / properties / steamid / description

Previous value: -"17-digit SteamID64. Convert a vanity/custom URL name with resolve_vanity_url first."New value: +"17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first."

removedInput schema / required
```
Removed value: -[
-  "steamid"
-]
```

Changedget_player_achievements3 fields changed

addedInput schema / properties / language

Added value: +{
+  "description": "Language for achievement names/descriptions; overrides STEAM_LANGUAGE.",
+  "minLength": 2,
+  "type": "string"
+}

changedInput schema / properties / steamid / description

Previous value: -"17-digit SteamID64. Convert a vanity/custom URL name with resolve_vanity_url first."New value: +"17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first."

changedInput schema / required

Previous value: -[
-  "steamid",
-  "appid"
-]New value: +[
+  "appid"
+]

Changedget_player_summary2 fields changed

changedInput schema / properties / steamid / description

Previous value: -"17-digit SteamID64. Convert a vanity/custom URL name with resolve_vanity_url first."New value: +"17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first."

removedInput schema / required
```
Removed value: -[
-  "steamid"
-]
```

Changedget_recently_played2 fields changed

changedInput schema / properties / steamid / description

Previous value: -"17-digit SteamID64. Convert a vanity/custom URL name with resolve_vanity_url first."New value: +"17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first."

removedInput schema / required
```
Removed value: -[
-  "steamid"
-]
```

Changedget_wishlist2 fields changed

changedInput schema / properties / steamid / description

Previous value: -"17-digit SteamID64. Convert a vanity/custom URL name with resolve_vanity_url first."New value: +"17-digit SteamID64. Omit to use the STEAM_ID configured on the server. Convert a vanity/custom URL name with resolve_vanity_url first."

removedInput schema / required
```
Removed value: -[
-  "steamid"
-]
```

5 tool updatesv0.2.0Jun 29, 2026
- Addeddiscover_deals
- Removedget_current_prices
- Removedget_deals
- Removedget_game_info
- Removedget_price_history
22 tool updatesv0.1.0Jun 29, 2026
- First observedget_current_players
- First observedget_current_prices
- First observedget_deals
- First observedget_featured
- First observedget_game
- First observedget_game_achievements
- First observedget_game_info
- First observedget_game_news
- First observedget_game_reviews
- First observedget_global_achievements
- First observedget_items
- First observedget_owned_games
- First observedget_player_achievements
- First observedget_player_summary
- First observedget_price_history
- First observedget_prices
- First observedget_recently_played
- First observedget_review_histogram
- First observedget_specials
- First observedget_wishlist
- First observedresolve_vanity_url
- First observedsearch_games

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.4/5.0

Scored 2026-09-09 18:15 across 25 tools

Disambiguation4/5

Most tools have clearly distinct purposes, and the descriptions aggressively cross-reference each other ('use get_items instead', 'for X use Y'), which makes correct selection practical. However, there are tight clusters that could cause misselection: three achievement tools (get_global_achievements / get_game_achievements / get_player_achievements), two review tools, two front-page tools (get_specials / get_featured), and two game-finding tools (search_games / discover_games) — the boundaries are explained but an agent skimming could easily grab the wrong one.

Naming Consistency5/5

All tool names are snake_case and follow a predictable get_<resource> convention for 20 of 25 tools (get_game, get_prices, get_wishlist, get_owned_games). The five exceptions (search_games, discover_games, resolve_vanity_url, find_friends_who_own, compare_players) use descriptive action verbs that match their non-trivial operations, forming a coherent secondary pattern rather than a random deviation.

Tool Count4/5

25 tools puts this at the top of the 'heavy' range, but the server spans two genuinely distinct domains — store browsing/discovery (12 tools) and player/social data (13 tools) — so each tool plausibly earns its place. It is slightly over the ideal size and could benefit from consolidation (e.g., get_specials folded into get_featured, get_prices into get_items), but the two-domain structure keeps it navigable.

Completeness4/5

For a read-only Steam data server, the surface is remarkably complete: store search, details, pricing, reviews, trends, news, achievements, discovery, and player-side coverage including wishlists, friends, owned games, shared libraries, bans, and recommendations. There are no dead ends — search_games feeds appids and resolve_vanity_url feeds SteamIDs. Minor gaps exist: no market/workshop data, no bulk profile summary lookups, and discover_games' popularity-first scan is a documented practical limitation.

Maintenance

ActivityMaintained

ResponsivenessWithin a week

Resources

Need Help?

Related Servers

Related MCP Connectors

Steam B
io.github.pipeworx-io
Steam Web API: profiles, owned games, achievements, app news, player counts.
Games & Gamification Entertainment & Media
2
SteamGPT A
net.steamgpt
Steam profiles, SteamID conversion, bans, FACEIT stats, friends and comparisons. Free, no API key.
Developer Tools Games & Gamification
92
steamwebapi A
io.github.sellrock-de
Live Steam Market API docs, schemas, products, games, markets and endpoint search.
Games & Gamification E-commerce & Retail
112
gamedatakit A
com.borisinc
Live Steam market data for AI agents: top sellers, deals, player counts. Paid per call via x402.
Games & Gamification E-commerce & Retail
52

Related MCP Servers

Steam MCP Server
Games & Gamification Search Social Media
sharkusmanch
A
license
B
quality
C
maintenance
Provides tools for interacting with the Steam Web API to access player profiles, game libraries, achievements, statistics, inventories, and game information through natural language.
Updated a day ago (2026-09-19 03:03 UTC)
34
58 npm
5
MIT
steam-mcp
Games & Gamification Entertainment & Media
stealthsrc
A
license
A
quality
B
maintenance
Exposes Steam Web API tools as MCP resources for Claude Code, Claude Desktop, and Gemini CLI, enabling profile lookups, game searches, achievement tracking, and more.
Updated 16 days ago (2026-09-04 10:44 UTC)
11
10 npm
1
MIT
mcp-server-steam
Games & Gamification Entertainment & Media
deuxksy
A
license
A
quality
C
maintenance
Integrates with Steam Web API to enable querying user profiles, game libraries, store data, and community features like reviews and workshop items.
Updated 7 months ago (2026-02-23 23:48 UTC)
16
MIT
mcp-steam
Games & Gamification Entertainment & Media
pipeworx-io
A
license
Not graded
quality
D
maintenance
Provides 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.
Updated 2 days ago (2026-09-18 23:36 UTC)
3 npm
MIT