Steam MCP server for AI agents

Let Claude, ChatGPT or your own agent read and act on Steam: 32 typed functions through one MCP server. No Steam API key needed.

Functions
32
Sign-in
For account actions
Works with
MCP, HTTP, Node, Python

Connect

Just Steam

An MCP server for Steam alone, with one tool per function. Paste it into Claude, ChatGPT, Cursor or any MCP client as a remote server.

https://api.bowmark.ai/mcp/site/steam
Every site

One MCP server for Steam and every other site Bowmark covers. Your agent looks up what it needs and calls it.

https://api.bowmark.ai/mcp
Set it up in your client

Both need a Bowmark API key. The quickstart gets you one and a first result in a few minutes. Functions that need a login use the person's own account: how sign-in works.

Functions

Open a function to see its arguments, what it returns and how to call it.

Read 26
  • getAchievementsReads a game's achievement list from its public Steam Community page by appid: name, description, icon and the global percentage of players who…

    Arguments

    NameTypeRequired
    appidstring | numberYes

    Returns GetAchievementsResponse

    interface SteamAchievement {
      name: string;
      description: string;
      icon: string;
      percent: number;
    }
    
    interface GetAchievementsResponse {
      achievements: SteamAchievement[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getAchievements

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getAchievements({ appid: 620 });
  • getCommunityHubReads the first page of a game's public Steam Community hub by appid: announcements, discussions, reviews, screenshots, artwork, workshop items…

    Arguments

    NameTypeRequired
    appIdstring | numberYes

    Returns GetCommunityHubResponse

    type SteamHubItemKind =
      | "announcement"
      | "discussion"
      | "review"
      | "screenshot"
      | "artwork"
      | "workshop"
      | "guide"
      | "video"
      | "other";
    
    interface SteamHubItem {
      kind: SteamHubItemKind;
      postedAt: string | null;
      url: string;
      title: string | null;
      text: string | null;
      author: string | null;
      imageUrl: string | null;
      commentCount: number | null;
      rating: number | null;
    }
    
    interface GetCommunityHubResponse {
      appId: string;
      gameName: string | null;
      items: SteamHubItem[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getCommunityHub

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getCommunityHub({ appId: 440 });
  • getGameDetailsReads a specific game's full store page including title, description, price, developer, publisher, release date, platforms, system requirements, and…

    Arguments

    NameTypeRequired
    appidstring | numberYes

    Returns GetGameDetailsResponse

    interface SteamGameDetails {
      appid: string;
      name: string;
      type: string | null;
      isFree: boolean;
      shortDescription: string | null;
      detailedDescription: string | null;
      headerImage: string | null;
      website: string | null;
      developers: string[];
      publishers: string[];
      price: { currency: string; initial: number; final: number; discountPercent: number } | null;
      releaseDate: { comingSoon: boolean; date: string } | null;
      platforms: { windows: boolean; mac: boolean; linux: boolean };
      genres: string[];
      categories: string[];
      metacriticScore: number | null;
      recommendationsTotal: number | null;
      systemRequirements: {
        pcMinimum: string | null;
        pcRecommended: string | null;
        macMinimum: string | null;
        linuxMinimum: string | null;
      };
      screenshots: string[];
      videos: { name: string | null; thumbnail: string | null; hlsUrl: string | null }[];
      url: string;
    }
    
    interface GetGameDetailsResponse {
      game: SteamGameDetails;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getGameDetails

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getGameDetails({ appid: 620 });
  • getGameDlcLists a game's DLC by appid: each add-on's appid, name, US price in cents (null when free), discount, release time and platforms, in one request.

    Arguments

    NameTypeRequired
    appidstring | numberYes

    Returns GetGameDlcResponse

    interface SteamDlc {
      appid: string;
      name: string | null;
      price: { currency: string; initial: number; final: number; discountPercent: number } | null;
      releasedAt: number | null;
      headerImage: string | null;
      platforms: { windows: boolean; mac: boolean; linux: boolean };
      url: string;
    }
    
    interface GetGameDlcResponse {
      appid: string;
      gameName: string | null;
      dlc: SteamDlc[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getGameDlc

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getGameDlc({ appid: 1245620 });
  • getGameReviewsRetrieves user reviews for a game, including review text, helpful/unhelpful counts, reviewer profile link, and review date.

    Arguments

    NameTypeRequired
    appidstring | numberYes
    filter"recent" | "updated" | "all"No
    languagestringNo
    numPerPagenumberNo
    cursorstringNo

    Returns GetGameReviewsResponse

    interface SteamReviewAuthor {
      steamId: string;
      numGamesOwned: number;
      numReviews: number;
      playtimeForeverMinutes: number;
      profileUrl: string;
    }
    
    interface SteamReview {
      recommendationId: string;
      author: SteamReviewAuthor;
      language: string;
      review: string;
      timestampCreated: number;
      votedUp: boolean;
      votesUp: number;
      votesFunny: number;
      steamPurchase: boolean;
      receivedForFree: boolean;
      writtenDuringEarlyAccess: boolean;
    }
    
    interface GetGameReviewsResponse {
      reviews: SteamReview[];
      summary: {
        reviewScore: number;
        reviewScoreDescription: string;
        totalPositive: number;
        totalNegative: number;
        totalReviews: number;
      };
      cursor: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getGameReviews

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getGameReviews({ appid: 620 });
  • getGameScreenshotsFetches a game's screenshots and promotional images, returning image URLs, captions, and ordering.

    Arguments

    NameTypeRequired
    appidstring | numberYes

    Returns GetGameScreenshotsResponse

    interface GetGameScreenshotsResponse {
      screenshots: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getGameScreenshots

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getGameScreenshots({ appid: 620 });
  • getGameStatsReads a game's current concurrent player count and its global achievement completion rates (average and per-achievement), by appid.

    Arguments

    NameTypeRequired
    appidstring | numberYes

    Returns GetGameStatsResponse

    interface SteamAchievementRate {
      name: string;
      percent: number;
    }
    
    interface GetGameStatsResponse {
      currentPlayers: number;
      achievements: {
        averagePercent: number | null;
        rates: SteamAchievementRate[];
      };
    }
    
    interface SteamAchievementRate {
      name: string;
      percent: number;
    }
    
    interface GetGameStatsResponse {
      currentPlayers: number;
      achievements: {
        averagePercent: number | null;
        rates: SteamAchievementRate[];
      };
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getGameStats

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getGameStats({ appid: 620 });
  • getGameVideosFetches a game's trailers and video clips by appid, returning each video's name, thumbnail and HLS stream URL.

    Arguments

    NameTypeRequired
    appidstring | numberYes

    Returns GetGameVideosResponse

    interface SteamVideo {
      name: string | null;
      thumbnail: string | null;
      hlsUrl: string | null;
    }
    
    interface GetGameVideosResponse {
      videos: SteamVideo[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getGameVideos

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getGameVideos({ appid: 620 });
  • getLibraryFetches the signed-in caller's owned-games library.

    Arguments

    None.

    Returns GetLibraryResponse

    interface GetLibraryResponse {
      appids: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getLibrary

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getLibrary({});
  • getMarketPriceReads an item's current Community Market price by appid and exact market name (viewInventory's marketHashName): lowest listing price, median sale…

    Arguments

    NameTypeRequired
    appIdstring | numberYes
    marketHashNamestringYes
    currencynumberNo

    Returns GetMarketPriceResponse

    interface GetMarketPriceResponse {
      appId: string;
      marketHashName: string;
      currency: number;
      listed: boolean;
      lowestPrice: string | null;
      medianPrice: string | null;
      volume: number | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getMarketPrice

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getMarketPrice({ appId: 440, marketHashName: "Mann Co. Supply Crate Key" });
  • getNewsItemFetches the full text of a specific news article by appid and id (both from listNews or searchNews results), including title, author, publication…

    Arguments

    NameTypeRequired
    appidstring | numberYes
    newsIdstringYes

    Returns NewsItemResponse

    interface NewsItemResponse {
      id: string;
      title: string;
      author: string;
      date: number;
      content: string;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getNewsItem

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getNewsItem({ appid: 620, newsId: "1844751498235199" });
  • getPlayTimeLists the signed-in caller's own playtime per owned game.

    Arguments

    NameTypeRequired
    appIdstring | numberNo

    Returns GetPlayTimeResult

    interface PlayTimeEntry {
      appId: number;
      name: string | null;
      hoursTotal: number;
      hoursLastTwoWeeks: number;
      lastPlayed: string | null;
    }
    
    interface GetPlayTimeResult {
      gameCount: number;
      games: PlayTimeEntry[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getPlayTime

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getPlayTime({ appId: 620 });
  • getProfileReads a Steam profile by steamid64 or vanity name off the site's own public profile page: persona name, avatar, level, real name, country, current…

    Arguments

    NameTypeRequired
    idstringYes

    Returns GetProfileResponse

    interface SteamProfile {
      steamId: string;
      personaName: string;
      profileUrl: string;
      avatarUrl: string | null;
      status: string;  // the site's own labels, read the values off a result, never guess one from prose
      private: boolean;
      level: number | null;
      realName: string | null;
      location: string | null;
      summary: string | null;
      currentGame: string | null;
      memberSince: string | null;
    }
    
    interface GetProfileResponse {
      profile: SteamProfile;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getProfile

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getProfile({ id: "76561197960287930" });
  • getSteamDeckCompatibilityReads a game's Steam Deck rating by appid (verified, playable, unsupported or unknown) and Valve's individual test results behind it.

    Arguments

    NameTypeRequired
    appidstring | numberYes

    Returns GetSteamDeckCompatibilityResponse

    interface SteamDeckTestResult {
      result: string;
      kind: "pass" | "caveat" | "fail" | "info" | "other";
    }
    
    interface GetSteamDeckCompatibilityResponse {
      appid: string;
      rating: "verified" | "playable" | "unsupported" | "unknown";
      category: number;
      results: SteamDeckTestResult[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getSteamDeckCompatibility

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getSteamDeckCompatibility({ appid: 1245620 });
  • getWishlistFetches the caller's complete wishlist with all games currently saved.

    Arguments

    None.

    Returns GetWishlistResponse

    interface GetWishlistResponse {
      appids: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/getWishlist

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.getWishlist({});
  • listFeaturedGamesFetches the current list of featured games displayed on the Steam store homepage, which rotate based on staff picks and promotions.

    Arguments

    NameTypeRequired
    platform"windows" | "mac" | "linux"No

    Returns ListFeaturedGamesResponse

    interface FeaturedGame {
      appid: string;
      name: string | null;
      price: { currency: string; initial: number; final: number; discountPercent: number } | null;
      discountExpiration: number | null;
      capsuleImage: string | null;
      headerImage: string | null;
      platforms: { windows: boolean; mac: boolean; linux: boolean };
      streamingAvailable: boolean;
      controllerSupport: string | null;
    }
    
    interface ListFeaturedGamesResponse {
      games: FeaturedGame[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/listFeaturedGames

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.listFeaturedGames({ platform: "windows" });
  • listGamesByCategoryLists games filtered by one of Steam's own genre/category tags (Action, Adventure, Indie, RPG, Strategy, Simulation, Racing, Sports, Casual)…

    Arguments

    NameTypeRequired
    categorystringYes
    startnumberNo
    countnumberNo

    Returns ListGamesByCategoryResponse

    interface CategoryGamePrice {
      currency: "USD";
      initial: number;
      final: number;
      discountPercent: number;
    }
    
    interface CategoryGame {
      appid: string;
      name: string;
      url: string;
      releaseDate: string | null;
      reviewSummary: string | null;
      isFree: boolean;
      price: CategoryGamePrice | null;
      platforms: { windows: boolean; mac: boolean; linux: boolean };
    }
    
    interface ListGamesByCategoryResponse {
      games: CategoryGame[];
      totalCount: number;
      start: number;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/listGamesByCategory

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.listGamesByCategory({ category: "action" });
  • listGameTagsLists every tag users can apply to games on the Steam store, in the site's own popularity order, optionally localized by language.

    Arguments

    NameTypeRequired
    languagestringNo

    Returns ListGameTagsResponse

    interface SteamTag {
      tagId: number;
      name: string;
    }
    
    interface ListGameTagsResponse {
      tags: SteamTag[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/listGameTags

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.listGameTags({});
  • listNewsLists a game's news and updates by appid, from both official announcements and third-party gaming sites, with title, author, date, full HTML content…

    Arguments

    NameTypeRequired
    appidstring | numberYes
    countnumberNo
    feednamestringNo
    maxLengthnumberNo

    Returns ListNewsResponse

    interface SteamNewsItem {
      id: string;
      title: string;
      url: string;
      isExternalUrl: boolean;
      author: string;
      contents: string;
      feedLabel: string;
      date: number;
      feedName: string;
      feedType: number;
      tags: string[];
    }
    
    interface ListNewsResponse {
      items: SteamNewsItem[];
      totalCount: number;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/listNews

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.listNews({ appid: 620 });
  • listStoreSpecialsLists what the Steam store is promoting right now: games on sale, top sellers, new releases, coming soon and the daily deal, with prices, discounts…

    Arguments

    NameTypeRequired
    countryCodestringNo

    Returns ListStoreSpecialsResponse

    interface StoreSpecialsGame {
      appid: string;
      name: string | null;
      price: { currency: string; initial: number; final: number; discountPercent: number } | null;
      discountExpiration: number | null;
      headerImage: string | null;
      platforms: { windows: boolean; mac: boolean; linux: boolean };
      url: string;
    }
    
    interface ListStoreSpecialsResponse {
      specials: StoreSpecialsGame[];
      topSellers: StoreSpecialsGame[];
      newReleases: StoreSpecialsGame[];
      comingSoon: StoreSpecialsGame[];
      dailyDeal: StoreSpecialsGame[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/listStoreSpecials

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.listStoreSpecials({});
  • searchGamesSearches the Steam store by keyword and returns matching games with basic details like title, price, metascore, and platform availability.

    Arguments

    NameTypeRequired
    querystringYes

    Returns SearchGamesResponse

    interface SteamSearchResult {
      appid: string;
      name: string;
      price: { currency: string; initial: number; final: number } | null;
      metascore: number | null;
      platforms: { windows: boolean; mac: boolean; linux: boolean };
      url: string;
    }
    
    interface SearchGamesResponse {
      results: SteamSearchResult[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/searchGames

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.searchGames({ query: "portal" });
  • searchMarketSearches the Steam Community Market by keyword, optionally within one game (appId): each row's name, exact market hash name (what getMarketPrice…

    Arguments

    NameTypeRequired
    querystringYes
    appIdstring | numberNo
    startnumberNo

    Returns SearchMarketResponse

    interface SteamMarketListing {
      name: string;
      hashName: string;
      appId: string | null;
      appName: string | null;
      type: string | null;
      sellListings: number;
      sellPriceText: string | null;
      url: string;
      iconUrl: string | null;
    }
    
    interface SearchMarketResponse {
      query: string;
      totalCount: number;
      start: number;
      listings: SteamMarketListing[];
      hasMore: boolean;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/searchMarket

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.searchMarket({ query: "Mann Co. Supply Crate Key", appId: 440 });
  • searchNewsSearches a game's recent news items by keyword and/or date range.

    Arguments

    NameTypeRequired
    appidstring | numberYes
    querystringNo
    sincenumberNo
    untilnumberNo
    batchSizenumberNo

    Returns SearchNewsResponse

    interface SteamSearchNewsItem {
      id: string;
      title: string;
      url: string;
      author: string;
      contents: string;
      feedLabel: string;
      date: number;
      tags: string[];
    }
    
    interface SearchNewsResponse {
      items: SteamSearchNewsItem[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/searchNews

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.searchNews({ appid: 620, query: "update" });
  • viewFriendsLists the signed-in caller's Steam friends.

    Arguments

    None.

    Returns ViewFriendsResult

    interface SteamFriend {
      steamId: string;
      name: string;
      profileUrl: string;
      avatarUrl: string | null;
      status: string;  // "in-game", "online", "offline", the site's own persona class
      playingGame: string | null;
    }
    
    interface ViewFriendsResult {
      friends: SteamFriend[];
      totalCount: number;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/viewFriends

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.viewFriends({});
  • viewInventoryReads a PUBLIC Steam profile's inventory by steamid64, appid and context.

    Arguments

    NameTypeRequired
    steamIdstring | numberYes
    appIdstring | numberNo
    contextIdstring | numberNo
    countnumberNo

    Returns ViewInventoryResponse

    interface SteamInventoryItem {
      assetId: string;
      classId: string;
      instanceId: string;
      amount: number;
      name: string | null;
      marketHashName: string | null;
      type: string | null;
      iconUrl: string | null;
      tradable: boolean;
      marketable: boolean;
    }
    
    interface ViewInventoryResponse {
      steamId: string;
      appId: string;
      contextId: string;
      items: SteamInventoryItem[];
      totalCount: number;
      private: boolean;
      hasMore: boolean;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/viewInventory

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.viewInventory({ steamId: "76561198337712279", appId: 440 });
  • viewMarketHistoryLists the signed-in caller's own Steam Community Market history.

    Arguments

    NameTypeRequired
    startnumberNo
    countnumberNo

    Returns ViewMarketHistoryResult

    interface MarketHistoryEntry {
      itemName: string;
      gameName: string | null;
      action: "bought" | "sold" | null;
      price: string | null;
      actedOn: string | null;
      listedOn: string | null;
      counterparty: string | null;
      appId: number | null;
      imageUrl: string | null;
    }
    
    interface ViewMarketHistoryResult {
      entries: MarketHistoryEntry[];
      totalCount: number;
      start: number;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/viewMarketHistory

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.viewMarketHistory({ count: 10 });
Act 6
  • addFriendSends a friend request to another Steam user by steamid64, off the friends page's own AddFriendAjax door.

    Arguments

    NameTypeRequired
    steamIdstring | numberYes

    Returns AddFriendResult

    interface AddFriendResult {
      steamId: string;
      requested: true;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/addFriend

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.addFriend({ steamId: "<steamId>" });
  • addToWishlistAdds a game to the signed-in caller's wishlist, off the store's own addtowishlist door.

    Arguments

    NameTypeRequired
    appidstring | numberYes

    Returns AddToWishlistResult

    interface AddToWishlistResult {
      appid: string;
      added: true;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/addToWishlist

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.addToWishlist({ appid: "<appid>" });
  • editProfileUpdates the signed-in caller's own persona name and/or profile summary off the profile-edit page's own save door.

    Arguments

    NameTypeRequired
    personaNamestringNo
    summarystringNo

    Returns EditProfileResult

    interface EditProfileResult {
      personaName: string | null;
      summary: string | null;
      updated: true;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/editProfile

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.editProfile({});
  • postCommentPosts a comment on a Steam user's profile by steamid64 (max 1000 characters), off the profile comment box's own post door.

    Arguments

    NameTypeRequired
    steamIdstring | numberYes
    commentstringYes

    Returns PostCommentResult

    interface PostCommentResult {
      steamId: string;
      posted: true;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/postComment

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.postComment({ steamId: "<steamId>", comment: "<comment>" });
  • removeFriendRemoves a user from the signed-in caller's Steam friends list by steamid64, off the friends page's own RemoveFriendAjax door.

    Arguments

    NameTypeRequired
    steamIdstring | numberYes

    Returns RemoveFriendResult

    interface RemoveFriendResult {
      steamId: string;
      removed: true;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/removeFriend

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.removeFriend({ steamId: "<steamId>" });
  • removeFromWishlistRemoves a game from the signed-in caller's wishlist by appid, off the store's own removefromwishlist door.

    Arguments

    NameTypeRequired
    appidstring | numberYes

    Returns RemoveFromWishlistResult

    interface RemoveFromWishlistResult {
      appid: string;
      removed: true;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/steam/removeFromWishlist

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.steam.removeFromWishlist({ appid: "<appid>" });

Use it from code