Home

Awesome

SteamUser

Allows interaction with the Steam network via the Steam client protocol

npm version npm downloads license sponsors

SteamUser allows you to communicate with the Steam servers in the same manner as a proper Steam client. It's designed to be a self-contained module which provides all the functionality expected of a Steam user client.

Node.js v14.0.0 or later is required.

Subscribe to release announcements

Have a question about the module or coding in general? Do not create a GitHub issue. GitHub issues are for feature requests and bug reports. Instead, post in the dedicated forum. Such issues may be ignored!

Upgrading from v4?
Upgrading from v3?

Installation

Install it from npm:

$ npm install steam-user

Contents

Some of the documentation for SteamUser, especially documentation for experimental features (but not exclusively), is located in the GitHub wiki.

Patterns ^

There are a number of coding patterns that are repeated throughout SteamUser. Please read this section in its entirety before starting work with SteamUser.

Callbacks and Promises

All methods listed in this document that accept a callback also return a Promise. You may use either callbacks or promises.

Legacy callbacks return their data spanning across multiple arguments. All promises (which return any data at all) return a single object containing one or more properties. The names of these properties for legacy callbacks are the names of the callback arguments listed in this readme. Newer callbacks return a single object response argument, which is identical to the promise output for that method.

Some methods indicate that their callback is required or optional. You are never required to use callbacks over promises, but if a callback is listed as optional then an unhandled promise rejection will not raise a warning/error. If a callback is listed as required and you neither supply a callback nor handle the promise rejection, then a promise rejection will raise a warning, and eventually a crash in a future Node.js release.

Enums ^

There are a lot of enums used in Steam. They're all available directly from SteamUser. For example, access EResult using SteamUser.EResult.

All enums can be viewed on GitHub.

Additionally, for convenience, the name of an enum value is available from any enum at the key identified by the enum value. For example, given an EResult of 88 you can translate it using SteamUser.EResult[88] which gives you the string TwoFactorCodeMismatch.

Static Methods ^

Static methods, or functions attached directly to SteamUser, are called on the root module and not on instantiated handler instances.

formatCurrency(amount, currency)

Formats a currency value and returns a string. For example:

console.log(SteamUser.formatCurrency(12.34, SteamUser.ECurrencyCode.USD)); // $12.34
console.log(SteamUser.formatCurrency(12345, SteamUser.ECurrencyCode.JPY)); // ¥ 12345
console.log(SteamUser.formatCurrency(123.45, SteamUser.ECurrencyCode.EUR)); // 123,45€

Options ^

There are a number of options which can control the behavior of the SteamUser object. They are:

dataDirectory

Controls where the Steam server list and machine auth token files are written. If null, no data will be automatically stored.

Defaults to a platform-specific user data directory.

Custom Storage Engine

If you don't want to (or can't) save data to the disk, you can implement your own storage engine. To do this, simply add the following code:

user.storage.on('save', function(filename, contents, callback) {
	// filename is the name of the file, as a string
	// contents is a Buffer containing the file's contents
	// callback is a function which you MUST call on completion or error, with a single error argument

	// For example:
	someStorageSystem.saveFile(filename, contents, function(err) {
		callback(err);
	});
});

user.storage.on('read', function(filename, callback) {
	// filename is the name of the file, as a string
	// callback is a function which you MUST call on completion or error, with an error argument and a Buffer argument

	// For example:
	someStorageSystem.readFile(filename, function(err, file) {
		if(err) {
			callback(err);
			return;
		}

		callback(null, file);
	});
});

In this manner, you can save data to a database, a cloud service, or anything else you choose.

autoRelogin

A boolean which controls whether or not SteamUser will automatically reconnect to Steam if disconnected due to Steam going down.

Defaults to true.

machineIdType

What kind of machine ID will SteamUser send to Steam when logging on? Should be a value from EMachineIDType.

Added in 1.7.0.

Defaults to AccountNameGenerated.

machineIdFormat

If you're using machineIdType AccountGenerated, this is the format it uses. This is an array of three strings, each of which will be hashed with SHA1 before being sent to Steam. {account_name} will be replaced with the current account name.

Added in 1.13.0.

Defaults to ["SteamUser Hash BB3 {account_name}", "SteamUser Hash FF2 {account_name}", "SteamUser Hash 3B3 {account_name}"].

enablePicsCache

If enabled, then node-steam-user will internally cache data in memory about all apps and packages that it knows about. Currently, node-steam-user "knows about" an app/package if:

This option is required in order to use several methods and events. This works when logging in anonymously.

Added in 3.3.0.

Defaults to false.

picsCacheAll

If picsCacheAll is enabled, enablePicsCache is enabled, and changelistUpdateInterval is nonzero, then apps and packages which get updated while your bot is running will also be added to the cache. Default behavior is to only cache apps and packages that are "known" via the above criteria.

Added in 3.3.0.

Defaults to false.

changelistUpdateInterval

If enablePicsCache is enabled, then node-steam-user will automatically request app/package changes (via getProductChanges) for known apps and packages, and update the internal cache when they update. This is the frequency, in milliseconds, for changelist update requests. Set to 0 to disable.

Added in 3.3.0.

Defaults to 60000. Minimum value 1000, although you're recommended to not go below 10 seconds or so.

ownershipFilter

Specify a custom app/package ownership filter object or function to be applied to all calls to getOwned*() and owns*() where a filter is not specified in the method invocation. If you specify a filter when you call getOwned*() or owns*(), then that filter is applied and the global ownershipFilter is ignored.

Added in 4.22.0.

Defaults to a filter that excludes expired licenses only.

This filter can be either an object or a function:

Filter Object

A filter object should contain zero or more of these properties:

Any omitted properties are assumed to be false. If you don't specify an ownership filter, an empty object is assumed.

Filter Function

You can also provide your own custom filter function. This function will be called for each license owned by your account, and should return true to include a license or false to exclude it. This function should have the same arguments as the callback you'd pass to Array.prototype.filter.

The element argument will be an object of type Proto_CMsgClientLicenseList_License (same as the licenses property).

Please note that when you specify a custom filter function, expired licenses (e.g. past free weekends) will be sent to your filter function as candidates for inclusion, but these licenses are filtered out in all other cases. You can determine if a license is expired by checking if (license.flags & SteamUser.ELicenseFlags.Expired).

Example usage:

user.setOption('ownershipFilter', (license) => {
	// only passes licenses that were acquired at least a year ago
	let time = Math.floor(Date.now() / 1000);
	return time - license.time_created >= 60 * 60 * 24 * 365;
});

additionalHeaders

Set this to an object where keys are header names and values are header values, and those headers will be included with all HTTP requests node-steam-user makes to the Steam WebAPI.

Added in 3.29.0.

Defaults to {}.

localAddress

Pass an IP here (as a string) to bind to that address, or null to let the OS decide.

Added in 4.0.0.

Defaults to null.

localPort

Pass a port here to bind to that port, or null to let the OS decide.

Added in 4.0.0.

Defaults to null.

httpProxy

Specify a URL here to use an HTTP proxy. For example, http://user:pass@1.2.3.4:8081

Added in 4.0.0.

socksProxy

Specify a URL here to use a SOCKS proxy. SOCKS4, SOCKS4a, and SOCKS5 are supported.

Example: socks5://x1234567:kNRLnUDG46@proxy-nl.privateinternetaccess.com:1080

Added in 4.26.0.

protocol

A value from EConnectionProtocol.

Added in 4.0.0.

Defaults to Auto.

language

Set this to the full name of a language (e.g. "english" or "spanish") to localize specific things within steam-user. Currently this is only used to localize rich_presence_string in user event data and in requestRichPresence.

Added in 4.0.0.

Defaults to english.

webCompatibilityMode

If you're having trouble connecting to Steam (e.g. through a firewall or a proxy), set this to true. When in web compatibility mode, connections to Steam will always use WebSockets (the protocol option will be ignored, and you will get a warning if you set it to TCP), and only Steam servers listening on port 443 will be considered.

Added in 4.6.0.

Defaults to false.

saveAppTickets

If true, then calls to getAppOwnershipTicket will save ownership tickets to disk and will return cached tickets unless they are expired.

Added in 3.5.0.

Defaults to true.

renewRefreshTokens

If true, then SteamUser will attempt to renew your refresh token every time you call logOn() by passing a refresh token. If renewal succeeds, the refreshToken event will be emitted, and the refresh token you used to log on will become invalid.

Added in 5.0.0.

Defaults to false.

Properties ^

steamID

null if not connected, a SteamID containing your SteamID otherwise.

options

An object containing options for this SteamUser. Read-only; use setOption or setOptions to change an option.

publicIP

v1.12.0 or later is required to use this property

Only defined if you're currently logged on. This is your public IP as reported by Steam, in "x.x.x.x" format.

cellID

v1.12.0 or later is required to use this property

Only defined if you're currently logged on. This is your cell (region ID) on the Steam network.

vanityURL

v3.7.0 or later is required to use this property

Only defined if you're currently logged on. This is your vanity URL (the part that goes after /id/ in your profile URL). Falsy if you don't have one.

accountInfo

An object containing information about your account. null until accountInfo is emitted.

emailInfo

An object containing information about your account's email address. null until emailInfo is emitted.

limitations

An object containing information about your account's limitations. null until accountLimitations is emitted.

vac

An object containing information about your account's VAC bans. null until vacBans is emitted.

wallet

An object containing information about your Steam Wallet. null until wallet is emitted.

licenses

An array containing license data for the packages which your Steam account owns. null until licenses is emitted.

gifts

An array containing gifts and guest passes you've received but haven't accepted (to your library or to your inventory) or declined. null until gifts is emitted. Each object in the array contains these properties:

users

An object containing persona data about all Steam users we've encountered or requested data for. Key are 64-bit SteamIDs, and values are identical to the objects received in the user event.

This property may not be updated unless you set your instance to online.

groups

An object containing information about all Steam groups we've encountered. Keys are 64-bit SteamIDs, and values are identical to those received in the group event.

This property may not be updated unless you set your instance to online.

chats

An object containing information about all legacy chat rooms we're in. Keys are 64-bit SteamIDs, values are objects with this structure:

myFriends

An object whose keys are 64-bit SteamIDs, and whose values are values from the EFriendRelationship enum. Therefore, you can deduce your friends list from this object.

When we get unfriended, instead of setting the value to EFriendRelationship.None, the key is deleted from the object entirely.

This isn't populated after logon until friendsList is emitted.

myGroups

An object whose keys are 64-bit SteamIDs, and whose values are from the EClanRelationship enum. Therefore, you can deduce which groups you're in from this object.

When we leave a group, instead of setting the value to EClanRelationship.None, the key is deleted from the object entirely.

This isn't populated after logon until groupList is emitted.

myFriendGroups

v1.10.0 or later is required to use this property

An object containing your friend groups (in the official client, these are called tags). Keys are numeric group IDs, and objects as follows:

myNicknames

v3.15.0 or later is required to use this property

An object containing the nicknames you have assigned to other users. Keys are numeric 64-bit SteamIDs, properties are strings containing that user's nickname.

This is empty until nicknameList is emitted.

picsCache

v3.3.0 or later is required to use this property

An object containing cached data about known apps and packages. Only useful if the enablePicsCache option is true.

chat

v4.0.0 or later is required to use this property

This is a SteamChatRoomClient instance. Use this object to chat with friends and chat rooms.

Read SteamChatRoomClient docs here.

playingState

v4.0.0 or later is required to use this property

An object containing information about your current playing state. This object has these properties:

packageName

v4.2.0 or later is required to use this property

Contains the name of this package. The value is always "steam-user". This allows other modules to verify interoperability.

packageVersion

v4.2.0 or later is required to use this property

Contains the version of this package. For example, "4.2.0". This allows other modules to verify interoperability.

Methods ^

Constructor(options)

Constructs a new SteamUser.

Prior to v4.0.0, it was possible to pass a SteamClient instance as the first argument to this constructor. This functionality was removed in v4.0.0. See the full list of v4 changes.

setOption(option, value)

Changes the value of an option.

setOptions(options)

logOn([details])

v3.11.0 or later is required to use machineName.
v4.3.0 or later is required to use webLogonToken.
v4.25.0 or later is required to use refreshToken.
v4.29.0 or later is required to use machineAuthToken.

Logs onto Steam. Omit the details object if you wish to login to an anonymous user account.

There are five ways to log onto Steam:

Using Refresh Tokens

The Steam client uses refresh tokens when logging on. You can obtain a refresh token using the steam-session module, or you can log on to steam-user using your account name and password as normal. When logging on using your account name and password, steam-user will internally fetch a refresh token, emit the refreshToken event, and then use that token to log on to Steam.

As of 2022-09-03, refresh tokens are JWTs that are valid for ~200 days. You can keep using the same refresh token to log on until it expires. You can find out when a token expires by decoding it and checking the exp property, which is a Unix timestamp indicating when the token expires.

If you attempt to log on using a refresh token that isn't valid for use with client logins, the app will crash with a relevant error message.

Machine Auth Tokens

When using email Steam Guard, machine auth tokens are used to remember a device, in order to bypass the requirement to provide a code every time you login. By default, steam-user will automatically save your machine auth tokens in your data directory, but you can also manage them yourself by listening for the machineAuthToken event and providing the token as a machineAuthToken property when you log on.

logOff()

Logs you off of Steam and closes the connection.

relog()

v3.18.0 or later is required to use this method

Logs you off of Steam and then immediately back on. This can only be used if one of the following criteria are met:

Attempts to call this method under any other circumstance will result in an Error being thrown and nothing else will happen.

When used, disconnected and then loggedOn will be emitted in succession. This is essentially the same as using logOff() and then calling logOn() immediately in the disconnected event callback.

webLogOn()

SteamUser will automatically log onto steamcommunity.com when a successful connection to Steam is established (as an individual user), but you can call webLogOn() to create a new session if your old one expires or becomes invalid.

Listen for the webSession event to get your cookies.

requestValidationEmail([callback])

Requests Steam to send you a validation email to your registered email address.

enableTwoFactor(callback)

v2.0.0 or later is required to use this method

Starts the process to turn on TOTP for your account.

If you have a phone number linked with your account, then you'll be sent an SMS with an activation code. Otherwise, you'll receive the activation code by email. You'll need to provide the activation code to finalizeTwoFactor.

You should save the entire response object somewhere secure. You can use JSON.stringify on it safely.

Properties of note in the response object:

finalizeTwoFactor(secret, activationCode, callback)

v2.0.0 or later is required to use this method

Finishes the process of enabling TOTP two-factor authentication for your account. You can use steam-totp in the future when logging on to get a code.

If TOTP two-factor authentication is enabled, a code will be required on every login unless a refresh token is used.

getSteamGuardDetails(callback)

v1.11.0 or later is required to use this method.
v1.12.0 or later is required to use canTrade.
v3.3.3 or later is required to use timestampTwoFactorEnabled.
v3.5.0 or later is required to use isPhoneVerified.

Requests details about your account's Steam Guard status. This could be used to see if your account passes the Steam Guard trading requirements.

In order to trade, all of the following must be true:

getCredentialChangeTimes(callback)

v3.10.0 or later is required to use this method

Gets when you last changed various account credentials.

getAuthSecret(callback)

v3.10.0 or later is required to use this method

Gets your account's auth secret, which is the pre-shared key used for in-home streaming.

getPrivacySettings(callback)

v4.11.0 or later is required to use this method

Retrieves your account's privacy settings. You can't change your privacy state using steam-user; you'll need to use steamcommunity.

kickPlayingSession([callback])

v3.21.0 or later is required to use this method
v4.22.0 or later is required to read playingApp in the callback

If this account is being used to play a game on another logon session, calling this method will kick that other session off of Steam entirely (it will get an error event if the other session is using node-steam-user).

gamesPlayed(apps[, force])

v3.21.0 or later is required to use force

Reports to Steam that you're playing or using zero or more games/apps. To exit all games/apps, use an empty array [].

To play a single game by AppID, use a single integer (e.g. 440)

To play a single non-Steam game by name, use a single string (e.g. "Minecraft")

To play a single game by AppID and name (the client-provided name is what is given to the WebAPI and mobile app), use an object of this format:

{
	"game_id": 440,
	"game_extra_info": "Team Fortress 2"
}

You can use multiple apps by providing an array of any mixture of the above formats.

getPlayerCount(appid, callback)

Requests a count of how many Steam users are currently playing/using an app.

serverQuery(conditions, callback)

Requests a list of game servers from the master server.

getServerList(filter, limit, callback)

Works when anonymous. Requests a list gameservers from Steam matching a given filter, along with information about the server as Steam knows it.

getServerSteamIDsByIP(ips, callback)

Works when anonymous. Gets current SteamIDs for servers running on given addresses.

getServerIPsBySteamID(steamids, callback)

Works when anonymous. Gets current IP addresses for servers with given SteamIDs.

getProductChanges(sinceChangenumber, callback)

Works when anonymous. Requests a list of all apps/packages which have changed since a given changenumber.

getProductInfo(apps, packages[, inclTokens], callback)

Works when anonymous. Requests details about one or more apps or packages.

If you have the PICS cache enabled and the risk of getting stale data is acceptable, you could check the PICS cache if you want instead of calling getProductInfo.

getProductAccessToken(apps, packages, callback)

Works when anonymous. Requests access tokens for one or more apps or packages. These access tokens can be used with getProductInfo.

Access tokens are global. That is, everyone who has access to an app receives the same token. Tokens do not seem to expire.

getOwnedApps([filter])

v3.3.0 or later is required to use this method
v4.7.0 or later is required to use excludeSharedLicenses
v4.22.0 or later is required to use filter

Returns an array of AppIDs which your account owns. This cannot be safely called until ownershipCached is emitted.

enablePicsCache must be true to use this method. Otherwise, an Error will be thrown.

If filter is a boolean, it is interpreted as excludeShared for backward compatibility. For example, getOwnedApps(true) is the same as getOwnedApps({excludeShared: true}). This usage is deprecated and will be removed in a future release.

The output of this function will contain all AppIDs that are present in at least one license that was not filtered out. For example, if you previously activated a free on demand package for Spacewar but later activated a retail CD key for the same, it will be included if you pass {excludeFree: true} as your filter since you own it both via a free package and via a paid package.

ownsApp(appid[, filter])

v3.3.0 or later is required to use this method
v4.7.0 or later is required to use excludeSharedLicenses
v4.22.0 or later is required to use filter

Returns true if your account owns the specified AppID, or false if not. This cannot be safely called until ownershipCached is emitted.

enablePicsCache must be true to use this method. Otherwise, an Error will be thrown.

If filter is a boolean, it is interpreted as excludeShared for backward compatibility. For example, ownsApp(730, true) is the same as ownsApp(730, {excludeShared: true}). This usage is deprecated and will be removed in a future release.

The output of this function will be true if the provided AppID is present in at least one license that was not filtered out.

getOwnedDepots([filter])

v3.3.0 or later is required to use this method
v4.7.0 or later is required to use excludeSharedLicenses
v4.22.0 or later is required to use filter

Returns an array of depot IDs which your account owns. This cannot be safely called until ownershipCached is emitted.

enablePicsCache must be true to use this method. Otherwise, an Error will be thrown.

If filter is a boolean, it is interpreted as excludeShared for backward compatibility. For example, getOwnedDepots(true) is the same as getOwnedDepots({excludeShared: true}). This usage is deprecated and will be removed in a future release.

The output of this function will contain all depot IDs that are present in at least one license that was not filtered out.

ownsDepot(depotid[, filter])

v3.3.0 or later is required to use this method
v4.7.0 or later is required to use excludeSharedLicenses
v4.22.0 or later is required to use filter

Returns true if your account owns the specified depot, or false if not. This cannot be safely called until ownershipCached is emitted.

enablePicsCache must be true to use this method. Otherwise, an Error will be thrown.

If filter is a boolean, it is interpreted as excludeShared for backward compatibility. For example, ownsDepot(731, true) is the same as ownsDepot(731, {excludeShared: true}). This usage is deprecated and will be removed in a future release.

The output of this function will be true if the provided depot ID is present in at least one license that was not filtered out.

getOwnedPackages([filter])

v3.3.0 or later is required to use this method
v4.7.0 or later is required to use excludeSharedLicenses
v4.22.0 or later is required to use filter

Returns an array of package IDs which your account owns.

If filter is a boolean, it is interpreted as excludeShared for backward compatibility. For example, getOwnedPackages(true) is the same as getOwnedPackages({excludeShared: true}). This usage is deprecated and will be removed in a future release.

The output of this function will contain all package IDs for which you have at least one license that was not filtered out.

The point at which this method can be called depends on the following:

ownsPackage(packageid[, filter])

v3.3.0 or later is required to use this method
v4.7.0 or later is required to use excludeSharedLicenses
v4.22.0 or later is required to use filter

Returns true if your account owns the specified package ID, or false if not.

The output of this function will be true if your account has at least one license for the provided package ID that wasn't filtered out.

The same timing requirements apply to this method as apply to getOwnedPackages.

If filter is a boolean, it is interpreted as excludeShared for backward compatibility. For example, ownsPackage(16018, true) is the same as ownsPackage(16018, {excludeShared: true}). This usage is deprecated and will be removed in a future release.

getStoreTagNames(language, tagIDs, callback)

v3.26.0 or later is required to use this method

Retrieves localized names for specified store tag IDs. Tag IDs are available in the response to getProductInfo.

getPublishedFileDetails(ids, callback)

v3.8.0 or later is required to use this method

Gets details for one or more published files. Published files are anything with a URL like https://steamcommunity.com/sharedfiles/filedetails/?id=662626851 (where id is the published file ID).

The amount of data available in results is huge, so I can only suggest that you console.log it to see what's available.

setPersona(state[, name])

v1.9.0 or later is required to use this method

Changes our online status, and optionally your profile name. You need to call this after you logon or else you'll show up as offline. You won't receive any persona data about your friends if you don't go online.

setUIMode(mode)

v3.7.0 or later is required to use this method

Sets your current UI mode, which displays as an icon next to your online status in Steam chat and the friends list.

addFriend(steamID[, callback])

v1.9.0 or later is required to use this method. v3.10.0 or later is required to use callback.

Sends a friend request to the user with the specified SteamID. If they've already sent you a friend request, accepts it.

If you provide a callback, the message of the err will be DuplicateName and the eresult will be 14 if we are already friends with the requested user, or if we've sent them a friend request already that they haven't accepted or ignored. message will be Blocked and eresult will be 40 if they've blocked us.

removeFriend(steamID)

v1.9.0 or later is required to use this method

Removed a specified user from your friends list. Also ignores an outstanding friend request from this user.

blockUser(steamID[, callback])

v1.9.0 or later is required to use this method

Blocks all communication with a specified user.

unblockUser(steamID[, callback])

v1.9.0 or later is required to use this method

Unblocks all communication with a specified user.

createQuickInviteLink([options,] callback)

v4.11.0 or later is required to use this method

v4.13.0 or later is required to use inviteDuration

Creates a quick-invite link that can be used by anyone who has it to add you to their friends list without needing to send an invite that you must to approve.

listQuickInviteLinks(callback)

v4.11.0 or later is required to use this method

Retrieves the list of quick-invite links on your account. Links that you've revoked won't appear here.

revokeQuickInviteLink(linkOrToken[, callback])

v4.11.0 or later is required to use this method

Revokes a quick-invite link. Can also be used to delete an already-used code from listQuickInviteLinks.

getQuickInviteLinkSteamID(link)

v4.11.0 or later is required to use this method

Decodes a quick-invite link and returns a SteamID object representing the user account to whom this link belongs. Returns null if the link is not well-formed.

This happens offline and thus returns immediately, without need for a callback or Promise.

checkQuickInviteLinkValidity(link, callback)

v4.11.0 or later is required to use this method

Checks whether a quick-invite link is valid.

redeemQuickInviteLink(link[, callback])

v4.11.0 or later is required to use this method

Redeems a quick-invite link and adds the user to your friends list.

getPersonas(steamids[, callback])

v1.9.0 or later is required to use this method

Requests persona data for one or more users from Steam. The response will arrive in the user event, or in the callback if provided.

uploadRichPresence(appID, richPresence)

v4.4.0 or later is required to use this method

Uploads rich presence data to Steam. In order to display text in the Steam friends list, you need a key named steam_display, which must be a rich presence localization key (you can see RP keys for apps on SteamDB).

%placeholders% in the rich presence localization value will be replaced with the value of the corresponding key that you upload. For example, to get a TF2 RP string of "Special Event - Hello, World!", then you should upload:

{
	"steam_display": "#TF_RichPresence_Display",
	"state": "PlayingMatchGroup",
	"matchgrouploc": "SpecialEvent",
	"currentmap": "Hello, World!"
}

This will subsequently be parsed like this:

  1. #TF_RichPresence_Display = {#TF_RichPresence_State_%state%}
  2. {#TF_RichPresence_State_PlayingMatchGroup} = {#TF_RichPresence_MatchGroup_%matchgrouploc%} - %currentmap%
  3. {#TF_RichPresence_MatchGroup_SpecialEvent} - Hello, World!
  4. Special Event - Hello, World!

getAppRichPresenceLocalization(appID, language, callback)

v4.0.0 or later is required to use this method

Requests localized rich presence strings for a particular app in the given language. This will allow you to decode the rich_presence array in the user event into the localized string displayed in the Steam client.

requestRichPresence(appID, steamIDs, callback)

v4.18.0 or later is required to use this method

Requests rich presence key/value data and localized strings as displayed in Steam for a list of given users, for a given app. You do not need to be friends with the requested users. Response object looks like this:

{
    "users": {
        "76561198006409530": {
            "richPresence": {
                "status": "Playing CS:GO",
                "version": "13765",
                "time": "15.851017",
                "game:state": "lobby",
                "steam_display": "#display_Menu",
                "connect": "+gcconnectG02C0193A"
            },
            "localizedString": "Playing CS:GO"
        }
    }
}

If the Steam display string cannot be localized, then localizedString will be null. This is the case when there exists no translation for the language you selected.

getSteamLevels(steamids, callback)

v1.9.0 or later is required to use this method

Gets the Steam Level for one or more Steam users (who do not have to be on your friends list).

getAliases(steamids, callback)

v3.10.0 or later is required to use this method

Gets the last 10 persona names (including the current one) used by one or more Steam users (who do not have to be on your friends list).

getNicknames([callback])

v3.23.0 or later is required to use this method

Retrieves an up-to-date nickname list (see nicknameList) from Steam. The nicknameList event will be emitted when the response to this request is received, immediately after the callback fires. If you provide no callback, the nicknameList event is still emitted.

In theory, the nickname list in myNicknames will always be up-to-date since v3.23.0, but you may wish to use this if you want to be doubly sure.

setNickname(steamID, nickname[, callback])

v3.15.0 or later is required to use this method

Sets a nickname on a user. If one already exists, overwrites it. The myNicknames property will be updated just before the callback fires, on success.

Note: It appears to be possible for Steam to report success when using this method, when in reality your nickname wasn't saved on the server. You can detect this case by calling getNicknames.

getGameBadgeLevel(appid, callback)

v3.8.0 or later is required to use this method

Gets your own Steam Level, and the level you have on a badge for a particular game.

getUserOwnedApps(steamID[, options], callback)

v4.16.0 or later is required to use this method

Retrieves a user's list of owned apps. The user's games must not be private.

This is functionally identical to IPlayerService/GetOwnedGames but with some minor data processing.

getFriendsThatPlay(appID, callback)

v4.20.0 or later is required to use this method

Retrieves a list of friends that have played or used an app.

getOwnedProfileItems([options,] callback)

v4.16.0 or later is required to use this method

Retrieves a listing of all profile items you currently own.

Profile Item Data

Profile item objects have these properties:

getEquippedProfileItems(steamID[, options], callback)

v4.16.0 or later is required to use this method

Retrieves a list of a given user's equipped profile items.

setProfileBackground(backgroundAssetID[, callback])

v4.16.0 or later is required to use this method

Changes your own profile background.

inviteToGroup(userSteamID, groupSteamID)

v3.7.0 or later is required to use this method

Invites a user to a Steam group.

Warning: Group invites can only be sent to users on your friends list. Why is this?

respondToGroupInvite(groupSteamID, accept)

v3.7.0 or later is required to use this method

Joins a group you were invited to or ignores the invite.

createFriendsGroup(groupName[, callback])

v3.27.0 or later is required to use this method

Creates a friends group (also known as a tag within the official Steam client)

deleteFriendsGroup(groupID[, callback])

v3.27.0 or later is required to use this method

Deletes a friends group (also known as a tag within the official Steam client)

renameFriendsGroup(groupID, newName[, callback])

v3.27.0 or later is required to use this method

Renames a friends group (also known as a tag within the official Steam client)

Note: The change does not seem to update within the official Steam client

addFriendToGroup(groupID, userSteamID[, callback])

v3.27.0 or later is required to use this method

Adds a friend to a friends group (also known as a tag within the official Steam client)

removeFriendFromGroup(groupID, userSteamID[, callback])

v3.27.0 or later is required to use this method

Removes a friend to a friends group (also known as a tag within the official Steam client)

trade(steamID)

v1.9.0 or later is required to use this method

Send a trade request to the specified user. Listen for the tradeResponse event for their response.

Note: Valve seems to have dropped real-time trade requests from the Steam UI, in favor of trade offers. However, real-time trades are not fully deprecated as they can still be initiated from inside of some games, for example TF2. Users using the Steam client will not see real-time trade requests that your bots send them, but bots should still be able to send and accept trade requests amongst themselves.

cancelTradeRequest(steamID)

v1.9.0 or later is required to use this method

Cancels your outstanding trade request to the specified user.

getAssetClassInfo(language, appid, classes, callback)

v3.25.0 or later is required to use this method

Retrieves asset description data from Steam. Works similarly to the WebAPI method by the same name, although at time of documentation no tags are returned.

getTradeURL(callback)

v3.28.0 or later is required to use this method

Gets your account's trade token and URL.

changeTradeURL(callback)

v3.28.0 or later is required to use this method

Asks the Steam server to generate a new trade token for your account, and returns the new token and URL.

getEmoticonList(callback)

v4.5.0 or later is required to use this method

Requests a list of emoticons that your account is entitled to use.

chatMessage(recipient, message[, type])

v1.9.0 or later is required to use this method

Sends a chat message to a friend or a legacy chat room.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatTyping(recipient)

v1.9.0 or later is required to use this method

Tells the recipient that you're typing a chat message.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

getChatHistory(steamID[, callback])

v1.9.0 or later is required to use this method

Requests our chat history with a user. The results will arrive either in the callback or in the chatHistory event.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

joinChat(steamID[, callback])

v1.9.0 or later is required to use this method

Joins a legacy chat room. To join a group chat, use the group's SteamID.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

leaveChat(steamID)

v1.9.0 or later is required to use this method

Leaves a legacy chat room we're in.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

setChatPrivate(steamID)

v1.9.0 or later is required to use this method

Locks a legacy chat room so that only group members and invited users can join.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

setChatPublic(steamID)

v1.9.0 or later is required to use this method

Unlocks a legacy chat room so anyone can join.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

setChatOfficersOnly(steamID)

v1.9.0 or later is required to use this method

Sets a legacy chat room so that only group officers can chat.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

unsetChatOfficersOnly(steamID)

v1.9.0 or later is required to use this method

Sets a legacy chat room so that anyone can chat.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

kickFromChat(chatID, userID)

v1.9.0 or later is required to use this method

Kicks a user from a legacy chat room.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

banFromChat(chatID, userID)

v1.9.0 or later is required to use this method

Bans a user from a legacy chat room.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

unbanFromChat(chatID, userID)

v1.9.0 or later is required to use this method

Unbans a banned user from a legacy chat room.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

inviteToChat(chatID, userID)

v1.9.0 or later is required to use this method

Invites a user to a legacy chat room.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

createChatRoom([convertUserID, ][inviteUserID, ][callback])

v1.9.0 or later is required to use this method

Creates a new multi-user legacy chat room.

This is deprecated. This creates an old-style, pre-new-chat chat room, which is not compatible with Steam's newer chat system. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

redeemKey(key[, callback])

v3.2.0 or later is required to use this method

Redeems a game code (CD key) on your account. If this request fails, the Error object will have purchaseResultDetails and packageList properties, and you should access this data via the Error object and not via the callback arguments.

requestFreeLicense(appIDs[, callback])

v3.18.0 or later is required to use this method

Requests a free-on-demand license to be granted to your account.

Older free-to-play games are in the "Steam" package (package ID 0). This package is automatically granted to all accounts (but not anonymous ones). Games in this package do not need a license to be explicitly requested.

All newer free-to-play games have "free-on-demand packages". These are packages that are not automatically granted to all accounts, but will be granted upon request ("on demand"). This is so that the Steam client can show free-to-play games you have previously added to your library when not installed. In order to "play" any free-to-play app that isn't in sub 0, you need to request a license for it using this method.

If successful, calling this method will result in the licenses event being emitted containing your new license(s).

Please note: This method is rate-limited to approximately 50 apps per hour.

Please note: This method only works with free-on-demand licenses. Promotional free licenses (i.e. "free to keep for a limited time") cannot be requested using this method. You can request such licenses using the steamstore module's addFreeLicense method.

getLegacyGameKey(appid, callback)

v4.24.0 or later is required to use this method

Requests your legacy CD key for a game in your library. This will only succeed if the game in question uses legacy CD keys (usually you'll get a Steam popup when you launch this game presenting you with your key which you can copy and paste into the game when prompted).

markNotificationsRead(notificationIds)

v5.2.0 or later is required to use this method

Marks a list of notifications as read. There is no response or feedback to this method.

markAllNotificationsRead()

v5.2.0 or later is required to use this method

Marks all notifications as read. There is no response or feedback to this method.

createEncryptedAppTicket(appid[, userData], callback)

v3.14.0 or later is required to use this method

Requests an "encrypted app ticket" from Steam servers for a particular game. This can be used to prove your ownership of an app and also your account identity to some publisher server, provided they're expecting an encrypted app ticket. To use encrypted app tickets, publishers must set up an encryption key in the Steamworks backend. Therefore, this will not work if encrypted tickets haven't been set up for the AppID you request a ticket for. You cannot decrypt an encrypted app ticket, nor can you view anything it contains. It is for all intents and purposes an opaque blob of binary data which only the developer/publisher of the game can do anything with.

sendToGC(appid, msgType, protoBufHeader, payload[, callback])

v4.1.0 or later is required to use this method

Please see documentation for GC interaction on the GitHub wiki.

Events ^

ID Events

Events marked as ID events are special. They all have a SteamID object as their first parameter. In addition to the event itself firing, a second event comprised of eventName + "#" + steamID.getSteamID64() is fired.

For example:

// This will fire when we receive a chat message from ANY friend
user.on('friendMessage', function(steamID, message) {
	console.log("Friend message from " + steamID.getSteam3RenderedID() + ": " + message);
});

// This will fire when we receive a chat message from [U:1:46143802] / 76561198006409530 ONLY
user.on('friendMessage#76561198006409530', function(steamID, message) {
	console.log("Friend message from " + steamID.getSteam3RenderedID() + ": " + message);
});

loggedOn

v3.5.0 or later is required to use parental.

Emitted when you're successfully logged into Steam.

steamGuard

This event will be emitted when Steam requests a Steam Guard code from us. You should collect the code from the user somehow and then call the callback with the code as the sole argument.

If no listener is bound to this event, then steam-user will prompt the user for a code via stdin.

If you are using 2FA, you need to check the lastCodeWrong argument. If it's true, then the last code you provided was incorrect (likely already used). In this case, you should wait 30 seconds to allow the TOTP algorithm to generate a new code. Failure to do so will result in a login loop, causing your IP address to be temporarily banned.

Example:

user.on('steamGuard', function(domain, callback) {
	console.log("Steam Guard code needed from email ending in " + domain);
	var code = getCodeSomehow();
	callback(code);
});

error

Emitted when an error occurs during logon. Also emitted if we're disconnected and autoRelogin is either disabled, or it's a fatal disconnect.

If this event isn't handled, the program will crash.

The SteamUser object's steamID property will still be defined when this is emitted. The Error object will have an eresult parameter which is a value from the EResult enum.

disconnected

Emitted when we're disconnected from Steam for a non-fatal reason and autoRelogin is enabled. SteamUser will continually retry connection and will either emit loggedOn when logged back on, or error if a fatal logon error is experienced.

Also emitted in response to a logOff() call.

The SteamUser object's steamID property will still be defined when this is emitted.

The eresult value might be 0 (Invalid), which indicates that the disconnection was due to the connection being closed directly, without Steam sending a LoggedOff message.

machineAuthToken

v4.29.0 or later is required to use this event

Emitted when a new machine auth token is issued. This is only relevant for accounts using email Steam Guard. Even if you are using email Steam Guard, you likely don't need to worry about this event as steam-user will automatically manage your machine auth tokens for you.

This may be emitted before loggedOn fires.

refreshToken

v5.0.0 or later is required to use this event

Emitted when a new refresh token is issued. This will always be emitted when logging on using an account name and password, and when logging on using an existing refresh token, this may be emitted if a new refresh token is issued because your provided token is nearly expired (only if renewRefreshTokens is set to true).

This may be emitted before loggedOn fires.

webSession

Emitted when a steamcommunity.com web session is successfully negotiated. This will automatically be emitted on logon (unless you used a webLogonToken to log on) and in response to webLogOn calls.

Some libraries require you to provide your sessionID, others don't. If the library you're using doesn't need you to provide a sessionID, then you can safely ignore it.

Read more about how cookies work and interact with other modules.

newItems

Emitted when Steam sends a notification of new items. You can reset the count to 0 by loading your inventory page (https://steamcommunity.com/my/inventory) while logged in.

newComments

Emitted when Steam sends a notification of new comments.

tradeOffers

Emitted when Steam sends a notification of new trade offers. This gets emitted shortly after logon iff it's nonzero, and every time it changes thereafter (i.e. both when you receive a trade offer and when an active trade offer you received gets accepted/canceled/declined).

communityMessages

v3.26.0 or later is required to use this event

Emitted when Steam sends a notification of new community (moderator) messages. This gets emitted shortly after logon iff it's nonzero, and every time it changes thereafter (i.e. both when you receive a community message and when a community message gets read).

offlineMessages

Emitted when Steam sends a notification of unread offline chat messages. This will always be emitted after logon, even if you have no messages.

notificationsReceived

v5.2.0 or later is required to use this event

Emitted when the Steam backend notifies us of new or changed notifications. The behavior is not 100% intuitive, but here is what has been observed:

vanityURL

v3.7.0 or later is required to use this event

Emitted when your vanity URL changes. url is your new vanity URL. This event is emitted before the vanityURL property is updated, so you can compare to see what changed.

accountInfo

v3.4.0 or later is required to use this event

Emitted on logon and when account info changes. This event is emitted before the accountInfo property is updated, so you can compare to see what changed.

emailInfo

Emitted on logon and when email info changes. The emailInfo property will be updated after this event is emitted.

accountLimitations

Emitted on logon and when limitations change. The limitations property will be updated after this event is emitted.

vacBans

Emitted on logon and probably when you get banned/unbanned. The vac property will be updated after this event is emitted.

wallet

Emitted on logon and when wallet balance changes. The wallet property will be updated after this event is emitted.

licenses

Contains the license data for the packages which your Steam account owns. To see license object structure, see CMsgClientLicenseList.License.

Emitted on logon and when licenses change. The licenses property will be updated after this event is emitted.

This isn't emitted for anonymous accounts. However, all anonymous user accounts have a license for package 17906 automatically.

gifts

Emitted on logon and when you receive/accept/decline a gift or guest pass. The gifts property will be updated after this event is emitted.

Guest Passes (do they even still exist?) are gifts (actually, gifts are Guest Passes with a very long expiration date). Consequently, both come through this event.

Each object in the array is an oustanding gift or guest pass that was sent to you that you haven't accepted/declined yet. Only outstanding gifts show up here. Gifts that you stored in your inventory don't show up here.

The structure of the objects in the array is defined in the documentation for the gifts property.

ownershipCached

v3.3.0 or later is required to use this event under the name appOwnershipCached
v4.22.1 or later is required to use this event under the name ownershipCached

Emitted once we have all data required in order to determine app ownership. You can now safely call getOwnedApps, ownsApp, getOwnedDepots, and ownsDepot.

This is only emitted if enablePicsCache is true.

This event was renamed from appOwnershipCached in v4.22.1. It can still be used by the old name, although such usage is deprecated and will be removed in a future release.

changelist

v3.3.0 or later is required to use this event

Emitted when we receive a new changelist from Steam. The picsCache property is updated after this is emitted, so you can get the previous changenumber via picsCache.changenumber.

This is only emitted if enablePicsCache is true and changelistUpdateInterval is nonzero.

appUpdate

v3.3.0 or later is required to use this event

Emitted when an app that was already in our cache updates. The picsCache property is updated after this is emitted, so you can get the previous app data via picsCache.apps[appid].

This is only emitted if enablePicsCache is true and changelistUpdateInterval is nonzero.

packageUpdate

v3.3.0 or later is required to use this event

Emitted when a package that was already in our cache updates. The picsCache property is updated after this is emitted, so you can get the previous package data via picsCache.packages[packageid].

This is only emitted if enablePicsCache is true and changelistUpdateInterval is nonzero.

marketingMessages

v3.4.0 or later is required to use this event

Emitted on logon, and when new marketing messages are published. Marketing messages are the popups that appear after you exit a game if you have "Notify me about additions or changes to my games, new releases, and upcoming releases" enabled in the Steam client.

tradeRequest

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when someone sends us a trade request. Example usage:

user.on('tradeRequest', function(steamID, respond) {
	console.log("Incoming trade request from " + steamID.getSteam3RenderedID() + ", accepting");
	respond(true);
});

tradeResponse

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when someone responds to our trade request. Also emitted with response EEconTradeResponse.Cancel when someone cancels their outstanding trade request to us.

tradeStarted

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a new trade session has started (either as a result of someone accepting a Steam trade request, an in-game (TF2) trade request, or something else).

The trade is now available at http://steamcommunity.com/trade/[SteamID], and can be automated with node-steam-trade.

playingState

v3.21.0 or later is required to use this event

Emitted under these conditions:

user

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when Steam sends us persona information about a user, which will only happen if this client instance's persona state is online. The users property isn't yet updated when this is emitted, so you can compare to see what changed.

group

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when Steam sends us information about a Steam group. The groups property isn't yet updated when this is emitted, so you can compare to see what changed.

groupEvent

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a group schedules a new event, or a new event starts.

groupAnnouncement

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a group posts a new announcement.

friendRelationship

v1.9.0 or later is required to use this event. v4.20.2 or later is required to use previousRelationship

This is an ID event.

Emitted when our relationship with a particular user changes. For example, EFriendRelationship.RequestRecipient means that we got invited as a friend, and EFriendRelationship.None means that we got unfriended.

The myFriends property isn't yet updated when this is emitted, so you can compare to the old value to see what changed.

groupRelationship

v1.9.0 or later is required to use this event. v4.20.2 or later is required to use previousRelationship

This is an ID event.

Emitted when our relationship with a particular Steam group changes.

The myGroups property isn't yet updated when this is emitted, so you can compare to the old value to see what changed.

friendsList

v1.9.0 or later is required to use this event

Emitted when our friends list is downloaded from Steam after logon, and is now available in myFriends.

friendPersonasLoaded

v3.22.0 or later is required to use this event

Emitted when all personas have been loaded for our entire friends list, and they are all now available in users.

groupList

v1.9.0 or later is required to use this event

Emitted when our group list is downloaded from Steam after logon, and is now available in myGroups.

friendsGroupList

v1.10.0 or later is required to use this event

Emitted when our friends group list is downloaded from Steam, which should be shortly after logon (automatically).

In the official client, friend groups are called tags.

The myFriendGroups property will be updated after this event is emitted, so you can compare groups with the property to see what changed.

nicknameList

v3.15.0 or later is required to use this event

Emitted when we receive our full nickname list from Steam, which should be shortly after logon (automatically). You can access it via the myNicknames property.

nickname

v3.23.0 or later is required to use this event

Emitted when a friend's nickname is changed somewhere else (that is, on the web or by another client sessions). This is not emitted in response to a setNickname call.

This is emitted before the myNicknames property is updated, so you can compare with that object to see what it used to be.

friendOrChatMessage

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when we receive either a friend message or a legacy chat room message, as long as we're online.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

friendMessage

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when we receive a direct friend message (that is, not through a chat room), as long as we're online.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

friendTyping

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when Steam notifies us that one of our friends is typing a message to us, as long as we're online.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

friendLeftConversation

v3.10.0 or later is required to use this event

This is an ID event.

Emitted when Steam notifies us that one of our friends with whom we've been chatting has closed our chat window, as long as we're online.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

friendMessageEcho

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when Steam echos us a message that we sent to a friend on another login.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

friendTypingEcho

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when Steam echos us a notification that we're typing to a friend on another login.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatMessage

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when we receive a chat message from a legacy chat room, as long as we're online. This is a special ID event. Any of the following are acceptable:

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatHistory

v1.9.0 or later is required to use this event

This is an ID event.

With the exception of the steamID argument, this is identical to the callback of getChatHistory.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatInvite

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when we're invited to join a legacy chat room. This is a special ID event. Any of the following are acceptable:

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatCreated

v1.9.0 or later is required to use this event

This is an ID event.

With the exception of the friendID argument, this event is identical to the callback of createChatRoom.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatEnter

v1.9.0 or later is required to use this event

This is an ID event.

With the exception of the chatID argument, this event is identical to the callback of joinChat.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatLeft

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when we leave a legacy chat room for any reason (we left, kicked, banned, etc).

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatUserJoined

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a user joins a legacy chat room we're in.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatUserLeft

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a user leaves a legacy chat room we're in.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatUserDisconnected

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a user in a legacy chat room we're in disconnects from Steam.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatUserKicked

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a user is kicked from a legacy chat room we're in.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatUserBanned

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a user is banned from a legacy chat room we're in.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatUserSpeaking

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a user in a legacy chat room we're in starts speaking over voice chat.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatUserDoneSpeaking

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a user in a legacy chat room we're in stops speaking over voice chat.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatSetPublic

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a legacy chat room we're in is unlocked so that anyone can join.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatSetPrivate

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a legacy chat room we're in is locked so that only group members can join without an invite.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatSetOfficersOnly

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a legacy chat room we're in is set so that only group officers can chat.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

chatSetPrivate

v1.9.0 or later is required to use this event

This is an ID event.

Emitted when a legacy chat room we're in is set so that everyone can chat.

This is deprecated. You should use SteamChatRoomClient instead, which is available as the chat property of each SteamUser instance.

Read SteamChatRoomClient docs here.

lobbyInvite

v3.9.0 or later is required to use this event

Emitted when we're invited to a Steam lobby. The inviter should be currently playing the game associated with this lobby, so you can get the AppID of the associated game from their user persona data.

appLaunched

v4.1.0 or later is required to use this event

Please see documentation for GC interaction on the GitHub wiki.

appQuit

v4.1.0 or later is required to use this event

Please see documentation for GC interaction on the GitHub wiki.

receivedFromGC

v4.1.0 or later is required to use this event

Please see documentation for GC interaction on the GitHub wiki.