Functions For Modules

Here is a list of all the functions available in the GodotSteam module. Many will reference appID or steamID. AppID always references a game, application, or DLC's ID number in Steam. The steamID, however, can reference a user, lobby session, server, or such.


Core

steamInit( bool retrieve_stats )

  • Starts up the Steam API. You can pass a bool to retrieve the current player's stats automatically; this defaults to true.
  • Returns a dictionary:
    • status (int)
    • verbal (string)

isSteamRunning()

  • Check if the Steam client is running. Returns 1 if so and 0 if not.
  • Returns a bool.

restartAppIfNecessary( int appID )

  • Checks if your executable was launched through Steam and relaunches it through Steam if it wasn't.
  • Returns a bool.

run_callbacks()

  • This should be run often; best if called in the _process(delta) function.
  • Returns nothing; void.

Apps

getDLCDataByIndex()

  • Get metadata for a DLC, by index.
  • Returns an array of:
    • dlc (dictionary)
      • appID (int)
      • available (bool)
      • name (string)

isAppInstalled( int appID )

  • Check if given application/game is installed, not necessarily owned.
  • Returns a bool.

isCybercafe()

  • Checks whether the current App ID is for Cyber Cafes.
  • Returns a bool.

isDLCInstalled( int value )

  • Checks if the user owns a specific DLC and if the DLC is installed.
  • Returns a bool.

isLowViolence()

  • Checks if the license owned by the user provides low violence depots.
  • Returns a bool.

isSubscribed()

  • Checks if the active user is subscribed to the current App ID.
  • Returns a bool.

isSubscribedApp( int value )

  • Checks ownership of another game related to yours: a demo, etc.
  • Returns a bool.

isSubscribedFromFamilySharing()

  • Checks if the active user is accessing the current appID via a temporary Family Shared license owned by another user.
  • Returns a bool.

isSubscribedFromFreeWeekend()

  • Checks if the user is subscribed to the current app through a free weekend.
  • Returns a bool.

isTimedTrial()

  • Check if game is a timed trial with limited playtime.
  • Returns a dictionary:
    • seconds_allowed (int)
    • seconds_played

isVACBanned()

  • Does the user have a VAC ban for this game.
  • Returns a bool.

getAppBuildId()

  • Gets the build ID for this application; will change based on backend updates.
  • Returns an int.

getAppInstallDir( int appID )

  • Gets the install folder for a specific AppID.
  • Returns a string.

getAppOwner()

  • Gets the Steam ID of the original owner of the current app. If it's different from the current user then it is borrowed.
  • Returns an int.

getAvailableGameLanguages()

  • Get a list of the languages the current app supports.
  • STRING; returns comma-separated list of two-letter country language codes.

getCurrentBetaName()

  • Checks if the user is running from a beta branch, and gets the name of the branch if they are.
  • Returns a string.

getCurrentGameLanguage()

  • Get the user's current game language (ie. english, russian, french).
  • Returns a string.

getDLCCount()

  • Get the total number of DLC installed for this application/game.
  • Returns an int.

getDLCDownloadProgress( int appID )

  • Gets the download progress for optional DLC.
  • Returns a dictionary:
    • ret (bool)
    • downloaded (int)
    • total (int)

getEarliestPurchaseUnixTime( int value )

  • Get the datetime of the purchase of the app.
  • Returns an int.

getFileDetails( string filename )

  • Asynchronously retrieves metadata details about a specific file in the depot manifest.
  • Triggers _file_details_result callback.
  • Returns nothing; void.

getInstalledDepots( int appID, int depots, int maxDepots )

  • Gets a list of all installed depots for a given App ID.
  • Returns an array.

getLaunchCommandLine( )

  • Gets the command line if the game was launched via Steam URL, e.g. steam://run/(appid)//(command line)/. This method is preferable to launching with a command line via the operating system, which can be a security risk. In order for rich presence joins to go through this and not be placed on the OS command line, you must enable "Use launch command line" from the Installation > General page on your app.
  • Returns a string.

getLaunchQueryParam( string key )

  • Gets the associated launch parameter if the game is run via steam://run//?param1=value1;param2=value2;param3=value3 etc.
  • Returns a string.

installDLC( int value )

  • Install control for optional DLC.
  • Triggers _dlc_installed callback.
  • Returns nothing; void.

markContentCorrupt( bool missingFilesOnly )

  • Allows you to force verify game content on next launch. Returns true/false depending on success.
  • Returns a bool.

uninstallDLC( int value )

  • Uninstall control for optional DLC.
  • Returns nothing; void.

Friends

activateGameOverlay( string dialog )

  • Activates the overlay with optional dialog to open the following: "Friends", "Community", "Players", "Settings", "OfficialGameGroup", "Stats", "Achievements", "LobbyInvite".
  • Returns nothing; void.

activateGameOverlayInviteDialog( int steamID )

  • Activates game overlay to open the invite dialog. Invitations will be sent for the provided lobby.
  • Returns nothing; void.

activateGameOverlayInviteDialogConnectString( string connectString )

  • Activates game overlay to open the invite dialog. Invitations will be sent for the provided lobby.
  • Returns nothing; void.

activateGameOverlayToStore( int appID )

  • Activates the overlay with the application/game Steam store page.
  • Returns nothing; void.

activateGameOverlayToUser( string url, int steamID )

  • Activates the overlay to the following: "steamid", "chat", "jointrade", "stats", "achievements", "friendadd", "friendremove", "friendrequestaccept", "friendrequestignore".
  • Returns nothing; void.

activateGameOverlayToWebPage( string url )

  • Activates the overlay with specified web address.
  • Returns nothing; void.

clearRichPresence()

  • Clear the game information in Steam; used in 'View Game Info'.
  • Returns nothing; void.

closeClanChatWindowInSteam( int chatID )

  • Closes the specified Steam group chat room in the Steam UI.
  • Returns a bool.

downloadClanActivityCounts( int clanID, int clansToRequest )

  • For clans a user is a member of, they will have reasonably up-to-date information, but for others you'll have to download the info to have the latest.
  • Triggers _clan_activity_downloaded callback.
  • Return nothing; void.

enumerateFollowingList( int startIndex )

  • Gets the list of users that the current user is following.
  • Triggers _enumerate_following_list
  • Return nothing; void.

getChatMemberByIndex( int clanID, int user )

  • Gets the Steam ID at the given index in a Steam group chat.
  • Returns an int.

getClanActivityCounts( int clanID )

  • Gets the most recent information we have about what the users in a Steam Group are doing. This can only retrieve data that the local client knows about. To refresh the data or get data from a group other than one that the current user is a member of you must call DownloadClanActivityCounts.
  • Returns a dictionary:
    • clan (int)
    • online (int)
    • ingame (int)
    • chatting (int)

getClanByIndex( int clan )

  • Gets the Steam group's Steam ID at the given index. You must call GetClanCount before calling this.
  • INT.

getClanChatMemberCount( int clanID )

  • Get the number of users in a Steam group chat.
  • Returns an int.

getClanChatMessage( int chatID, int message )

  • Gets the data from a Steam group chat room message. This should only ever be called in response to a GameConnectedClanChatMsg_t callback.
  • Returns a dictionary:
    • ret (bool)
    • text (string)
    • type (int)
    • chatter (int)

getClanCount()

  • Gets the number of Steam groups that the current user is a member of. This is used for iteration, after calling this then GetClanByIndex can be used to get the Steam ID of each Steam group.
  • Returns an int.

getClanName( int clanID )

  • Gets the display name for the specified Steam group; if the local client knows about it.
  • Returns a string.

getClanOfficerByIndex( int clanID, int officer )

  • Returns the steamID of a clan officer, by index, of range [0, GetClanOfficerCount).
  • Returns an int.

getClanOfficerCount( int clanID )

  • Returns the number of officers in a clan (including the owner).
  • Returns an int.

getClanOwner( int clanID )

  • Get the steamID of the clan owner.
  • Returns an int.

getClanTag( int clanID )

  • Gets the unique tag (abbreviation) for the specified Steam group; If the local client knows about it. The Steam group abbreviation is a unique way for people to identify the group and is limited to 12 characters. In some games this will appear next to the name of group members.
  • Returns a string.

getCoplayFriend( int friend )

  • Gets the Steam ID of the recently played with user at the given index.
  • Returns an int.

getCoplayFriendCount()

  • Gets the number of players that the current users has recently played with, across all games. This is used for iteration, after calling this then GetCoplayFriend can be used to get the Steam ID of each player. These players are have been set with previous calls to SetPlayedWith.
  • Returns an int.

getFollowerCount( int steamID )

  • Gets the number of users following the specified user.
  • Triggers _get_follower_count callback.
  • Returns nothing; void.

getFriendByIndex( int friendNum, int friendFlags )

  • Get the Steam ID of a user.
  • Returns an int.

getFriendCoplayGame( int friendID )

  • Gets the app ID of the game that user played with someone on their recently-played-with list.
  • Returns an int.

getFriendCoplayTime( int friendID )

  • Gets the timestamp of when the user played with someone on their recently-played-with list. The time is provided in Unix epoch format (seconds since Jan 1st 1970).
  • Returns an int.

getFriendCount()

  • Get the number of friends the user has.
  • Returns an int.

getFriendCountFromSource( int sourceID )

  • Iterator for getting users in a chat room, lobby, game server or clan. The clansID can actually be the Steam ID of a group, game server, lobby, or chat room.
  • Returns an int.

getFriendFromSourceByIndex( int sourceID, int friendNum )

  • Same as getFriendCountFromSource except it requires a specific number for iteration.
  • Returns an int.

getFriendGamePlayed( int steamID )

  • Gets the details of a friend playing a joinable game.
  • Returns a dictionary:
    • ip (string)
    • gamePort (int)
    • queryPort (int)
    • lobby (int)

getFriendMessage( int friendID, int message )

  • Gets the data from a Steam friends message. This should only ever be called in response to a GameConnectedFriendChatMsg_t callback.
  • DICTIONARY; returns a dictionary containing the return value and text.

getFriendPersonaName( int steamID )

  • Get the given user's Steam username.
  • Returns a string.

getFriendPersonaNameHistory( int steamID, int nameHistory )

  • Accesses old friends names; returns an empty string when there are no more items in the history.
  • Returns a string.

getFriendPersonaState( int steamID )

  • Returns the current status of the specified user.
  • Returns an int; should be one of the following:
    • 0 - Offline
    • 1 - Online
    • 2 - Busy
    • 3 - Away
    • 4 - Snooze
    • 5 - Looking For Trade
    • 6 - Looking for Play

getFriendRelationship( int steamID )

  • Returns a relationship to a user.
  • Returns an int; should be one of the following:
    • 0 - None
    • 1 - Blocked
    • 2 - Request Recipient
    • 3 - Friend
    • 4 - Request Initiator
    • 5 - Ignored
    • 6 - Ignored Friend
    • 7 - Suggested
    • 8 - Max

getFriendRichPresence( int friendID, string key )

  • Get a Rich Presence value from a specified friend (typically only used for debugging).
  • Returns a string.

getFriendRichPresenceKeyCount( int friendID )

  • Gets the number of Rich Presence keys that are set on the specified user.
  • Returns an int.

getFriendRichPresenceKeyByIndex( int friendID, int key )

  • Gets an empty string ("") if the index is invalid or the specified user has no Rich Presence data available.
  • Returns a string.

getFriendsGroupCount()

  • Gets the number of friends groups (tags) the user has created. This is used for iteration, after calling this then GetFriendsGroupIDByIndex can be used to get the ID of each friend group. This is not to be confused with Steam groups. Those can be obtained with GetClanCount.
  • Returns an int.

getFriendsGroupIDByIndex( int friendGroup )

  • Gets the friends group ID for the given index.
  • Returns an int.

getFriendsGroupMemberCount( int friendGroup )

  • Gets the number of friends in a given friends group. This should be called before getting the list of friends with GetFriendsGroupMembersList.
  • Returns an int.

getFriendsGroupMembersList( int friendGroup, int memberCount )

  • Gets the number of friends in the given friends group. If fewer friends exist than requested those positions' Steam IDs will be invalid. You must call GetFriendsGroupMembersCount before calling this to set up the pOutSteamIDMembers array with an appropriate size!
  • Returns an array.

getFriendsGroupName( int friendGroup )

  • Gets the name for the given friends group.
  • Returns a string.

getFriendSteamLevel( int steamID )

  • Get friend's steam level, obviously.
  • Returns an int.

getLargeFriendAvatar( int steamID )

  • Gets the large (184x184) avatar of the current user, which is a handle to be used in GetImageRGBA(), or 0 if none set.
  • Returns an int.

getMediumFriendAvatar( int steamID )

  • Gets the medium (64x64) avatar of the current user, which is a handle to be used in GetImageRGBA(), or 0 if none set.
  • Returns an int.

getPersonaName()

  • Get the user's Steam username.
  • Returns a string.

getPersonaState()

  • Gets the status of the current user.
  • Return an int; should be one of the following:
    • 0 - Offline
    • 1 - Online
    • 2 - Busy
    • 3 - Away
    • 4 - Snooze
    • 5 - Looking For Trade
    • 6 - Looking for Play

getPlayerAvatar( int size, int steamID )

  • Get player's avatar.
  • Triggers _avatar_loaded callback.
  • Returns nothing; void.

getPlayerNickname( int steamID )

  • Returns nickname the current user has set for the specified player. Returns NULL if the no nickname has been set for that player.
  • Returns a string.

getRecentPlayers()

  • Get list of players user has recently played game with.
  • Returns an array of:
    • player (dictionary)
      • id (int)
      • name (string)
      • time (int)
      • status (int)

getSmallFriendAvatar( int steamID )

  • Gets the small (32x32) avatar of the current user, which is a handle to be used in GetImageRGBA(), or 0 if none set.
  • Returns an int.

getUserFriendsGroups()

  • Get list of friends groups (tags) the user has created. This is not to be confused with Steam groups.
  • Returns an array of:
    • tags (dictionary)
      • id (int)
      • name (string)
      • members (int)

getUserRestrictions()

  • If current user is chat restricted, they can't send or receive any text or voice chat messages. The user can't see custom avatars. But the user can be online and send or receive game invites. A chat restricted user cannot add friends or join any groups.
  • Returns an int; it should be one of the following:
    • 0 - None
    • 1 - Unknown
    • 2 - Any Chat
    • 4 - Voice Chat
    • 8 - Group Chat
    • 16 - Rating
    • 32 - Game Invites
    • 64 - Trading

getUserSteamFriends()

  • Get a list of user's Steam friends; a mix of different Steamworks API friend functions.
  • Returns an array of:
    • friends (dictionary)
      • id (int)
      • name (string)
      • status (int)

getUserSteamGroups()

  • Get list of user's Steam groups; a mix of different Steamworks API group functions.
  • Returns an array of:
    • groups (dictionary)
      • id (int)
      • name (string)
      • tag (string)

hasFriend( int steamID, int friendFlags )

  • Returns true if the specified user meets any of the criteria specified in friendFlags:
    • 0x00 - None
    • 0x01 - Blocked
    • 0x02 - Friendship Requested
    • 0x04 - Immediate
    • 0x08 - Clan Member
    • 0x10 - On Game Server
    • 0x80 - Requesting Friendship
    • 0x100 - Requesting Info
    • 0x200 - Ignored
    • 0x400 - Ignored Friend
    • 0x0000 - Chat Member
    • 0xFFFF - All
  • Returns a bool.

inviteUserToGame( int steamID, string connectString )

  • Invite friend to current game/lobby.
  • Returns a bool.

isClanChatAdmin( int chatID, int steamID )

  • Checks if a user in the Steam group chat room is an admin.
  • Returns a bool.

isClanPublic( int clanID )

  • Checks if the Steam group is public.
  • Returns a bool.

isClanOfficialGameGroup( int clanID )

  • Checks if the Steam group is an official game group/community hub.
  • Returns a bool.

isClanChatWindowOpenInSteam( int chatID )

  • Checks if the Steam Group chat room is open in the Steam UI.
  • Returns a bool.

isFollowing( int steamID )

  • Checks if the current user is following the specified user.
  • Triggers _is_following callback.
  • Returns nothing; void.

isUserInSource( int steamID, int sourceID )

  • Find out if the local user can see that steamIDUser is a member or in steamIDSource.
  • Returns a bool.

joinClanChatRoom( int clanID )

  • Allows the user to join Steam group (clan) chats right within the game.
  • Triggers _join_clan_chat_complete
  • Returns nothing; void.

leaveClanChatRoom( int clanID )

  • Leaves a Steam group chat that the user has previously entered with JoinClanChatRoom.
  • Returns a bool.

openClanChatWindowInSteam( int chatID )

  • Opens the specified Steam group chat room in the Steam UI.
  • Returns a bool.

registerProtocolInOverlayBrowser( string protocol )

  • Call this before calling ActivateGameOverlayToWebPage() to have the Steam Overlay Browser block navigations to your specified protocol (scheme) uris and instead dispatch a OverlayBrowserProtocolNavigation_t callback to your game.
  • Returns a bool.

replyToFriendMessage( int steamID, string message )

  • Sends a message to a Steam friend.
  • Returns a bool.

requestClanOfficerList( int clanID )

  • Requests information about a clan officer list; when complete, data is returned in ClanOfficerListResponse_t call result.
  • Triggers _request_clan_officer_list callback.
  • Returns nothing; void.

requestFriendRichPresence( int friendID )

  • Requests rich presence for a specific user.
  • Returns nothing; void.

requestUserInformation( int steamID, bool requireNameOnly )

  • Requests information about a user, basically the persona name and avatar. If requireNameOnly is set, then the avatar of a user isn't downloaded.
  • Returns a bool.

sendClanChatMessage( int chatID, string text )

  • Sends a message to a Steam group chat room.
  • Returns a bool.

setInGameVoiceSpeaking( int steamID, bool speaking )

  • User is in a game pressing the talk button (will suppress the microphone for all voice comms from the Steam friends UI).
  • Returns nothing; void.

setListenForFriendsMessages( bool intercept )

  • Listens for Steam friends chat messages.
  • Returns a bool.

setPersonaName( string name )

  • Sets the player name, stores it on the server and publishes the changes to all friends who are online.
  • Triggers _name_changed callback.
  • Returns nothing; void.

setPlayedWith( int steamID )

  • Set player as 'Played With' for current game.
  • Returns nothing; void.

setRichPresence( string key, string value)

  • Set the game information in Steam; used in 'View Game Info'.
  • Returns a bool.

Game Search

addGameSearchParams( string key, string value )

  • A keyname and a list of comma separated values: one of which is must be found in order for the match to qualify; fails if a search is currently in progress.
  • Returns an int.

searchForGameWithLobby( int lobbyID, int playerMin, int playerMax)

  • All players in lobby enter the queue and await a SearchForGameNotificationCallback_t callback. Fails if another search is currently in progress. If not the owner of the lobby or search already in progress this call fails. Periodic callbacks will be sent as queue time estimates change.
  • Returns an int.

searchForGameSolo( int playerMin, int playerMax)

  • User enter the queue and await a SearchForGameNotificationCallback_t callback. fails if another search is currently in progress. Periodic callbacks will be sent as queue time estimates change.
  • Returns an int.

acceptGame()

  • After receiving SearchForGameResultCallback_t, accept or decline the game. Multiple SearchForGameResultCallback_t will follow as players accept game until the host starts or cancels the game.
  • Returns an int.

declineGame()

  • After receiving SearchForGameResultCallback_t, accept or decline the game. Multiple SearchForGameResultCallback_t will follow as players accept game until the host starts or cancels the game.
  • Returns an int.

retrieveConnectionDetails( int hostID )

  • After receiving GameStartedByHostCallback_t get connection details to server.
  • Returns a string.

endGameSearch()

  • Leaves queue if still waiting.
  • Returns an int.

setGameHostParams( string key, string value )

  • A keyname and a list of comma separated values: all the values you allow.
  • Returns an int.

setConnectionDetails( string details, int connectionDetails )

  • Set connection details for players once game is found so they can connect to this server.
  • Returns an int.

requestPlayersForGame( int playerMin, int playerMax, int maxTeamSize )

  • Mark server as available for more players with nPlayerMin,nPlayerMax desired. Accept no lobbies with playercount greater than nMaxTeamSize.
  • Returns an int.

hostConfirmGameStart( int gameID )

  • Accept the player list and release connection details to players.
  • Returns an int.

cancelRequestPlayersForGame()

  • Cancel request and leave the pool of game hosts looking for players.
  • Returns an int.

submitPlayerResult( int gameID, int playerID, int playerResult )

  • Submit a result for one player. does not end the game. ullUniqueGameID continues to describe this game.
  • Returns an int.

endGame( int gameID )

  • Ends the game. no further SubmitPlayerResults for ullUniqueGameID will be accepted.
  • Returns an int.

HTML Surface

addHeader( string key, string value )

  • Add a header to any HTTP requests from this browser.
  • Returns nothing; void.

allowStartRequest( bool allowed )

  • Sets whether a pending load is allowed or if it should be canceled. NOTE:You MUST call this in response to a HTML_StartRequest_t callback.
  • Returns nothing; void.

copyToClipboard( int browserHandle )

  • Copy the currently selected text from the current page in an HTML surface into the local clipboard.
  • Returns nothing; void.

createBrowser( string userAgent, string userCSS )

  • Create a browser object for displaying of an HTML page. NOTE: You MUST call RemoveBrowser when you are done using this browser to free up the resources associated with it. Failing to do so will result in a memory leak.
  • Returns nothing; void.

executeJavascript( string script )

  • Run a javascript script in the currently loaded page.
  • Returns nothing; void.

find( string search, bool currentlyInFind, bool reverse )

  • Find a string in the current page of an HTML surface. This is the equivalent of "ctrl+f" in your browser of choice. It will highlight all of the matching strings. You should call StopFind when the input string has changed or you want to stop searching.
  • Returns nothing; void.

getLinkAtPosition( int x, int y )

  • Retrieves details about a link at a specific position on the current page in an HTML surface.
  • Returns nothing; void.

goBack( int browserHandle )

  • Navigate back in the page history.
  • Returns nothing; void.

goForward( int browserHandle )

  • Navigate forward in the page history.
  • Returns nothing; void.

htmlInit()

  • Initializes the HTML Surface API. This must be called prior to using any other functions in this interface. You MUST call Shutdown when you are done using the interface to free up the resources associated with it. Failing to do so will result in a memory leak!
  • Returns nothing; void.

jsDialogResponse( bool result )

  • Allows you to react to a page wanting to open a javascript modal dialog notification.
  • Returns nothing; void.

keyChar( int unicodeChar, int keyModifiers )

  • cUnicodeChar is the unicode character point for this keypress (and potentially multiple chars per press).
  • Returns nothing; void.

keyDown( int nativeKeyCode, int keyModifiers )

  • Keyboard interactions, native keycode is the virtual key code value from your OS.
  • Returns nothing; void.

keyUp( int nativeKeyCode, int keyModifiers )

  • Keyboard interactions, native keycode is the virtual key code value from your OS.
  • Returns nothing; void.

loadURL( string url, string postData )

  • Navigate to a specified URL. If you send POST data with pchPostData then the data should be formatted as: name1=value1&name2=value2. You can load any URI scheme supported by Chromium Embedded Framework including but not limited to: http://, https://, ftp://, and file:///. If no scheme is specified then http:// is used.
  • Returns nothing; void.

mouseDoubleClick( int mouseButton )

  • Tells an HTML surface that a mouse button has been double clicked. The click will occur where the surface thinks the mouse is based on the last call to MouseMove.
  • Returns nothing; void.

mouseDown( int mouseButton )

  • Tells an HTML surface that a mouse button has been pressed. The click will occur where the surface thinks the mouse is based on the last call to MouseMove.
  • Returns nothing; void.

mouseMove( int x, int y )

  • Tells an HTML surface where the mouse is.
  • Returns nothing; void.

mouseUp( int mouseButton )

  • Tells an HTML surface that a mouse button has been released. The click will occur where the surface thinks the mouse is based on the last call to MouseMove.
  • Returns nothing; void.

mouseWheel( int delta )

  • Tells an HTML surface that the mouse wheel has moved.
  • Returns nothing; void.

pasteFromClipboard( int browserHandle )

  • Paste from the local clipboard to the current page in an HTML surface.
  • Returns nothing; void.

reload( int browserHandle )

  • Refreshes the current page. The reload will most likely hit the local cache instead of going over the network. This is equivalent to F5 or Ctrl+R in your browser of choice.
  • Returns nothing; void.

removeBrowser( int browserHandle )

  • You MUST call this when you are done with an HTML surface, freeing the resources associated with it. Failing to call this will result in a memory leak!
  • Returns nothing; void.

setBackgroundMode( bool backgroundMode )

  • Enable/disable low-resource background mode, where javascript and repaint timers are throttled, resources are more aggressively purged from memory, and audio/video elements are paused. When background mode is enabled, all HTML5 video and audio objects will execute ".pause()" and gain the property "._steam_background_paused = 1". When background mode is disabled, any video or audio objects with that property will resume with ".play()".
  • Returns nothing; void.

setCookie( string hostname, string key, string value, string path, int expires, bool secure, bool httpOnly )

  • Set a webcookie for a specific hostname. You can read more about the specifics of setting cookies here on wikipedia.
  • Returns nothing; void.

setHorizontalScroll( int absolutePixelScroll )

  • Scroll the current page horizontally.
  • Returns nothing; void.

setKeyFocus( bool hasKeyFocus )

  • Tell a HTML surface if it has key focus currently, controls showing the I-beam cursor in text controls amongst other things.
  • Returns nothing; void.

setPageScaleFactor( float zoom, int pointX, int pointY )

  • Zoom the current page in an HTML surface. The current scale factor is available from HTML_NeedsPaint_t.flPageScale, HTML_HorizontalScroll_t.flPageScale, and HTML_VerticalScroll_t.flPageScale.
  • Returns nothing; void.

setSize( int width, int height )

  • Sets the display size of a surface in pixels.
  • Returns nothing; void.

setVerticalScroll( int absolutePixelScroll )

  • Scroll the current page vertically.
  • Returns nothing; void.

htmlShutdown()

  • Shutdown the ISteamHTMLSurface interface, releasing the memory and handles. You MUST call this when you are done using this interface to prevent memory and handle leaks. After calling this then all of the functions provided in this interface will fail until you call Init to reinitialize again.
  • Returns a bool.

stopFind( int browserHandle )

  • Cancel a currently running find.
  • Returns nothing; void.

stopLoad( int browserHandle )

  • Stop the load of the current HTML page.
  • Returns nothing; void.

viewSource( int browserHandle )

  • Open the current pages HTML source code in default local text editor, used for debugging.
  • Returns nothing; void.

HTTP

createCookieContainer( bool allowResponsesToModify )

  • Creates a cookie container to store cookies during the lifetime of the process. This API is just for during process lifetime, after steam restarts no cookies are persisted and you have no way to access the cookie container across repeat executions of your process.
  • Returns nothing; void.

createHTTPRequest( int requestMethod, string absoluteURL )

  • Initializes a new HTTP request.
  • Returns nothing; void.

deferHTTPRequest( int requestHandle )

  • Defers a request which has already been sent by moving it at the back of the queue.
  • Returns a bool.

getHTTPDownloadProgressPct( int requestHandle )

  • Gets progress on downloading the body for the request.
  • Returns a float.

getHTTPRequestWasTimedOut( int requestHandle )

  • Check if the reason the request failed was because we timed it out (rather than some harder failure).
  • Returns a bool.

getHTTPResponseBodyData( int requestHandle, int bufferSize )

  • Gets the body data from an HTTP response.
  • Returns an PoolByteArray.

getHTTPResponseBodySize( int requestHandle )

  • Gets the size of the body data from an HTTP response.
  • Returns an int.

getHTTPResponseHeaderSize( int requestHandle, string headerName )

  • Checks if a header is present in an HTTP response and returns its size.
  • Returns an int.

getHTTPResponseHeaderValue( int requestHandle, string headerName, int bufferSize )

  • Gets a header value from an HTTP response.
  • Returns an int.

getHTTPStreamingResponseBodyData( int requestHandle, int offset, int bufferSize )

  • Gets the body data from a streaming HTTP response.
  • Returns an int.

prioritizeHTTPRequest( int requestHandle )

  • Prioritizes a request which has already been sent by moving it at the front of the queue.
  • Returns a bool.

releaseCookieContainer()

  • Releases a cookie container, freeing the memory allocated within Steam.
  • Returns a bool.

releaseHTTPRequest( int requestHandle )

  • Releases an HTTP request handle, freeing the memory allocated within Steam.
  • Returns a bool.

sendHTTPRequest( int requestHandle )

  • Sends an HTTP request.
  • Returns a bool.

sendHTTPRequestAndStreamResponse( int requestHandle )

  • Sends an HTTP request and streams the response back in chunks.
  • Returns a bool.

setHTTPCookie( string host, string url, string cookie )

  • Adds a cookie to the specified cookie container that will be used with future requests.
  • Returns a bool.

setHTTPRequestAbsoluteTimeoutMS( int requestHandle, int milliseconds )

  • Set an absolute timeout in milliseconds for the HTTP request. This is the total time timeout which is different than the network activity timeout which is set with SetHTTPRequestNetworkActivityTimeout which can bump everytime we get more data.
  • Returns a bool.

setHTTPRequestContextValue( int requestHandle, int contextValue )

  • Set a context value for the request, which will be returned in the HTTPRequestCompleted_t callback after sending the request. This is just so the caller can easily keep track of which callbacks go with which request data. Must be called before sending the request.
  • Returns a bool.

setHTTPRequestCookieContainer( int requestHandle, int cookieHandle )

  • Associates a cookie container to use for an HTTP request.
  • Returns a bool.

setHTTPRequestGetOrPostParameter( int requestHandle, string name, string value )

  • Set a GET or POST parameter value on the HTTP request. Must be called prior to sending the request.
  • Returns a bool.

setHTTPRequestHeaderValue( int requestHandle, string headerName, string headerValue )

  • Set a request header value for the HTTP request. Must be called before sending the request.
  • Returns a bool.

setHTTPRequestNetworkActivityTimeout( int requestHandle, int timeoutSeconds )

  • Set the timeout in seconds for the HTTP request.
  • Returns a bool.

setHTTPRequestRawPostBody( int requestHandle, string contentType, int bodyLen )

  • Sets the body for an HTTP Post request.
  • Returns an int.

setHTTPRequestRequiresVerifiedCertificate( int requestHandle, bool requireVerifiedCertificate )

  • Sets that the HTTPS request should require verified SSL certificate via machines certificate trust store. This currently only works Windows and macOS.
  • Returns a bool.

setHTTPRequestUserAgentInfo( int requestHandle, string userAgentInfo )

  • Set additional user agent info for a request.
  • Returns a bool.

Input

activateActionSet( int inputHandle, int actionSetHandle )

  • Reconfigure the controller to use the specified action set.
  • Returns nothing; void.

activateActionSetLayer( int inputHandle, int actionSetLayerHandle )

  • Reconfigure the controller to use the specified action set layer.
  • Returns nothing; void.

deactivateActionSetLayer( int inputHandle, int actionSetHandle )

  • Reconfigure the controller to stop using the specified action set.
  • Returns nothing; void.

deactivateAllActionSetLayers( int inputHandle )

  • Reconfigure the controller to stop using all action set layers.
  • Returns nothing; void.

getActionSetHandle( string actionSetName )

  • Lookup the handle for an action set.
  • Returns an int.

getActionOriginFromXboxOrigin( int inputHandle, int origin )

  • Get an action origin that you can use in your glyph look up table or passed into GetGlyphForActionOrigin or GetStringForActionOrigin.
  • Returns an int.

getActiveActionSetLayers( int inputHandle)

  • Fill an array with all of the currently active action set layers for a specified controller handle.
  • Returns an array.

getAnalogActionData( int inputHandle, int analogActionHandle )

  • Gets the current state of the supplied analog game action.
  • Returns a dictionary:
    • mode (int)
    • x (int)
    • y (int)
    • active (bool)

getAnalogActionHandle( string actionName )

  • Get the handle of the specified analog action.
  • Returns an int.

getAnalogActionOrigins( int inputHandle, int actionSetHandle, int analogActionHandle )

  • Get the origin(s) for an analog action within an action.
  • Returns an array.

getConnectedControllers()

  • Get current controllers handles.
  • Returns an array.

getControllerForGamepadIndex( int index )

  • Get the associated controller handle for the specified emulated gamepad.
  • Returns an int.

getCurrentActionSet( int inputHandle )

  • Get the currently active action set for the specified controller.
  • Returns an int.

getDeviceBindingRevision( int inputHandle )

  • Get's the major and minor device binding revisions for Steam Input API configurations. Minor revisions are for small changes such as adding a new option action or updating localization in the configuration. When updating a Minor revision only one new configuration needs to be update with the "Use Action Block" flag set. Major revisions are to be used when changing the number of action sets or otherwise reworking configurations to the degree that older configurations are no longer usable. When a user's binding disagree's with the major revision of the current official configuration Steam will forcibly update the user to the new configuration. New configurations will need to be made for every controller when updating the Major revision.
  • Returns an array.

getDigitalActionData( int inputHandle, int digitalActionHandle )

  • Gets the current state of the supplied digital game action.
  • Returns a dictionary:
    • state (bool)
    • active (bool)

getDigitalActionHandle( string actionName )

  • Get the handle of the specified digital action
  • Returns an int.

getDigitalActionOrigins( int inputHandle, int actionSetHandle, int digitalActionHandle )

  • Get the origin(s) for an analog action within an action.
  • Returns an array.

getGamepadIndexForController( int inputHandle )

  • Get the associated gamepad index for the specified controller.
  • Returns an int.

getGlyphForActionOrigin( int origin )

  • Get a local path to art for on-screen glyph for a particular origin.
  • Returns a string.

getInputTypeForHandle( int inputHandle )

  • Get the input type (device model) for the specified controller.
  • Returns a string.

getMotionData( int inputHandle )

  • Get raw motion data for the specified controller.
  • Returns a dictionary:
    • rotQuatX (float)
    • rotQuatY (float)
    • rotQuatZ (float)
    • rotQuatW (float)
    • posAccelX (float)
    • posAccelY (float)
    • posAccelZ (float)
    • rotVelX (float)
    • rotVelY (float)
    • rotVelZ (float)

getRemotePlaySessionID( int inputHandle )

  • Get the Steam Remote Play session ID associated with a device, or 0 if there is no session associated with it. See isteamremoteplay.h for more information on Steam Remote Play sessions.
  • Returns an int.

getStringforActionOrigin( int origin )

  • Returns a localized string (from Steam's language setting) for the specified origin.
  • Returns a string.

inputInit()

  • Start SteamControllers interface.
  • Returns a bool.

inputShutdown()

  • Stop SteamControllers interface.
  • Returns a bool.

setLEDColor( int inputHandle, int colorR, int colorG, int colorB, int flags )

  • Set the controller LED color on supported controllers.
  • Returns nothing; void.

runFrame()

  • Syncronize controllers.
  • Returns nothing; void.

showBindingPanel( int inputHandle )

  • Invokes the Steam overlay and brings up the binding screen.
  • Returns a bool.

stopAnalogActionMomentum( int inputHandle, int action )

  • Stops the momentum of an analog action (where applicable, ie a touchpad w/ virtual trackball settings).
  • Returns nothing; void.

translateActionOrigin( int destinationInput, int sourceOrigin )

  • Get the equivalent origin for a given controller type or the closest controller type that existed in the SDK you built into your game if eDestinationInputType is k_ESteamInputType_Unknown. This action origin can be used in your glyph look up table or passed into GetGlyphForActionOrigin or GetStringForActionOrigin.
  • Returns an int.

triggerHapticPulse( int inputHandle, int targetPad, int duration )

  • Triggers a (low-level) haptic pulse on supported controllers.
  • Returns nothing; void.

triggerRepeatedHapticPulse( intint targetPad, int duration, int offset, int repeat, int flags )

  • Triggers a repeated haptic pulse on supported controllers.
  • Returns nothing; void.

triggerVibration( int inputHandle, int leftSpeed, int rightSpeed )

  • Trigger a vibration event on supported controllers.
  • Returns nothing; void.

Inventory

addPromoItem( int item )

  • Grant a specific one-time promotional item to the current user.
  • Returns a bool.

addPromoItems( poolintarray items )

  • Grant a specific one-time promotional items to the current user.
  • Returns a bool.

checkResultSteamID( int steamIDExpected )

  • Checks whether an inventory result handle belongs to the specified Steam ID.
  • Returns a bool.

consumeItem( int itemConsume, int quantity )

  • Consumes items from a user's inventory. If the quantity of the given item goes to zero, it is permanently removed.
  • Returns a bool.

deserializeResult()

  • Deserializes a result set and verifies the signature bytes.
  • Returns a bool.

destroyResult()

  • Destroys a result handle and frees all associated memory.
  • Returns nothing; void.

exchangeItems( poolintarray outputItems, int outputQuantity, int inputItems, int inputQuantity )

  • Grant one item in exchange for a set of other items.
  • Returns a bool.

generateItems( poolintarray items, int quantity )

  • Grants specific items to the current user, for developers only.
  • Returns a bool.

getAllItems()

  • Start retrieving all items in the current users inventory.
  • Returns a bool.

getItemDefinitionProperty( int definition, string name )

  • Gets a string property from the specified item definition. Gets a property value for a specific item definition.
  • Returns a string.

getItemsByID( int idArray, int count )

  • Gets the state of a subset of the current user's inventory.
  • Returns a bool.

getItemPrice( int definition )

  • After a successful call to RequestPrices, you can call this method to get the pricing for a specific item definition.
  • Returns an int.

getItemsWithPrices( int length )

  • After a successful call to RequestPrices, you can call this method to get all the pricing for applicable item definitions. Use the result of GetNumItemsWithPrices as the the size of the arrays that you pass in.
  • Returns an array:
    • priceGroup (dictionary)
      • item (int)
      • price (int)
      • base_prices (int)

getNumItemsWithPrices()

  • After a successful call to RequestPrices, this will return the number of item definitions with valid pricing.
  • Returns an int.

getResultItemProperty( int index, string name )

  • Gets the dynamic properties from an item in an inventory result set.
  • Returns a string.

getResultItems()

  • Get the items associated with an inventory result handle.
  • Returns an array.

getResultStatus()

  • Find out the status of an asynchronous inventory result handle.
  • Returns a string.

getResultTimestamp()

  • Gets the server time at which the result was generated.
  • Returns an int.

grantPromoItems()

  • Grant all potential one-time promotional items to the current user.
  • Returns a bool.

loadItemDefinitions()

  • Triggers an asynchronous load and refresh of item definitions.
  • Triggers _inventory_definition_update callback.
  • Returns a bool.

requestEligiblePromoItemDefinitionsIDs( int steamID )

  • Request the list of "eligible" promo items that can be manually granted to the given user.
  • Triggers _inventory_eligible_promo_item callback.
  • Returns nothing; void.

requestPrices()

  • Request prices for all item definitions that can be purchased in the user's local currency. A SteamInventoryRequestPricesResult_t call result will be returned with the user's local currency code. After that, you can call GetNumItemsWithPrices and GetItemsWithPrices to get prices for all the known item definitions, or GetItemPrice for a specific item definition.
  • Triggers _inventory_request_prices_result callback.
  • Returns nothing; void.

serializeResult()

  • Serialized result sets contain a short signature which can't be forged or replayed across different game sessions.
  • Returns a bool.

startPurchase( poolintarray items, int quantity )

  • Starts the purchase process for the user, given a "shopping cart" of item definitions that the user would like to buy. The user will be prompted in the Steam Overlay to complete the purchase in their local currency, funding their Steam Wallet if necessary, etc.
  • Triggers _inventory_start_purchase_result callback.
  • Returns nothing; void.

transferItemQuantity( int itemID, int quantity, int itemDestination, bool split )

  • Transfer items between stacks within a user's inventory.
  • Returns a bool.

triggerItemDrop( int definition )

  • Trigger an item drop if the user has played a long enough period of time.
  • Returns a bool.

startUpdateProperties()

  • Starts a transaction request to update dynamic properties on items for the current user. This call is rate-limited by user, so property modifications should be batched as much as possible (e.g. at the end of a map or game session). After calling SetProperty or RemoveProperty for all the items that you want to modify, you will need to call SubmitUpdateProperties to send the request to the Steam servers. A SteamInventoryResultReady_t callback will be fired with the results of the operation.
  • Returns nothing; void.

submitUpdateProperties()

  • Submits the transaction request to modify dynamic properties on items for the current user. See StartUpdateProperties.
  • Returns a bool.

removeProperty( int itemID, string name )

  • Removes a dynamic property for the given item.
  • Returns a bool.

setPropertyString( int itemID, string name, string value )

  • Sets a dynamic property for the given item. Supported value types are strings.
  • Returns a bool.

setPropertyBool( int itemID, string name, bool value )

  • Sets a dynamic property for the given item. Supported value types are boolean.
  • Returns a bool.

setPropertyInt( int itemID, string name, int64 value )

  • Sets a dynamic property for the given item. Supported value types are 64 bit integers.
  • Returns a bool.

setPropertyFloat( int itemID, string name, float value )

  • Sets a dynamic property for the given item. Supported value types are 32 bit floats.
  • Returns a bool.

Matchmaking

getFavoriteGames()

  • Get an array of the user's favorite game servers.
  • Returns an array of:
    • favorite (dictionary)
      • ip (string)
      • port (int)
      • query_port (int)
      • flags (int)
      • last_played (int)

addFavoriteGame( int appID, int ip, int port, int queryPort, int flags, int lastPlayed )

  • Adds the game server to the local list; updates the time played of the server if it already exists in the list.
  • Returns an int.

removeFavoriteGame( int appID, int ip, int port, int queryPort, int flags )

  • Removes the game server from the local storage.
  • Returns a bool.

requestLobbyList()

  • Get a list of relevant lobbies.
  • Triggers _lobby_match_list callback.
  • Returns nothing; void.

addRequestLobbyListStringFilter( string keyToMatch, string valueToMatch, int comparisonType )

  • Adds a string comparison filter to the next RequestLobbyList call.
  • Returns nothing; void.

addRequestLobbyListNumericalFilter( string keyToMatch, int valueToMatch, int comparisonType )

  • Adds a numerical comparison filter to the next RequestLobbyList call.
  • Returns nothing; void.

addRequestLobbyListNearValueFilter( string keyToMatch, int valueToBeCloseTo )

  • Gets results closest to the specified value. Multiple near filters can be added, with early filters taking precedence.
  • Returns nothing; void.

addRequestLobbyListFilterSlotsAvailable( int slotsAvailable )

  • Gets only lobbies with the specified number of slots available.
  • Returns nothing; void.

addRequestLobbyListDistanceFilter( int distanceFilter )

  • Sets the distance for which we should search for lobbies (based on users IP address to location map on the Steam backed).
  • Returns nothing; void.

addRequestLobbyListResultCountFilter( int maxResults )

  • Sets how many results to return, the lower the count the faster it is to download the lobby results & details to the client.
  • Returns nothing; void.

createLobby( int lobbyType, int maxMembers )

  • Create a lobby on the Steam servers, if private the lobby will not be returned by any RequestLobbyList() call.
  • Triggers _lobby_created callback.
  • Returns nothing; void.

joinLobby( int steamIDLobby )

  • Join an existing lobby.
  • Triggers _lobby_joined callback for other users.
  • Returns nothing; void.

leaveLobby( int steamIDLobby )

  • Leave a lobby, this will take effect immediately on the client side, other users will be notified by callback.
  • Returns nothing; void.

inviteUserToLobby( int steamIDLobby, int steamIDInvitee )

  • Invite another user to the lobby. The target user will receive a _lobby_invite callback.
  • Returns a bool.

getNumLobbyMembers( int steamIDLobby )

  • Lobby iteration; for viewing details of users in a lobby.
  • Returns an int.

getLobbyMemberByIndex( int steamIDLobby, int member )

  • Gets the Steam ID of a user in the lobby.
  • Returns an int.

getLobbyData( int steamIDLobby, string key )

  • Get data associated with this lobby.
  • Returns a string.

setLobbyData( int steamIDLobby, string key, string value )

  • Sets a key/value pair in the lobby metadata.
  • Returns a bool.

getAllLobbyData

  • Get lobby data by the lobby's ID.
  • Returns a dictionary:
    • index (int)
    • key (string)
    • value (string)

deleteLobbyData( int steamIDLobby, string key )

  • Removes a metadata key from the lobby.
  • Returns a bool.

getLobbyMemberData( int steamIDLobby, int steamIDUser, string key )

  • Gets per-user metadata for someone in this lobby.
  • Returns a string.

setLobbyMemberData( int steamIDLobby, string key, string value )

  • Sets per-user metadata (for the local user implicitly).
  • Returns nothing; void.

sendLobbyChatMsg( int steamIDLobby, string messageBody )

  • Broadcasts a chat message to the all the users in the lobby. Those users should receive a _lobby_Message callback.
  • Returns a bool.

requestLobbyData( int steamIDLobby )

  • Refreshes metadata for a lobby you're not necessarily in right now.
  • Returns a bool.

setLobbyGameServer( int steamIDLobby, string serverIP, int serverPort, int steamIDGameServer )

  • Sets the game server associated with the lobby.
  • Triggers _lobby_game_created callback.
  • Returns nothing; void.

getLobbyGameServer( int steamIDLobby )

  • Gets the details of a game server set in a lobby.
  • Returns a dictionary:
    • ip (string)
    • port (int)
    • id (int)

setLobbyMemberLimit( int steamIDLobby, int maxMembers )

  • Set the limit on the number of users who can join the lobby.
  • Returns a bool.

getLobbyMemberLimit( int steamIDLobby )

  • Returns the current limit on the # of users who can join the lobby.
  • Returns an int.

setLobbyType( int steamIDLobby, int eLobbyType )

  • Updates which type of lobby it is.
  • Returns a bool.

setLobbyJoinable( int steamIDLobby, bool joinable )

  • Sets whether or not a lobby is joinable; defaults to true for a new lobby.
  • Returns a bool.

getLobbyOwner( int steamIDLobby )

  • Get the current lobby owner.
  • Returns an int.

setLobbyOwner( int steamIDLobby, int steamIDNewOwner )

  • Changes who the lobby owner is.
  • Return a bool.

setLinkedLobby( int steamIDLobby, int steamIDLobbyDependent )

  • Link two lobbies for the purposes of checking player compatibility.
  • Returns a bool.

Matchmaking Servers

cancelQuery( int serverListRequest )

  • Cancel an outstanding server list request.
  • Returns nothing; void.

cancelServerQuery( int serverQuery )

  • Cancel an outstanding individual server query.
  • Returns nothing; void.

getServerCount( int serverListRequest )

  • Gets the number of servers in the given list.
  • Returns an int.

getServerDetails( int serverListRequest, int server )

  • Get the details of a given server in the list.
  • Returns a dictionary:
    • ping (int)
    • success_response (bool)
    • no_refresh (bool)
    • game_dir (string)
    • map (string)
    • description (string)
    • app_id (int)
    • players (int)
    • max_players (int)
    • bot_players (int)
    • password (bool)
    • secure (bool)
    • last_played (int)
    • server_version (int)

isRefreshing( int serverListRequest )

  • Returns true if the list is currently refreshing its server list.
  • Returns a bool.

pingServer( string ip, int port )

  • Queries an individual game servers directly via IP/Port to request an updated ping time and other details from the server.
  • Currently not enabled.
  • Returns an int.

playerDetails( string ip, int port )

  • Request the list of players currently playing on a server.
  • Currently not enabled.
  • Returns an int.

refreshQuery( int serverListRequest )

  • Ping every server in your list again but don't update the list of servers. Query callback installed when the server list was requested will be used again to post notifications and RefreshComplete, so the callback must remain valid until another RefreshComplete is called on it or the request is released with ReleaseRequest( hRequest ).
  • Returns nothing; void.

refreshServer( int serverListRequest, int server )

  • Refresh a single server inside of a query (rather than all the servers).
  • Returns nothing; void.

releaseRequest( int serverListRequest )

  • Releases the asynchronous request object and cancels any pending query on it if there's a pending query in progress.
  • Returns nothing; void.

requestFavoritesServerList( int appID, array filters )

  • Request a new list of servers of a particular type. These calls each correspond to one of the EMatchMakingType values.
  • Currently not enabled.
  • Returns an int.

requestFriendsServerList( int appID, array filters )

  • Request a new list of servers of a particular type. These calls each correspond to one of the EMatchMakingType values.
  • Currently not enabled.
  • Returns an int.

requestHistoryServerList( int appID, array filters )

  • Request a new list of servers of a particular type. These calls each correspond to one of the EMatchMakingType values.
  • Currently not enabled.
  • Returns an int.

requestInternetServerList( int appID, array filters )

  • Request a new list of servers of a particular type. These calls each correspond to one of the EMatchMakingType values.
  • Currently not enabled.
  • Returns an int.

requestLANServerList( int appID, array filters )

  • Request a new list of servers of a particular type. These calls each correspond to one of the EMatchMakingType values.
  • Currently not enabled.
  • Returns an int.

requestSpectatorServerList( int appID, array filters )

  • Request a new list of servers of a particular type. These calls each correspond to one of the EMatchMakingType values.
  • Currently not enabled.
  • Returns an int.

serverRules( int ip, int port )

  • Request the list of rules that the server is running (See ISteamGameServer::SetKeyValue() to set the rules server side).
  • Currently not enabled.
  • Returns an int.

Music

musicIsEnabled()

  • Is Steam music enabled?
  • Returns a bool.

musicIsPlaying()

  • Is Steam music playing something?
  • Returns a bool.

musicGetVolume()

  • Get the volume level of the music.
  • Returns a float.

musicPause()

  • Pause whatever Steam music is playing.
  • Returns nothing; void.

musicPlay()

  • Play current track/album.
  • Returns nothing; void.

musicPlayNext()

  • Play next track/album.
  • Returns nothing; void.

musicPlayPrev()

  • Play previous track/album.
  • Returns nothing; void.

musicSetVolume( float value )

  • Set the volume of Steam music. Must pass a float between 0.0 and 1.0.
  • Returns nothing; void.

Music Remote

activationSuccess( bool value )

  • If remote access was successfully activated.
  • Returns a bool.

isCurrentMusicRemote()

  • Is a remote music client / host connected?
  • Returns a bool.

currentEntryDidChange()

  • Did the currenty music entry just change?
  • Returns a bool.

currentEntryIsAvailable( bool available )

  • Is the current music entry available?
  • Returns a bool.

currentEntryWillChange()

  • Will the current music entry change?
  • Returns a bool.

deregisterSteamMusicRemote()

  • Disconnect from remote music client / host.
  • Returns a bool.

enableLooped( bool value )

  • Enable track loop on client.
  • Returns a bool.

enablePlaylists( bool value )

  • Enable playlists on client.
  • Returns a bool.

enablePlayNext( bool value )

  • Play the next track on client.
  • Returns a bool.

enablePlayPrevious( bool value )

  • Play previous track on client.
  • Returns a bool.

enableQueue( bool value )

  • Enable the music queue on the client.
  • Returns a bool.

enableShuffled( bool value )

  • Enable shuffle on the client.
  • Returns a bool.

playlistDidChange()

  • Has the playlist changed?
  • Returns a bool.

playlistWillChange()

  • Will the playlist change?
  • Returns a bool.

queueDidChange()

  • Did the song queue change?
  • Returns a bool.

queueWillChange()

  • Will the song queue change?
  • Returns a bool.

registerSteamMusicRemote( string name )

  • Connect to a music remote client / host?
  • Returns a bool.

resetPlaylistEntries()

  • Reset the playlist entries.
  • Returns a bool.

resetQueueEntries()

  • Reset the song queue entries.
  • Returns a bool.

setCurrentPlaylistEntry( int id )

  • Set a new current playlist.
  • Returns a bool.

setCurrentQueueEntry( int id )

  • Set a new current song queue.
  • Returns a bool.

setDisplayName( string name )

  • Set a new display name.
  • Returns a bool.

setPlaylistEntry( int id, int position, string entryText )

  • Set a new playlist entry.
  • Returns a bool.

setPNGIcon64x64(const PoolByteArray& icon )

  • Set a PNG icon for a song? A playlist?
  • Currently not enabled.
  • Returns a bool.

setQueueEntry( int id, int position, string entryText )

  • Set a new queue entry.
  • Returns a bool.

updateCurrentEntryCoverArt( PoolByteArray art )

  • Update the current song entry's cover art.
  • Currently not enabled.
  • Returns a bool.

updateCurrentEntryElapsedSeconds( int value )

  • Update the current seconds that have elapsed for an entry.
  • Returns a bool.

updateCurrentEntryText( string text )

  • Update the current song entry's text?
  • Returns a bool.

updateLooped( bool value )

  • Update looped or not.
  • Returns a bool.

updatePlaybackStatus( int status )

  • Update the current playback status; 0 - undefined, 1 - playing, 2 - paused, 3 - idle.
  • Returns a bool.

updateShuffled( bool value )

  • Update whether to shuffle or not.
  • Returns a bool.

updateVolume( float value )

  • Volume is between 0.0 and 1.0.
  • Returns a bool.

Networking

acceptP2PSessionWithUser( int steamIDRemote )

  • This allows the game to specify accept an incoming packet.
  • Returns a bool.

allowP2PPacketRelay( bool allow )

  • Allow or disallow P2P connections to fall back to being relayed through the Steam servers if a direct connection or NAT-traversal cannot be established.
  • Returns a bool.

closeP2PChannelWithUser( int steamIDRemote, int channel )

  • Closes a P2P channel when you're done talking to a user on the specific channel.
  • Returns a bool.

closeP2PSessionWithUser( int steamIDRemote )

  • This should be called when you're done communicating with a user, as this will free up all of the resources allocated for the connection under-the-hood.
  • Returns a bool.

getP2PSessionState( int steamIDRemote )

  • Fills out a P2PSessionState_t structure with details about the connection like whether or not there is an active connection.
  • Returns a dictionary:
    • connection_active (bool)
    • connecting (bool)
    • session_error (int)
    • using_relay (bool)
    • bytes_queued_for_send (int)
    • packets_queued_for_send (int)
    • remote_ip (int)
    • remote_port (int)

getAvailableP2PPacketSize( int channel )

  • Calls IsP2PPacketAvailable() under the hood, returns the size of the available packet or zero if there is no such packet.
  • Returns an int.

readP2PPacket( int packet, int channel )

  • Reads in a packet that has been sent from another user via SendP2PPacket.
  • Returns a dictionary:
    • data (PoolByteArray)
    • steamIDRemote (int)

sendP2PPacket( int steamIDRemote, array data, int sendType, int channel )

  • Sends a P2P packet to the specified user.
  • Returns a bool.

Networking Messages

sendMessageToUser( string message, int flags, int channel )

  • Sends a message to the specified host. If we don't already have a session with that user, a session is implicitly created. There might be some handshaking that needs to happen before we can actually begin sending message data.
  • Returns an int.

receiveMessagesOnChannel( int channel, int max_messages )

  • Reads the next message that has been sent from another user via SendMessageToUser() on the given channel. Returns number of messages returned into your list. (0 if no message are available on that channel.)
  • Currently not enabled.
  • Returns an array of:
    • messages (dictionary)
      • payload (string)
      • size (int)
      • connection (int)
      • identity (string)
      • user_data (int)
      • time_received (int)
      • message_number (int)
      • channel (int)
      • flags (int)
      • user_data (int)

acceptSessionWithUser()

  • AcceptSessionWithUser() should only be called in response to a SteamP2PSessionRequest_t callback SteamP2PSessionRequest_t will be posted if another user tries to send you a message, and you haven't tried to talk to them.
  • Returns a bool.

closeSessionWithUser()

  • Call this when you're done talking to a user to immediately free up resources under-the-hood.
  • Returns a bool.

closeChannelWithUser( int channel )

  • Call this when you're done talking to a user on a specific channel. Once all open channels to a user have been closed, the open session to the user will be closed, and any new data from this user will trigger a SteamP2PSessionRequest_t callback.
  • Returns a bool.

getSessionConnectionInfo()

  • Returns information about the latest state of a connection, if any, with the given peer.
  • Returns an int.

Networking Sockets

createListenSocketIP( int options )

  • Creates a "server" socket that listens for clients to connect to by calling ConnectByIPAddress, over ordinary UDP (IPv4 or IPv6)
  • Returns an int.

connectByIPAddress( int ip, int port, array options )

  • Creates a connection and begins talking to a "server" over UDP at the given IPv4 or IPv6 address. The remote host must be listening with a matching call to ISteamnetworkingSockets::CreateListenSocketIP on the specified port.
  • Currently not enabled.
  • Returns an int.

createListenSocketP2P( int port, int optionSize )

  • Like CreateListenSocketIP, but clients will connect using ConnectP2P. The connection will be relayed through the Valve network.
  • Returns an int.

connectP2P( int port, int numOptions )

  • Begin connecting to a server that is identified using a platform-specific identifier. This uses the default rendezvous service, which depends on the platform and library configuration. (E.g. on Steam, it goes through the steam backend.) The traffic is relayed over the Steam Datagram Relay network.
  • Returns an int.

acceptConnection( int connection )

  • Accept an incoming connection that has been received on a listen socket.
  • Returns an int.

closeConnection( int peer, int reason, bool linger )

  • Disconnects from the remote host and invalidates the connection handle. Any unread data on the connection is discarded.
  • Returns a bool.

closeListenSocket( int socket )

  • Destroy a listen socket. All the connections that were accepted on the listen socket are closed ungracefully.
  • Returns a bool.

createSocketPair( bool loopback, string identity1, string identity2 )

  • Create a pair of connections that are talking to each other, e.g. a loopback connection. This is very useful for testing, or so that your client/server code can work the same even when you are running a local "server".
  • Currently not enabled.
  • Returns a dictionary:
    • success (bool)
    • connection1 (int)
    • connection2 (int)

sendMessageToConnection( int connection, string message, int flags )

  • Send a message to the remote host on the specified connection.
  • Returns an int.

sendMessages( int messages, string message, int connection, int flags )

  • Send one or more messages without copying the message payload. This is the most efficient way to send messages. To use this function, you must first allocate a message object using ISteamNetworkingUtils::AllocateMessage. (Do not declare one on the stack or allocate your own.)
  • Currently not enabled.
  • Returns nothing; void.

flushMessagesOnConnection( int connection )

  • Flush any messages waiting on the Nagle timer and send them at the next transmission opportunity (often that means right now).
  • Returns an int.

receiveMessagesOnConnection( int connection, int max_messages )

  • Fetch the next available message(s) from the connection, if any. Returns the number of messages returned into your array, up to nMaxMessages. If the connection handle is invalid, -1 is returned. If no data is available, 0, is returned.
  • Returns an array of:
    • messages (dictionary)
      • payload (string)
      • size (int)
      • connection (int)
      • identity (string)
      • user_data (int)
      • time_received (int)
      • message_number (int)
      • channel (int)
      • flags (int)
      • user_data (int)

createPollGroup()

  • Create a new poll group.
  • Returns an int.

destroyPollGroup( int pollGroup )

  • Destroy a poll group created with CreatePollGroup.
  • Returns a bool.

setConnectionPollGroup( int connection, int pollGroup )

  • Assign a connection to a poll group. Note that a connection may only belong to a single poll group. Adding a connection to a poll group implicitly removes it from any other poll group it is in.
  • Returns a bool.

receiveMessagesOnPollGroup( int pollGroup, int max_messages )

  • Same as ReceiveMessagesOnConnection, but will return the next messages available on any connection in the poll group. Examine SteamNetworkingMessage_t::m_conn to know which connection. (SteamNetworkingMessage_t::m_nConnUserData might also be useful.)
  • Returns an array of:
    • messages (dictionary)
      • payload (string)
      • size (int)
      • connection (int)
      • identity (string)
      • user_data (int)
      • time_received (int)
      • message_number (int)
      • channel (int)
      • flags (int)
      • user_data (int)

getConnectionInfo( int connection )

  • Returns basic information about the high-level state of the connection. Returns false if the connection handle is invalid.
  • Returns a bool.

getQuickConnectionStatus( int connection )

  • Returns a small set of information about the real-time state of the connection. Returns false if the connection handle is invalid, or the connection has ended.
  • Returns a bool.

getDetailedConnectionStatus( int connection )

  • Returns very detailed connection stats in diagnostic text format. Useful for dumping to a log, etc. The format of this information is subject to change.
  • Returns a dictionary:
    • success (int)
    • buffer (string)

getConnectionUserData( int peer )

  • Fetch connection user data. Returns -1 if handle is invalid or if you haven't set any userdata on the connection.
  • Returns an int.

setConnectionName( int peer, string name )

  • Set a name for the connection, used mostly for debugging.
  • Returns nothing; void.

getConnectionName( int peer )

  • Fetch connection name into your buffer, which is at least nMaxLen bytes. Returns false if handle is invalid.
  • Returns a strong.

getListenSocketAddress( int socket )

  • Returns local IP and port that a listen socket created using CreateListenSocketIP is bound to.
  • Returns a bool.

getIdentity()

  • Get the identity assigned to this interface.
  • Returns a bool.

initAuthentication()

  • Indicate our desire to be ready participate in authenticated communications. If we are currently not ready, then steps will be taken to obtain the necessary certificates. (This includes a certificate for us, as well as any CA certificates needed to authenticate peers.)
  • Returns an int.

getAuthenticationStatus()

  • Query our readiness to participate in authenticated communications. A SteamNetAuthenticationStatus_t callback is posted any time this status changes, but you can use this function to query it at any time.
  • Returns an int.

receivedRelayAuthTicket( int ticketSize )

  • Call this when you receive a ticket from your backend / matchmaking system. Puts the ticket into a persistent cache, and optionally returns the parsed ticket.
  • Currently not enabled.
  • Returns a bool.

findRelayAuthTicketForServer( int gameServer, int port )

  • Search cache for a ticket to talk to the server on the specified virtual port. If found, returns the number of seconds until the ticket expires, and optionally the complete cracked ticket. Returns 0 if we don't have a ticket.
  • Currently not enabled.
  • Returns an int.

connectToHostedDedicatedServer( int port, int options )

  • Client call to connect to a server hosted in a Valve data center, on the specified virtual port. You must have placed a ticket for this server into the cache, or else this connect attempt will fail!
  • Returns an int.

getHostedDedicatedServerPort()

  • Returns the value of the SDR_LISTEN_PORT environment variable. This is the UDP server your server will be listening on. This will configured automatically for you in production environments.
  • Returns an int.

getHostedDedicatedServerPOPId()

  • Returns 0 if SDR_LISTEN_PORT is not set. Otherwise, returns the data center the server is running in. This will be k_SteamDatagramPOPID_dev in non-production envirionment.
  • Returns an int.

getHostedDedicatedServerAddress()

  • Return info about the hosted server. This contains the PoPID of the server, and opaque routing information that can be used by the relays to send traffic to your server.
  • Currently not enabled.
  • Returns an int.

createHostedDedicatedServerListenSocket( int port, int options )

  • Create a listen socket on the specified virtual port. The physical UDP port to use will be determined by the SDR_LISTEN_PORT environment variable. If a UDP port is not configured, this call will fail.
  • Returns an int.

getGameCoordinatorServerLogin()

  • Generate an authentication blob that can be used to securely login with your backend, using SteamDatagram_ParseHostedServerLogin. (See steamdatagram_gamecoordinator.h)
  • Currently not enabled.
  • Returns an int.

Networking Utils

initRelayNetworkAccess()

  • If you know that you are going to be using the relay network (for example, because you anticipate making P2P connections), call this to initialize the relay network. If you do not call this, the initialization will be delayed until the first time you use a feature that requires access to the relay network, which will delay that first access.
  • Returns nothing; void.

getRelayNetworkStatus()

  • Fetch current status of the relay network. If you want more details, you can pass a non-NULL value.
  • Returns an int.

getLocalPingLocation()

  • Return location info for the current host. Returns the approximate age of the data, in seconds, or -1 if no data is available.
  • Returns a float.

estimatePingTimeBetweenTwoLocations( int location1, int location2 )

  • Estimate the round-trip latency between two arbitrary locations, in milliseconds. This is a conservative estimate, based on routing through the relay network. For most basic relayed connections, this ping time will be pretty accurate, since it will be based on the route likely to be actually used.
  • Returns an int.

estimatePingTimeFromLocalHost( int location )

  • Same as EstimatePingTime, but assumes that one location is the local host. This is a bit faster, especially if you need to calculate a bunch of these in a loop to find the fastest one.
  • Returns an int.

convertPingLocationToString( int location )

  • Convert a ping location into a text format suitable for sending over the wire. The format is a compact and human readable. However, it is subject to change so please do not parse it yourself. Your buffer must be at least k_cchMaxSteamNetworkingPingLocationString bytes.
  • Returns a string.

parsePingLocationString( string string )

  • Parse back SteamNetworkPingLocation_t string. Returns false if we couldn't understand the string.
  • Returns a bool.

checkPingDataUpToDate( float maxAgeInSeconds )

  • Check if the ping data of sufficient recency is available, and if it's too old, start refreshing it.
  • Returns a bool.

isPingMeasurementInProgress()

  • Return true if we are taking ping measurements to update our ping location or select optimal routing. Ping measurement typically takes a few seconds, perhaps up to 10 seconds.
  • Currently no enabled. This is in the documentation but not in the actual header file.
  • Returns a bool.

getPingToDataCenter( int popID, int viaRelayPOP )

  • Fetch ping time of best available relayed route from this host to the specified data center.
  • Returns an int.

getDirectPingToPOP( int popID )

  • Get *direct* ping time to the relays at the point of presence.
  • Returns an int.

getPOPCount()

  • Get number of network points of presence in the config.
  • Returns an int.

getPOPList()

  • Get list of all POP IDs. Returns the number of entries that were filled into your list.
  • Returns an int.

setConfigValue( int setting, int scopeType, int dataType )

  • Set a configuration value.
  • Currently no enabled.
  • Returns a bool.

getConfigValue( int value, int scopeType )

  • Get a configuration value.
  • Currently not enabled.
  • Returns a dictionary:
    • result (int)
    • type (int)
    • value (string)
    • buffer (int)

getConfigValueInfo( int value )

  • Returns info about a configuration value.
  • Returns a dictionary:
    • success (bool)
    • value (string)
    • type (int)
    • scope (int)
    • next_value (int)

getFirstConfigValue()

  • Returns info about a configuration value. Returns false if the value does not exist.
  • Returns an int.

setGlobalConfigValueInt32( int config, int value )

  • The following functions are handy shortcuts for common use cases.
  • Returns a bool.

setGlobalConfigValueFloat( int config, float value )

  • Returns a bool.

setGlobalConfigValueString( int config, string value )

  • Returns a bool.

setConnectionConfigValueInt32( int connection, int config, int value )

  • Returns a bool.

setConnectionConfigValueFloat( int connection, int config, float value )

  • Returns a bool.

setConnectionConfigValueString( int connection, int config, string value )

  • Returns a bool.

allocateMessage( int buffer )

  • Allocate and initialize a message object. Usually the reason you call this is to pass it to ISteamNetworkingSockets::SendMessages. The returned object will have all of the relevant fields cleared to zero.
  • Returns nothing; void.

getLocalTimestamp()

  • A general purpose high resolution local timer with the following properties: Monotonicity is guaranteed. The initial value will be at least 24*3600*30*1e6, i.e. about 30 days worth of microseconds. In this way, the timestamp value of 0 will always be at least "30 days ago". Also, negative numbers will never be returned. Wraparound / overflow is not a practical concern.
  • Returns an int.

setDebugOutputFunction( int detailLevel, string function )

  • Set a function to receive network-related information that is useful for debugging.
  • Currently not enabled.
  • Returns nothing; void.

Parties

getAvailableBeaconLocations( int max )

  • Get the list of locations in which you can post a party beacon.
  • Returns an array of:
    • beaconData (dictionary)
      • type (int)
      • locationID (int)

createBeacon( int openSlots, int location, int type, string connectString, string metadata )

  • Create a beacon. You can only create one beacon at a time. Steam will display the beacon in the specified location, and let up to unOpenSlots users "follow" the beacon to your party.
  • Triggers a _create_beacon call result.
  • Returns nothing; void.

onReservationCompleted( int beacon, int steamID )

  • When a user follows your beacon, Steam will reserve one of the open party slots for them, and send your game a ReservationNotificationCallback_t callback. When that user joins your party, call OnReservationCompleted to notify Steam that the user has joined successfully.
  • Triggers a _reservation_notification callback.
  • Returns nothing; void.

cancelReservation( int beacon, int steamID )

  • To cancel a reservation (due to timeout or user input), call this. Steam will open a new reservation slot. Note: The user may already be in-flight to your game, so it's possible they will still connect and try to join your party.
  • Returns nothing; void.

changeNumOpenSlots( int beacon, int openSlots )

  • If a user joins your party through other matchmaking (perhaps a direct Steam friend, or your own matchmaking system), your game should reduce the number of open slots that Steam is managing through the party beacon. For example, if you created a beacon with five slots, and Steam sent you two ReservationNotificationCallback_t callbacks, and then a third user joined directly, you would want to call ChangeNumOpenSlots with a value of 2 for unOpenSlots. That value represents the total number of new users that you would like Steam to send to your party.
  • Triggers a _change_num_open_slots call result.
  • Returns nothing; void.

destroyBeacon( int beacon )

  • Call this method to destroy the Steam party beacon. This will immediately cause Steam to stop showing the beacon in the target location. Note that any users currently in-flight may still arrive at your party expecting to join.
  • Returns a bool.

getNumActiveBeacons()

  • Get the number of active party beacons created by other users for your game, that are visible to the current user.
  • Returns an int.

getBeaconByIndex( int index )

  • Use with ISteamParties::GetNumActiveBeacons to iterate the active beacons visible to the current user. unIndex is a zero-based index, so iterate over the range [0, GetNumActiveBeacons() - 1]. The return is a PartyBeaconID_t that can be used with ISteamParties::GetBeaconDetails to get information about the beacons suitable for display to the user.
  • Returns an int.

getBeaconDetails( int beacon )

  • Get details about the specified beacon. You can use the ISteamFriends API to get further details about pSteamIDBeaconOwner, and ISteamParties::GetBeaconLocationData to get further details about pLocation. The pchMetadata contents are specific to your game, and will be whatever was set (if anything) by the game process that created the beacon.
  • Returns a dictionary:
    • id (int)
    • owner (int)
    • type (int)
    • location (int)
    • metadata (string)

joinParty( int beacon )

  • When the user indicates they wish to join the party advertised by a given beacon, call this method. On success, Steam will reserve a slot for this user in the party and return the necessary "join game" string to use to complete the connection.
  • Triggers a _join_party call result.
  • Returns nothing; void.

getBeaconLocationData( int locationID, int locationType, int locationData )

  • Query general metadata for the given beacon location. For instance the Name, or the URL for an icon if the location type supports icons (for example, the icon for a Steam Chat Room Group).
  • Returns a string.

Remote Play

getSessionCount()

  • Get the number of currently connected Steam Remote Play sessions.
  • Returns an int.

getSessionID( int index )

  • Get the currently connected Steam Remote Play session ID at the specified index.
  • Returns an int.

getSessionSteamID( int sessionID )

  • Get the SteamID of the connected user.
  • Returns an int.

getSessionClientName( int sessionID )

  • Get the name of the session client device.
  • Returns a string.

getSessionClientFormFactor( int sessionID )

  • Get the form factor of the session client device.
  • Returns an int.

getSessionClientResolution( int sessionID )

  • Get the resolution, in pixels, of the session client device. This is set to 0x0 if the resolution is not available.
  • Returns a dictionary:
    • success (bool)
    • x (int)
    • y (int)

sendRemotePlayTogetherInvite( int friendID )

  • Invite a friend to join the game using Remote Play Together
  • Returns a bool.

Remote Storage

fileDelete( string file )

  • Delete user file from remote online storage.
  • Returns a bool.

fileExists( string file )

  • Check if a remote file exists.
  • Returns a bool.

fileForget( string file )

  • Deletes the file from remote storage, but leaves it on the local disk and remains accessible from the API.
  • Returns a bool.

filePersisted( string file )

  • Checks if a specific file is persisted in the Steam Cloud. Depreciated: PS3 Only
  • Returns a bool.

fileRead( string file, int dataToRead )

  • Read user file from remote online storage.
  • Returns a dictionary:
    • ret (bool)
    • buf (PoolByteArray)

fileReadAsync( string file, int offset, int dataToRead )

  • Starts an asynchronous read from a file. The offset and amount to read should be valid for the size of the file, as indicated by GetFileSize or GetFileTimestamp.
  • Triggers a _file_read_async_complete call result.
  • Returns nothing; void.

fileShare( string file )

  • Share a file.
  • Triggers a _file_share_result call result.
  • Returns nothing; void.

fileWrite( string file, PoolByteArray data, int data )

  • Write user file to remote online storage.
  • Returns a bool.

fileWriteAsync( string file, PoolByteArray data, int dataSize )

  • Creates a new file and asynchronously writes the raw byte data to the Steam Cloud, and then closes the file. If the target file already exists, it is overwritten.
  • Triggers a _file_write_async_complete call result.
  • Returns nothing; void.

fileWriteStreamCancel( int writeHandle )

  • Cancels a file write stream that was started by FileWriteStreamOpen. This trashes all of the data written and closes the write stream, but if there was an existing file with this name, it remains untouched.
  • Returns a bool.

fileWriteStreamClose( int writeHandle )

  • Closes a file write stream that was started by FileWriteStreamOpen. This flushes the stream to the disk, overwriting the existing file if there was one.
  • Returns a bool.

fileWriteStreamOpen( string file )

  • Creates a new file output stream allowing you to stream out data to the Steam Cloud file in chunks. If the target file already exists, it is not overwritten until FileWriteStreamClose has been called. To write data out to this stream you can use FileWriteStreamWriteChunk, and then to close or cancel you use FileWriteStreamClose and FileWriteStreamCancel respectively.
  • Returns an int.

fileWriteStreamWriteChunk( int writeHandle, PoolByteArray data, int dataSize )

  • Writes a blob of data to the file write stream.
  • Returns a bool.

getCachedUGCCount()

  • Gets the number of cached UGC.
  • Returns an int.

getCachedUGCHandle( int content )

  • Gets the cached UGC's handle.
  • Returns an int.

getFileCount()

  • Get the number of files saved on Steam Cloud.
  • Returns an int.

getFileNameAndSize( int file )

  • Gets the file name and size of a file from the index.
  • Returns a dictionary:
    • name (string)
    • size (int)

getFileSize( string file )

  • Get the size of the current file.
  • Returns an int.

getFileTimestamp( string file )

  • Get the timestamp of when the file was uploaded.
  • Returns an int.

getQuota()

  • Gets the number of bytes available, and used on the users Steam Cloud storage.
  • Returns a dictionary:
    • total_bytes (int)
    • available_bytes (int)

getSyncPlatforms( string file )

  • Obtains the platforms that the specified file will synchronize to.
  • Returns an int:
    • 0 - None
    • 1<<0 - Windows
    • 1<<1 - OSX
    • 1<<2 - PS3
    • 1<<3 - Linux
    • 1<<4 - Reserved
    • 0xffffffff - All

isCloudEnabledForAccount()

  • Check if Cloud Saves/Storage is enabled for the user's account.
  • Returns a bool.

isCloudEnabledForApp()

  • Check if Cloud Saves/Storage is enabled for the application.
  • Returns a bool.

setCloudEnabledForApp( bool enabled )

  • Enable or disable Steam Cloud for this application. This must only ever be called as the direct result of the user explicitly requesting that it's enabled or not. This is typically accomplished with a checkbox within your in-game options.
  • Returns a bool.

setSyncPlatforms( string file, int platform )

  • Allows you to specify which operating systems a file will be synchronized to. Use this if you have a multiplatform game but have data which is incompatible between platforms.
  • Returns a bool.

Screenshots

addScreenshotToLibrary( string filename, string thumbnailFilename, int width, int height )

  • Adds a screenshot to the user's Steam screenshot library from disk.
  • Triggers a _screenshot_ready callback.
  • Returns an int.

addVRScreenshotToLibrary( int type, string filename, string vrFilename )

  • Adds a VR screenshot to the user's Steam screenshot library from disk in the supported type.
  • Returns an int.

hookScreenshots( bool hook )

  • Toggles whether the overlay handles screenshots.
  • Returns nothing; void.

isScreenshotsHooked()

  • Checks if the app is hooking screenshots.
  • Returns a bool.

setLocation( int screenshot, string location )

  • Sets optional metadata about a screenshot's location.
  • Returns a bool.

tagPublishedFile( int screenshot, int fileID )

  • Tags a published file as being visible in the screenshot. You can tag up to the value declared by k_nScreenshotMaxTaggedPublishedFiles in a single screenshot. Tagging more items than that will just be discarded. This function has a built in delay before saving the tag which allows you to call it repeatedly for each item. You can get the handle to tag the screenshot once it has been successfully saved from the ScreenshotReady_t callback or via the WriteScreenshot, AddScreenshotToLibrary, AddVRScreenshotToLibrary calls.
  • Returns a bool.

tagUser( int screenshot, int steamID )

  • Tags a Steam user as being visible in the screenshot. You can tag up to the value declared by k_nScreenshotMaxTaggedUsers in a single screenshot. Tagging more users than that will just be discarded. This function has a built in delay before saving the tag which allows you to call it repeatedly for each item. You can get the handle to tag the screenshot once it has been successfully saved from the ScreenshotReady_t callback or via the WriteScreenshot, AddScreenshotToLibrary, AddVRScreenshotToLibrary calls.
  • Returns a bool.

triggerScreenshot()

  • Causes the Steam overlay to take a screenshot.
  • Returns nothing; void.

writeScreenshot( array data, int width, int height )

  • Writes a screenshot to the user's Steam screenshot library.
  • Triggers a _screenshot_ready callback.
  • Returns an int.

UGC / Workshop

addAppDependency( int publishedFileID, int appID )

  • Adds a dependency between the given item and the appid. This list of dependencies can be retrieved by calling GetAppDependencies. This is a soft-dependency that is displayed on the web. It is up to the application to determine whether the item can actually be used or not.
  • Triggers _add_app_dependency_result callback.
  • Returns nothing; void.

addDependency( int publishedFileID, int childPublishedFileID )

  • Adds a workshop item as a dependency to the specified item. If the nParentPublishedFileID item is of type k_EWorkshopFileTypeCollection, than the nChildPublishedFileID is simply added to that collection. Otherwise, the dependency is a soft one that is displayed on the web and can be retrieved via the ISteamUGC API using a combination of the m_unNumChildren member variable of the SteamUGCDetails_t struct and GetQueryUGCChildren.
  • Triggers _add_ugc_dependency_result callback.
  • Returns nothing; void.

addExcludedTag( int queryHandle, string tagName )

  • Adds a excluded tag to a pending UGC Query. This will only return UGC without the specified tag.
  • Returns a bool.

addItemKeyValueTag( int updateHandle, string key, string value )

  • Adds a key-value tag pair to an item. Keys can map to multiple different values (1-to-many relationship).
  • Returns a bool.

addItemPreviewFile( int queryHandle, string previewFile, int type )

  • Adds an additional preview file for the item.
  • Returns a bool.

addItemPreviewVideo( int queryHandle, string videoID )

  • Adds an additional video preview from YouTube for the item.
  • Returns a bool.

addItemToFavorite( int appID, int publishedFileID )

  • Adds a workshop item to the users favorites list.
  • Triggers _user_favorite_items_list_changed callback.
  • Returns nothing; void.

addRequiredKeyValueTag( int queryHandle, string key, string value )

  • Adds a required key-value tag to a pending UGC Query. This will only return workshop items that have a key = pKey and a value = pValue.
  • Returns a bool.

addRequiredTag( int queryHandle, string tagName )

  • Adds a required tag to a pending UGC Query. This will only return UGC with the specified tag.
  • Returns a bool.

addRequiredTagGroup( int queryHandle, array tagArray )

  • Adds the requirement that the returned items from the pending UGC Query have at least one of the tags in the given set (logical "or"). For each tag group that is added, at least one tag from each group is required to be on the matching items.
  • Returns a bool.

initWorkshopForGameServer( int workshopDepotID )

  • Lets game servers set a specific workshop folder before issuing any UGC commands.
  • Returns a bool.

createItem(AppId_t appID, int fileType )

  • Creates a new workshop item with no content attached yet.
  • Triggers _item_created callback.
  • Returns nothing; void.

createQueryAllUGCRequest( int queryType, int matchingType, int creatorID, int consumerID, int page )

  • Query for all matching UGC. You can use this to list all of the available UGC for your app.
  • Returns an int.

createQueryUGCDetailsRequest( array publishedFileIDs )

  • Query for the details of specific workshop items.
  • Returns an int.

createQueryUserUGCRequest( int steamID, int listType, int matchingUGCType, int sortOrder, int creatorID, int consumerID, int page )

  • Query UGC associated with a user. You can use this to list the UGC the user is subscribed to amongst other things.
  • Returns an int.

deleteItem( int publishedFileID )

  • Deletes the item without prompting the user.
  • Triggers _item_deleted callback.
  • Returns nothing; void.

downloadItem( int publishedFileID, bool highPriority )

  • Download new or update already installed item. If returns true, wait for DownloadItemResult_t. If item is already installed, then files on disk should not be used until callback received. If item is not subscribed to, it will be cached for some time. If bHighPriority is set, any other item download will be suspended and this item downloaded ASAP.
  • Returns a bool.

getItemDownloadInfo( int fileID )

  • Get info about a pending download of a workshop item that has k_EItemStateNeedsUpdate set.
  • Returns a dictionary:
    • ret (bool)
    • downloaded (int)
    • total (int)

getItemInstallInfo( int fileID )

  • Gets info about currently installed content on the disc for workshop items that have k_EItemStateInstalled set.
  • Returns a dictionary:
    • ret (bool)
    • size (int)
    • folder (string)
    • folder_size (int)
    • timestamp (int)

getItemState( int publishedFileID )

  • Gets the current state of a workshop item on this client.
  • Returns an int:
    • 0 - None
    • 1 - Subscribed
    • 2 - Legacy
    • 4 - Installed
    • 8 - Update
    • 16 - Downloading
    • 32 - Pending

getItemUpdateProgress( int updateHandle )

  • Gets the progress of an item update.
  • Returns a dictionary:
    • status (int)
    • processed (int)
    • total (int)

getNumSubscribedItems()

  • Gets the total number of items the current user is subscribed to for the game or application.
  • Returns an int.

getQueryUGCAdditionalPreview( int queryHandle, int index, int previewIndex )

  • Retrieve the details of an additional preview associated with an individual workshop item after receiving a querying UGC call result.
  • Returns a dictionary:
    • success (bool)
    • handle (int)
    • index (int)
    • preview (int)
    • url_or_video (string)
    • filename (string)
    • type (int)

getQueryUGCChildren( int queryHandle, int index )

  • Retrieve the ids of any child items of an individual workshop item after receiving a querying UGC call result. These items can either be a part of a collection or some other dependency (see AddDependency).
  • Returns a dictionary:
    • success (bool)
    • handle (int)
    • index (int)
    • children (int)

getQueryUGCKeyValueTag( int queryHandle, int index, int keyValueTagIndex )

  • Retrieve the details of a key-value tag associated with an individual workshop item after receiving a querying UGC call result.
  • Returns a dictionary:
    • success (bool)
    • handle (int)
    • index (int)
    • tag (int)
    • key (string)
    • value (string)

getQueryUGCMetadata( int queryHandle, int index )

  • Retrieve the developer set metadata of an individual workshop item after receiving a querying UGC call result.
  • Returns a string.
  • getQueryUGCNumAdditionalPreviews( int queryHandle, int index )

    • Retrieve the number of additional previews of an individual workshop item after receiving a querying UGC call result.
    • Returns an int.

    getQueryUGCNumKeyValueTags( int queryHandle, int index )

    • Retrieve the number of key-value tags of an individual workshop item after receiving a querying UGC call result.
    • Returns an int.

    getQueryUGCNumTags( int queryHandle, int index )

    • Retrieve the number of tags for an individual workshop item after receiving a querying UGC call result. You should call this in a loop to get the details of all the workshop items returned.
    • Returns an int.

    getQueryUGCPreviewURL( int queryHandle, int index )

    • Retrieve the URL to the preview image of an individual workshop item after receiving a querying UGC call result.
    • Returns a string.

    getQueryUGCResult( int queryHandle, int index )

    • Retrieve the details of an individual workshop item after receiving a querying UGC call result.
    • Returns a dictionary:
      • result (int)
      • fileID (int)
      • fileType (int)
      • creatorAppID (int)
      • consumerAppID (int)
      • title (string)
      • description (string)
      • steamIDOwner (int)
      • timeCreated (int)
      • timeUpdated (int)
      • timeAddedToUserList (int)
      • visibility (int)
      • banned (bool)
      • acceptedForUse (bool)
      • tagsTruncated (bool)
      • tags (string)
      • handleFile (int)
      • handlePreviewFile (int)
      • fileName (string)
      • fileSize (int)
      • previewFileSize (int)
      • url (string)
      • votesUp (int)
      • votesDown (int)
      • score (float)
      • numChildren (int)

    getQueryUGCStatistic( int queryHandle, int index, int statType )

    • Retrieve various statistics of an individual workshop item after receiving a querying UGC call result.
    • Returns a dictionary:
      • success (bool)
      • handle (int)
      • index (int)
      • type (int)
      • value (int)

    getQueryUGCTag( int queryHandle, int index, int tagIndex )

    • Retrieve the "nth" tag associated with an individual workshop item after receiving a querying UGC call result. You should call this in a loop to get the details of all the workshop items returned.
    • Returns a string.

    getQueryUGCTagDisplayName( int queryHandle, int index, int tagIndex )

    • Retrieve the "nth" display string (usually localized) for a tag, which is associated with an individual workshop item after receiving a querying UGC call result. You should call this in a loop to get the details of all the workshop items returned.
    • Returns a string.

    getSubscribedItems()

    • Gets a list of all of the items the current user is subscribed to for the current game.
    • Returns an array.

    getUserItemVote( int publishedFileID )

    • Gets the users vote status on a workshop item.
    • Triggers _get_item_vote_result callback.
    • Returns nothing; void.

    releaseQueryUGCRequest( int queryHandle )

    • Releases a UGC query handle when you are done with it to free up memory.
    • Returns a bool.

    removeAppDependency( int publishedFileID, int appID )

    • Removes the dependency between the given item and the appid. This list of dependencies can be retrieved by calling GetAppDependencies.
    • Triggers _remove_app_dependency_result callback.
    • Returns nothing; void.

    removeDependency( int publishedFileID, int childPublishedFileID )

    • Removes a workshop item as a dependency from the specified item.
    • Triggers _remove_ugc_dependency_result callback.
    • Returns nothing; void.

    removeItemFromFavorites( int appID, int publishedFileID )

    • Removes a workshop item from the users favorites list.
    • Triggers _user_favorite_items_list_changed callback.
    • Returns nothing; void.

    removeItemKeyValueTags( int updateHandle, string key )

    • Removes an existing key value tag from an item.
    • Returns a bool.

    removeItemPreview( int updateHandle, int index )

    • Removes an existing preview from an item.
    • Returns a bool.

    sendQueryUGCRequest( int updateHandle )

    • Send a UGC query to Steam.
    • Triggers _ugc_query_completed callback.
    • Returns nothing; void.

    setAllowCachedResponse( int updateHandle, int maxAgeSeconds )

    • Sets whether results will be returned from the cache for the specific period of time on a pending UGC Query.
    • Returns a bool.

    setCloudFileNameFilter( int updateHandle, string matchCloudFilename )

    • Sets to only return items that have a specific filename on a pending UGC Query.
    • Returns a bool.

    setItemContent( int updateHandle, string contentFolder )

    • Sets the folder that will be stored as the content for an item.
    • Returns a bool.

    setItemDescription( int updateHandle, string description )

    • Sets a new description for an item.
    • Returns a bool.

    setItemMetadata( int updateHandle, string metadata )

    • Sets arbitrary metadata for an item. This metadata can be returned from queries without having to download and install the actual content.
    • Returns a bool.

    setItemPreview( int updateHandle, string previewFile )

    • Sets the primary preview image for the item.
    • Returns a bool.

    setItemTags( int updateHandle, array tagArray)

    • Sets arbitrary developer specified tags on an item.
    • Returns a bool.

    setItemTitle( int updateHandle, string title )

    • Sets a new title for an item.
    • Returns a bool.

    setItemUpdateLanguage( int updateHandle, string language )

    • Sets the language of the title and description that will be set in this item update.
    • Returns a bool.

    setItemVisibility( int updateHandle, int visibility )

    • Sets the visibility of an item.
    • Returns a bool.

    setLanguage( int queryHandle, string language )

    • Sets the language to return the title and description in for the items on a pending UGC Query.
    • Returns a bool.

    setMatchAnyTag( int queryHandle, bool matchAnyTag )

    • Sets whether workshop items will be returned if they have one or more matching tag, or if all tags need to match on a pending UGC Query.
    • Returns a bool.

    setRankedByTrendDays( int queryHandle, int days )

    • Sets whether the order of the results will be updated based on the rank of items over a number of days on a pending UGC Query.
    • Returns a bool.

    setReturnAdditionalPreviews( int queryHandle, bool returnAdditionalPreviews )

    • Sets whether to return any additional images/videos attached to the items on a pending UGC Query.
    • Returns a bool.

    setReturnChildren( int queryHandle, bool returnChildren )

    • Sets whether to return the IDs of the child items of the items on a pending UGC Query.
    • Returns a bool.

    setReturnKeyValueTags( int queryHandle, bool returnKeyValueTags )

    • Sets whether to return any key-value tags for the items on a pending UGC Query.
    • Returns a bool.

    setReturnLongDescription( int queryHandle, bool returnLongDescription )

    • Sets whether to return the full description for the items on a pending UGC Query.
    • Returns a bool.

    setReturnMetadata( int queryHandle, bool returnMetadata )

    • Sets whether to return the developer specified metadata for the items on a pending UGC Query.
    • Returns a bool.

    setReturnOnlyIDs( int queryHandle, bool returnOnlyIDs )

    • Sets whether to only return IDs instead of all the details on a pending UGC Query.
    • Returns a bool.

    setReturnPlaytimeStats( int queryHandle, int days )

    • Sets whether to return the the playtime stats on a pending UGC Query.
    • Returns a bool.

    setReturnTotalOnly( int queryHandle, bool returnTotalOnly )

    • Sets whether to only return the the total number of matching items on a pending UGC Query.
    • Returns a bool.

    setSearchText( int queryHandle, string searchText )

    • Sets a string to that items need to match in either the title or the description on a pending UGC Query.
    • Returns a bool.

    setUserItemVote( int publishedFileID, bool voteUp )

    • Allows the user to rate a workshop item up or down.
    • Triggers _set_user_item_vote callback.
    • Returns nothing; void.

    startItemUpdate( int appID, int publishedFileID )

    • Starts the item update process.
    • Returns an int.

    startPlaytimeTracking( array publishedFileIDs )

    • Start tracking playtime on a set of workshop items.
    • Triggers _start_playtime_tracking callback.
    • Returns nothing; void.

    stopPlaytimeTracking( array publishedFileIDs )

    • Stop tracking playtime on a set of workshop items.
    • Triggers _stop_playtime_tracking callback.
    • Returns nothing; void.

    stopPlaytimeTrackingForAllItems()

    • Stop tracking playtime of all workshop items.
    • Triggers _stop_playtime_tracking callback.
    • Returns nothing; void.

    getAppDependencies( int publishedFileID )

    • Returns any app dependencies that are associated with the given item.
    • Triggers _get_app_dependencies_result callback.
    • Returns nothing; void.

    submitItemUpdate( int updateHandle, string changeNote )

    • Uploads the changes made to an item to the Steam Workshop; to be called after setting your changes.
    • Triggers _item_updated callback.
    • Returns nothing; void.

    subscribeItem( int publishedFileID )

    • Subscribe to a workshop item. It will be downloaded and installed as soon as possible.
    • Triggers _subscribe_item callback.
    • Returns nothing; void.

    suspendDownloads( bool suspend )

    • SuspendDownloads( true ) will suspend all workshop downloads until SuspendDownloads( false ) is called or the game ends.
    • Returns nothing; void.

    unsubscribeItem( int publishedFileID )

    • Unsubscribe from a workshop item. This will result in the item being removed after the game quits.
    • Triggers _unsubscribe_item callback.
    • Returns nothing; void.

    updateItemPreviewFile( int updateHandle, int index, string previewFile )

    • Updates an existing additional preview file for the item.
    • Returns a bool.

    updateItemPreviewVideo( int updateHandle, int index, string videoID )

    • Updates an additional video preview from YouTube for the item.
    • Returns a bool.

    Users

    advertiseGame( string server IP, int port )

    • (LEGACY FUNCTION) Set data to be replicated to friends so that they can join your game.
    • Returns nothing; void.

    beginAuthSession( int ticket, int steamID )

    • Authenticate the ticket from the entity's Steam ID to be sure it is valid and isn't reused.
    • Returns an int.

    cancelAuthTicket( int ticket )

    • Cancels an authentication ticket.
    • Returns nothing; void.

    decompressVoice( PoolByteArray voice, int voiceSize, int sampleRate )

    • Decodes the compressed voice data returned by GetVoice.
    • Returns a dictionary:
      • uncompressed (PoolByteArray)
      • size (int)

    endAuthSession(( int steamID )

    • Ends an authentication session.
    • Returns nothing; void.

    getAuthSessionTicketID()

    • Get an authentication ticket.
    • Returns an int.

    getAuthSessionTicket()

    • Used to debug and test authentication tickets.
    • Returns a dictionary:
      • id (int)
      • buffer (PoolByteArray)
      • size (int)

    getAvailableVoice()

    • Checks to see if there is captured audio data available from GetVoice, and gets the size of the data.
    • Returns an int.

    getDurationControl()

    • Retrieves anti indulgence / duration control for current user / game combination.
    • Triggers a _duration_control call result.
    • Returns nothing; void.

    getEncryptedAppTicket()

    • Retrieve an encrypted ticket. This should be called after requesting an encrypted app ticket with RequestEncryptedAppTicket and receiving the EncryptedAppTicketResponse_t call result.
    • Returns a dictionary:
      • buffer (PoolByteArray)
      • size (int)

    getGameBadgeLevel( int series, bool foil )

    • Trading Card badges data access, if you only have one set of cards, the series will be 1.
    • Returns an int.

    getPlayerSteamLevel()

    • Get the user's Steam level.
    • Returns an int.

    getSteamID()

    • Get the user's Steam ID (ID64).
    • Returns an int.

    getUserDataFolder()

    • Get the user's Steam installation path.
    • Returns a string.

    getVoice()

    • Read captured audio data from the microphone buffer.
    • Returns an int.

    getVoiceOptimalSampleRate()

    • Gets the native sample rate of the Steam voice decoder.
    • Returns an int.

    initiateGameConnection( int serverID, int serverIP, int serverPort, bool secure )

    • This starts the state machine for authenticating the game client with the game server. It is the client portion of a three-way handshake between the client, the game server, and the steam servers.
    • Returns a dictionary:
      • auth_blob (PoolByteArray)
      • server_id (int)
      • server_ip (int)
      • server_port (int)

    isBehindNAT()

    • Checks if the current users looks like they are behind a NAT device.
    • Returns a bool.

    isPhoneIdentifying()

    • Checks whether the user's phone number is used to uniquely identify them.
    • Returns a bool.

    isPhoneRequiringVerification()

    • Checks whether the current user's phone number is awaiting (re)verification.
    • Returns a bool.

    isPhoneVerified()

    • Checks whether the current user has verified their phone number.
    • Returns a bool.

    isTwoFactorEnabled()

    • Checks whether the current user has Steam Guard two factor authentication enabled on their account.
    • Returns a bool.

    loggedOn()

    • Check if user is logged into Steam currently.
    • Returns a bool.

    requestEncryptedAppTicket( string secret )

    • Requests an application ticket encrypted with the secret "encrypted app ticket key".
    • Triggers a _encrypted_app_ticket_response call result.
    • Returns nothing; void.

    requestStoreAuthURL( string redirect )

    • Requests a URL which authenticates an in-game browser for store check-out, and then redirects to the specified URL.
    • Triggers a _store_auth_url_response call result.
    • Returns nothing; void.

    startVoiceRecording()

    • Starts voice recording.
    • Returns nothing; void.

    stopVoiceRecording()

    • Stops voice recording.
    • Returns nothing; void.

    terminateGameConnection( int serverIP, int serverPort )

    • Notify the game server that we are disconnecting. NOTE: This is part of the old user authentication API and should not be mixed with the new API.
    • Returns nothing; void.

    userHasLicenseForApp( int steamID, int appID )

    • Checks if the user owns a specific piece of Downloadable Content (DLC). This can only be called after sending the users auth ticket to ISteamGameServer::BeginAuthSession.
    • Returns an int.

    User Statistics

    attachLeaderboardUGC( int ugcHandle, int thisLeaderboard )

    • Attaches a piece of user generated content the current user's entry on a leaderboard. If no thisLeaderboard handle is passed, then the function will use the last stored internal handle.
    • Triggers _leaderboard_ugc_set callback.
    • Returns nothing; void.

    clearAchievement( string name )

    • Clears a given achievement.
    • Returns a bool.

    downloadLeaderboardEntries( int start, int end, int type, int thisLeaderboard )

    • Request all rows for friends of user. If no thisLeaderboard handle is passed, then the function will use the last stored internal handle.
    • Triggers _leaderboard_scores_downloaded call result.
    • Returns nothing; void.

    downloadLeaderboardEntriesForUsers( array usersID, int thisLeaderboard )

    • Request a maximum of 100 users with only one outstanding call at a time. If no thisLeaderboard handle is passed, then the function will use the last stored internal handle.
    • Triggers _leaderboard_scores_downloaded callback.
    • Returns nothing; void.

    findLeaderboard( string name )

    • Find a given leaderboard, by name.
    • Triggers _leaderboard_find_result call result.
    • Returns nothing; void.

    findOrCreateLeaderboard( string name, int sortMethod, int displayType )

    • Gets a leaderboard by name, it will create it if it's not yet created.
    • Triggers _leaderboard_find_result callback.
    • Returns nothing; void.

    getAchievement( string name )

    • Return true/false if user has given achievement and the bool status of it being achieved or not.
    • Returns a dictionary:
      • ret (bool)
      • achieved (bool)

    getAchievementAchievedPercent( string name )

    • Returns the percentage of users who have unlocked the specified achievement.
    • Returns a dictionary:
      • ret (bool)
      • percent (float)

    getAchievementAndUnlockTime( string name )

    • Get the achievement status, and the time it was unlocked if unlocked (in seconds since January 1, 19).
    • Returns a dictionary:
      • retrieve (bool)
      • achieved (bool)
      • unlocked (int)

    getAchievementDisplayAttribute( string name, string key )

    • Get general attributes for an achievement.
    • Returns a string.

    getAchievementIcon( string name )

    • Gets the icon for an achievement.
    • Triggers _user_achievement_icon_fetched callback.
    • Returns an int.

    getAchievementName( int achievement )

    • Gets the 'API name' for an achievement index.
    • Returns a string.

    getAchievementProgressLimitsInt( string name )

    • For achievements that have related Progress stats, use this to query what the bounds of that progress are. You may want this info to selectively call IndicateAchievementProgress when appropriate milestones of progress have been made, to show a progress notification to the user.
    • Returns a dictionary:
      • name (string)
      • min (int)
      • max (int)

    getAchievementProgressLimitsFloat( string name )

    • For achievements that have related Progress stats, use this to query what the bounds of that progress are. You may want this info to selectively call IndicateAchievementProgress when appropriate milestones of progress have been made, to show a progress notification to the user.
    • Returns a dictionary:
      • name (string)
      • min (int)
      • max (int)

    getGlobalStatInt( string name )

    • Gets the lifetime totals for an aggregated stat.
    • Returns an int.

    getGlobalStatFloat( string name )

    • Gets the lifetime totals for an aggregated stat.
    • Returns a float.

    getGlobalStatIntHistory( string name )

    • Gets the daily history for an aggregated stat.
    • Returns an int.

    getGlobalStatFloatHistory( string name )

    • Gets the daily history for an aggregated stat.
    • Returns a float.

    getLeaderboardDisplayType( int leaderboardHandle )

    • Get the display type of a leaderboard handle. If no leaderboardHandle is passed, then the function will use the last stored internal handle.
    • Returns a dictionary:
      • result (int)
      • verbal (string)

    getLeaderboardEntryCount( int thisLeaderboard )

    • Get the total number of entries in a leaderboard, as of the last request. If no thisLeaderboard handle is passed, then the function will use the last stored internal handle.
    • Returns an int.

    getLeaderboardName( int thisLeaderboard )

    • Get the name of a leaderboard. If no thisLeaderboard handle is passed, then the function will use the last stored internal handle.
    • Returns a string.

    getLeaderboardSortMethod( int thisLeaderboard )

    • Get the sort order of a leaderboard handle. If no thisLeaderboard handle is passed, then the function will use the last stored internal handle.
    • Returns a dictionary:
      • result (int)
      • verbal (string)

    getMostAchievedAchievementInfo()

    • Gets the info on the most achieved achievement for the game.
    • Returns an array of:
      • entry (dictionary)
        • rank (int)
        • name (string)
        • percent (float)
        • achieved (bool)

    getNumAchievements()

    • Get the number of achievements.
    • Returns an int.

    getNumberOfCurrentPlayers()

    • Get the amount of players currently playing the current game (online + offline).
    • Triggers _number_of_current_players callback.
    • Returns nothing; void.

    getStatFloat( string name )

    • Get the value of a float statistic.
    • Returns a float.

    getStatInt( string name )

    • Get the value of an integer statistic.
    • Returns an int.

    getUserAchievement( int steamID, string name )

    • Gets the unlock status of the Achievement.
    • Returns a dictionary:
      • steam_id (int)
      • retrieved (bool)
      • name (string)
      • achieved (bool)

    getUserAchievementAndUnlockTime( int steamID, string name )

    • Gets the achievement status, and the time it was unlocked if unlocked.
    • Returns a dictionary:
      • retrieved (bool)
      • name (string)
      • achieved (bool)
      • unlocked (int)

    getUserStatFloat( int steamID, string name )

    • Gets the current value of a float stat for the specified user.
    • Returns a float.

    getUserStatInt( int steamID, string name )

    • Gets the current value of an integer stat for the specified user.
    • Returns an int.

    indicateAchievementProgress( string name, int currentProgress, int maxProgress )

    • Achievement progress, triggers an AchievementProgress callback, that is all. Calling this with X out of X progress will NOT set the achievement, the game must still do that.
    • Returns a bool.

    requestCurrentStats()

    • Request all statistics and achievements from Steam servers.
    • Triggers a _current_stats_received callback.
    • Returns a bool.

    requestGlobalAchievementPercentages()

    • Asynchronously fetch the data for the percentages.
    • Triggers _global_achievement_percentages_ready callback.
    • Returns nothing; void.

    requestGlobalStats( int historyDays )

    • Asynchronously fetches global stats data, which is available for stats marked as "aggregated" in the App Admin panel of the Steamworks website. The limit is 60.
    • Triggers _global_stats_received callback.
    • Returns nothing; void.

    requestUserStats( int steamID )

    • Asynchronously downloads stats and achievements for the specified user from the server.
    • Triggers _user_stats_received callback.
    • Returns nothing; void.

    resetAllStats( bool achievementsToo )

    • Reset all Steam statistics; optional to reset achievements.
    • Returns a bool.

    setAchievement( string name )

    • Set a given achievement.
    • Returns a bool.

    setLeaderboardDetailsMax( int max )

    • Set the maximum number of details to return for leaderboard entries.
    • Returns a int which is the current leaderboard details max value.

    setStatFloat( string name, float value )

    • Set a float statistic.
    • Returns a bool.

    setStatInt( string name, int value )

    • Set an integer statistic.
    • Returns a bool.

    storeStats()

    • Store all statistics, and achievements, on Steam servers; must be called to "pop" achievements.
    • Returns a bool.

    updateAvgRateStat( string name, float thisSession, double sessionLength )

    • Updates an AVGRATE stat with new values.
    • Returns a bool.

    uploadLeaderboardScore( int score, bool keepBest, array details, int thisLeaderboard )

    • Upload a leaderboard score for the user. If no thisLeaderboard handle is passed, then the function will use the last stored internal handle.
    • Triggers _leaderboard_score_uploaded callback.
    • Returns nothing; void.

    getLeaderboardEntries()

    • Get the currently used leaderboard entries.
    • Returns an array.

    Utilities

    filterText( int context, int steamID, string message )

    • Filters the provided input message and places the filtered result into pchOutFilteredText.
    • Returns a string.

    getAPICallFailureReason()

    • Used to get the failure reason of a call result. The primary usage for this function is debugging. The failure reasons are typically out of your control and tend to not be very important. Just keep retrying your API Call until it works.
    • Returns a string.

    getAppID()

    • Get the Steam ID of the running application/game.
    • Returns an int.

    getCurrentBatteryPower()

    • Get the amount of battery power, clearly for laptops.
    • Returns an int.

    getImageRGBA( int image )

    • Gets the image bytes from an image handle.
    • Returns a dictionary:
      • buffer (PoolByteArray)
      • success (bool)

    getImageSize ( int image )

    • Gets the size of a Steam image handle.
    • Returns a dictionary:
      • width (int)
      • height (int)

    getIPCCallCount

    • Returns the number of IPC calls made since the last time this function was called.
    • Returns an int.

    getIPCountry()

    • Get the user's country by IP.
    • Returns a string.

    getSecondsSinceAppActive()

    • Time since application/game was started.
    • INT; returns time in seconds.

    getSecondsSinceComputerActive()

    • Time since the user last moved the mouse.
    • INT; returns time in seconds.

    getServerRealTime()

    • Get the actual time.
    • INT; returns UNIX time from Steam servers.

    getSteamUILanguage()

    • Get the Steam user interface language.
    • STRING; should return two-letter language code.

    initFilterText()

    • Initializes text filtering. Returns false if filtering is unavailable for the language the user is currently running in. If the language is unsupported, the FilterText API will act as a passthrough.
    • Returns a bool.

    isAPICallCompleted()

    • Checks if an API Call is completed. Provides the backend of the CallResult wrapper.
    • Returns a dictionary:
      • completed (bool)
      • failed (bool)

    isOverlayEnabled()

    • Check if Steam overlay is enabled.
    • Returns a bool.

    isSteamChinaLauncher()

    • Returns whether the current launcher is a Steam China launcher. You can cause the client to behave as the Steam China launcher by adding -dev -steamchina to the command line when running Steam.
    • Returns a bool.

    isSteamInBigPictureMode()

    • Returns true if Steam and the Steam Overlay are running in Big Picture mode.
    • Returns a bool.

    isSteamRunningInVR()

    • Is Steam running in VR?
    • Returns a bool.

    isVRHeadsetStreamingEnabled()

    • Checks if the HMD view will be streamed via Steam In-Home Streaming.
    • Returns a bool.

    overlayNeedsPresent()

    • Checks if the Overlay needs a present. Only required if using event driven render updates.
    • Returns a bool.

    setOverlayNotificationInset( int horizontal, int vertical )

    • Sets the inset of the overlay notification from the corner specified by SetOverlayNotificationPosition. Integer should be number of pixels.
    • Returns nothing; void.

    setOverlayNotificationPosition( int pos )

    • Set the position where overlay shows notifications. Accepts the following integer inputs:
      • 0 - Top Left
      • 1 - Top Right
      • 2 - Bottom Left
      • 3 - Bottom Right
    • Returns nothing; void.

    setVRHeadsetStreamingEnabled()

    • Set whether the HMD content will be streamed via Steam In-Home Streaming.
    • Returns nothing; void.

    showGamepadTextInput( int inputMode, int lineInputMode, string description, int maxText, stringpresetText )

    • Activates the Big Picture text input dialog which only supports gamepad input.
    • Returns a bool.

    startVRDashboard()

    • Ask SteamUI to create and render its OpenVR dashboard.
    • Returns nothing; void.

    Video

    getOPFSettings( int appID )

    • Get the OPF details for 360 video playback.
    • Triggers a _get_opf_settings_result callback.
    • Returns nothing; void.

    getOPFStringForApp( int appID )

    • Gets the OPF string for the specified video App ID.
    • Returns a string.

    getVideoURL( int appID )

    • Asynchronously gets the URL suitable for streaming the video associated with the specified video app ID.
    • Triggers a _get_video_result callback.
    • Returns nothing; void.

    isBroadcasting()

    • Checks if the user is currently live broadcasting and gets the number of users.
    • Returns a dictionary:
      • broadcasting (bool)
      • viewers (int)