Get full store details for one game: description, price/discount, genres, platforms, release date, developers/publishers, Metacritic, age rating, DLC (the dlc appid list is capped at 50 — read dlc_total for the real count, and pass the appids to get_items for names and prices), PC requirements and a small highlighted-achievements sample (achievements_highlighted). Identify the game by appid (from search_games) OR by name — a title is resolved to the closest store match. Both forms error rather than returning an empty result when nothing matches, and an appid can fail for different reasons: it may not exist or have been removed from the store, or it may not be sold in the given country. The error names the country and these causes — retry with another country before concluding the game is gone. No API key required.

Get how a game's reviews trend over time by appid: a long-term history (rollup_type reports each entry's granularity, e.g. 'week' or 'month', chosen server-side by Steam; capped at the most recent 24 entries) and the recent per-day breakdown (capped at the most recent 30 days), each with positive/negative counts and positive %. Good for 'are reviews improving / did an update hurt reception'. An unknown appid comes back as empty history/recent arrays rather than an error — Steam answers success for any id — so an empty result means either no such appid or a game nobody has reviewed yet; confirm the appid with get_game if that distinction matters. For a current summary and example review text instead of a trend, use get_game_reviews. Get the appid from search_games. No API key required.

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 — no such appid, not sold in that country, or a transient upstream failure on the chunk it fell in, so retry before concluding a game is unavailable — never dropped). A priced row carries final/initial price and discount_percent. A row marked priced:false has no price block at all, which is how BOTH free-to-play and not-yet-released titles come back: this endpoint cannot tell them apart, so never report priced:false as 'free' — pass those appids to get_items, whose is_free/coming_soon do separate them. No API key required. Get appids from search_games or get_wishlist.

List games currently on special (discounted) on the Steam store front page, with the discount % and original/final price. For ALL catalog discounts (not just the front page), use discover_games with min_discount. No API key required.

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

Search the Steam store by title — term can be partial or approximate, not an exact match; returns matches with their appid (needed by the other game tools), the game's own price, Metacritic score, platforms, type (game, dlc, music for a soundtrack, demo, …) and a clickable store_url, in Steam's relevance order. total is Steam's full match count; limit returns up to 100 of them (there is no paging past that, so refine the term if the game you want isn't listed). Prices are Steam's formatted strings with the currency symbol (no separate currency code); null for free-to-play or unpriced games. Returns games only by default; set games_only=false to include DLC, soundtracks, demos and other store items. For review %, Steam Deck status or tags, pass the appids to get_items. No API key required.

Get recent news / patch notes for a game by appid (title, date, author, excerpt, link). By default this mixes the developer's announcements with third-party press feeds; set kind='official' for the developer's own posts only, or kind='patch_notes' for update notes only (posts the developer tagged as patch notes — if that comes back empty, try 'official'). Each excerpt is the first ~400 characters of the post with HTML stripped — follow url for the full text. An unknown/unassigned appid comes back as an empty list rather than an error, the same as get_global_achievements. Get the appid from search_games. No API key required.

Get the review summary (score label, positive/negative counts, %) and a few reviews for a game by appid — by default the most helpful ones posted in the last 30 days; set order for the newest or most recently edited instead, or within_days to widen/narrow the helpful window. Review text over 600 characters is truncated. An unknown appid comes back with a null summary and counts and no reviews rather than an error; confirm the appid with get_game if that matters. For long-term trend instead of a snapshot, use get_review_histogram. Get the appid from search_games. No API key required.

Get the global unlock percentage of each achievement in a game by appid — how rare each achievement is across all players. Returns each achievement's internal name and its unlock percent (no display names/descriptions — for those, use get_game_achievements), most-common first, capped at the first 200 (check returned vs count — most games have far fewer). An unknown appid, or one with no achievement schema (e.g. a DLC/soundtrack), comes back as an empty list rather than an error, the same as get_game_news. Get the appid from search_games. No API key required.

Get 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 — rows stay in the order you passed them, one per id, never dropped, 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.

Find games across the whole Steam catalog (keyless), filtered by ANY combination of: discount (min_discount — for 'what's on sale'), release recency (released_after / released_within_days — for 'new games'), hardware compatibility (steam_deck/steam_os/steam_machine/steam_frame — see each field's own description), native OS build (platform — windows/mac/linux), review quality (min_review / min_reviews), and user tags (tags — e.g. ['Roguelike', 'Deckbuilding'] for 'games like X'). Each result returns price/discount, review %, all four compat statuses, a vr_support flag (none/supported/required), popular tags, a clickable store_url, discount_end (when a deal expires) and release date in one call. Examples: '>80% off with 90%+ reviews' → set min_discount + min_review; 'recent well-reviewed games that run on Steam Deck' → set released_within_days + steam_deck + min_review; 'roguelike deckbuilders on sale' → tags:['Roguelike','Deckbuilding'] + min_discount. Base games only: DLC, soundtracks, demos and tools are filtered out, so a 'find DLC on sale' question returns nothing here — price a known DLC appid with get_items instead. No appids needed — unlike get_items, which prices a list you already have. For 'games like X' from a SINGLE named title, get its tags via get_items and pass them here; for taste inferred from the player's WHOLE library instead, use get_recommended_games (key-gated). Filtering: min_discount, released_after/released_within_days, tags, min_review and ONE of steam_deck/steam_machine/steam_frame are applied by Steam across the whole catalog, so a niche combination still finds its games, most popular first (total_matching is Steam's count of them). steam_os, platform, min_reviews and a second hardware filter have no server-side form and are applied afterwards to the count entries fetched, so those can return fewer — raise count for them. min_review only counts games with a Steam rating (10+ reviews). At most 50 results come back per call, best discount first: compare returned against matched to see whether the list was capped, and narrow the filters or page with start for the rest.

Get how many people are playing a game right now (live concurrent player count) by appid. Get the appid from search_games. No API key required. Errors clearly if the appid is unknown/invalid rather than returning a null count.

Get what is popular on Steam right now as a ranked list. chart picks one: top_sellers (weekly best-sellers, with weeks on chart), most_played (top 100 by peak players on the last full day, with the rank a week earlier), most_played_deck (top 100 played on Steam Deck in the past week, with the previous week's rank) or concurrent_players (top 100 by players in game right now, live). Use for 'what's hot / top selling / most played on Steam (Deck)'; for one known game's live count use get_current_players, for the store front page's curated sections (also hardware and bundles) use get_featured, to FILTER the catalog by discount, tags or compat use discover_games. Returns only rank, appid, name, store_url and chart metrics (no price/reviews/Deck status) — pass the appids to get_items for those. last_week_rank null means a new entry; concurrent_players has none. Results are cached for a few minutes. top_sellers is global by default; give country for that country's own best-sellers and week for a past week. The other three are global rankings of the current period only. No API key required.

List the games a player 'follows' on the Steam store, by SteamID64 — a lighter opt-in (get sale/update notifications) that's separate from the wishlist; many players follow more games than they wishlist. No API key required, but the follows/profile must be public — otherwise it returns found:false, which is ALSO what a public account following nothing returns; read reason to tell those apart. Returns appids + store_url only (no price/name), capped at 200 in whatever order Steam sends them — unlike every other capped list here there is no ranking, so a game past the cut is not 'less followed' (check returned vs total); pass the appids to get_items for price, review % and compat. Convert a vanity name with resolve_vanity_url first (that conversion itself needs STEAM_API_KEY, even though this tool doesn't).

List a player's Steam wishlist by SteamID64. No API key required, but the wishlist/profile must be public — otherwise it returns found:false, which is ALSO what an empty but public wishlist returns; read reason to tell those apart. By default returns a light list of appids (sorted by priority, no names), capped at the first 100 (check returned vs total). Set include_details for full store cards in ONE call (name, price/discount, review %, Deck/SteamOS/Machine/Frame compat, vr_support, tags, release) — no need to follow up with get_items. Narrow it in the SAME call with tags (e.g. ['Metroidvania']), platform (NATIVE windows/mac/linux build), steam_deck/steam_os/steam_machine/steam_frame (Proton compatibility — see each field), min_review, min_discount / on_sale_only, or country / language. Any of these filters switches to the detailed card view, since the light appid list has no price/tags/compat to filter on. Filters apply before the output cap (the detailed card list returns at most 50 items), so a deeply-discounted niche match past the display cap is never hidden by it (e.g. 'top metroidvanias on my wishlist with a good discount and reviews' → tags:['Metroidvania'] + min_discount + min_review). Results ranked by discount when a discount filter is set, else by wishlist priority; matched reports the pre-cap count. tags, steam_deck, mac/linux and the discount floor are applied by Steam over the whole wishlist; min_review, the exact own-package discount and the other compat/platform filters are checked by this server over up to 1000 matching entries, and note says when a bigger match set left some unchecked. Convert a vanity name with resolve_vanity_url first (that conversion itself needs STEAM_API_KEY, even though this tool doesn't).

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.

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.

List a player's Steam friends by SteamID64: name, online state, current game and how long they've been friends, most-recently-added first (capped at the 100 most-recently-added; check returned vs total). Requires STEAM_API_KEY and the friends list to be public — otherwise it returns found:false, which also covers a SteamID64 with no account behind it; read reason. For 'which of my friends own game X', use find_friends_who_own instead — it checks each friend's full library, not just this list. Get the SteamID64 from resolve_vanity_url.

Check which of a player's Steam friends own one or more games by appid, with each owner's playtime_hours — 'which of my friends have Portal 2 and how long have they played'. Checks each friend's FULL library, unlike get_owned_games whose own list stops at 50 games by playtime by default — so a friend's rarely-played or unplayed copy is never missed (its playtime_hours may still be low or 0). For the PLAYER'S OWN ownership instead of a friend's, use get_owned_games's check_appids. Requires STEAM_API_KEY and the player's OWN friends list to be public — otherwise the whole call returns found:false, which also covers a SteamID64 with no account behind it; read reason. A friend'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 200 friends are looked up at all (one Steam call per friend would otherwise run past an MCP client's request timeout), and they are the most-recently-added ones — the same ordering and the same prefix get_friend_list shows, so 'the friends checked' is a set you can actually name — compare friends_checked against total_friends, and treat a friend missing from all three lists as unchecked, not as a non-owner. Get appids from search_games.

Find games two players both own, with each one's playtime — 'what can my friend and I both play', 'do we have anything in common'. Checks each player's FULL library to find every shared game, unlike get_owned_games whose own list stops at 50 by playtime by default — but the returned list here is itself capped at the top 50 shared games by combined playtime (check returned vs shared_count). Requires STEAM_API_KEY and both profiles' game-details to be public. A private profile, or a SteamID64 with no account behind it, returns found:false; an upstream failure returns a tool error worth retrying. Omit steamid to compare against yourself (STEAM_ID).

Get a player's profile by SteamID64: display name, online state, country, account age, Steam level (a separate lookup that degrades to null on failure, independently of profile privacy), and the game they're currently in. found:false here means exactly one thing — no account with that SteamID64 — since this tool reads private profiles fine. Requires STEAM_API_KEY, but works even for a private profile (visibility reports 'private') — country, account age and the current game only populate when the profile is public. For VAC/game/trade ban status instead, use get_player_bans.

Check a player's VAC, game, community and economy (trade) ban status by SteamID64 — 'is this player banned', useful before trading or adding a friend. Ban status is always public — this works even when the rest of the profile is private. days_since_last_ban is null for a player who has never been banned — Steam sends 0 there, which would otherwise read as 'banned today'. Requires STEAM_API_KEY.

List the games a player owns with playtime (hours), ordered by playtime — most-played first by default, least-played first with sort='playtime_asc' (the games list is capped to 50 entries by default, so the far end of that ordering may not appear there; raise limit to widen the cap, or flip sort to keep the never-played end instead, which is what a 'what have I never got round to playing' question needs). To reliably check whether the player owns one or more SPECIFIC appids regardless of that cap — 'do I own game X' — pass check_appids; the owns field then checks the FULL, uncapped library, with each result's own playtime_hours (null if not owned). For the last two weeks of play instead of the all-time library, use get_recently_played. For checking a FRIEND's ownership instead of the player's own, use find_friends_who_own. Requires STEAM_API_KEY and a public profile + game-details visibility; a private profile, or a SteamID64 with no account behind it, returns found:false. Get the SteamID64 from resolve_vanity_url.

List the games a player has played in the last two weeks, with recent and total playtime, most-played-in-those-two-weeks first (capped at 50; check returned vs total) — the ordering is what decides which games the cap keeps, and it is playtime, not recency. For the all-time library by playtime instead (capped at 50 entries by default, either end of that ordering via sort), use get_owned_games. Requires STEAM_API_KEY and a public profile with game-details visibility (same requirement as get_owned_games) — otherwise, or for a SteamID64 with no account behind it, it returns found:false.

Recommend unowned Steam catalog games personalized to this player: tags on their own most-played owned games become weighted preferences (more playtime on a tag = more weight), discounted by each candidate's review score so a tag match on a poorly-received game doesn't outrank a better one, then ranked against a broad catalog page, excluding anything already owned. based_on_tags shows which of the player's own top tags drove the ranking; each result carries matched_tags and match_score alongside the usual price/review/compat card. Set exclude_tags to steer away from a genre despite it matching by playtime, and/or min_discount for a minimum deal size (e.g. 'suggest games on sale, not RPGs or shooters' → exclude_tags:['RPG','Shooter','FPS'], min_discount:30). Different from discover_games (which needs YOU to name the filters) — this infers taste from the player's WHOLE library instead, for 'what should I play next' / 'recommend me something'. For 'something like THIS ONE game' (a single named title), get its tags via get_items and call discover_games with them instead. Recommends base games only — DLC, soundtracks and demos are never suggested, the same filter discover_games applies. Note: taste is weighted from only the player's 30 most-played owned games, and candidates come from a fixed 300-entry catalog scan, so a heavy exclude_tags/min_discount combination can return fewer than limit — there's no larger scan to fall back to. Requires STEAM_API_KEY and a public profile with game-details visible (same requirement as get_owned_games) — found:false is also returned for a SteamID64 with no account behind it, if the player owns no games at all, or if too few of their played games have resolvable tags to build a taste profile.

Get a player's achievement progress for one game (unlocked count, % complete, per-achievement unlock dates) by SteamID64 + appid — unlocked/completion_pct always reflect the full list, but the per-achievement achievements array is capped at 200, unlocked first (check returned vs total — most games have far fewer). For the game's full achievement list (names, descriptions, global rarity) independent of any player, use get_game_achievements instead; for just the rarity without a key, use get_global_achievements. Requires STEAM_API_KEY and a public profile with game-details visibility — otherwise it returns found:false — which is also what a SteamID64 with no account behind it, an appid with no achievements, or no such appid at all returns; these are not always told apart, so confirm the appid with get_game.