Jump to content


Most Liked Content


#889 Identifying Steam Items

Posted by Dr. McKay on 20 May 2016 - 12:40 AM

Sometimes it can be a little confusing to identify a specific item in the Steam economy. There are several different types of IDs present in one particular item, and a lot of vague terminology. This guide aims to clear all that up for you.

For starters, the "official" term for a Steam item is an asset. When I say a "Steam item", I mean a particular copy of an item. I'm not referring to the item's definition, name, image, or anything. I'm referring to a specific, unique copy of the item.

In a general sense, every item on Steam must be owned by an app. An "app" is a game, software, or whatever on Steam. Every app has its own unique AppID. You can find a particular game's AppID by going to its store page or community hub and looking at the URL. For example, TF2's AppID is 440 so TF2's store page can be found at http://store.steampowered.com/app/440. CS:GO's is 730, Dota 2's is 570, and so on. Note that Steam Community items, Steam gifts, and other "Steam" items are owned by the "Steam" app, which has AppID 753. To identify an item, you'll need the AppID of the game which owns it.

Of course, the AppID alone isn't enough. You also need two other IDs. Have you ever noticed how some games have multiple inventories, which appear in a drop-down list? An example is the Steam inventory, which has sub-inventories for "Community", "Gifts", "Coupons", etc. These "sub-inventories" are called contexts, and each context has its own context ID. If a game doesn't have a drop-down menu to select a context, that doesn't mean that it's without contexts. That only means that it has one single visible context. That single context still has an ID. For all current Valve games, the context ID for the publicly-visible context is 2.

Context IDs can be a bit tricky. It's entirely up to the game's developer to determine how they work. For example, Valve games take the "single shared inventory" model in which there's one context ID which is shared by everyone. Under this model, an item belongs to one particular context and never leaves that context. Consequently, the item's context ID never changes. It is, however, possible for game developers to create contexts in any way they choose. For example, Spiral Knights uses the "per-character inventory" model in which everyone who plays the game has their own context IDs for their characters. Creating a new character creates a new context ID. This means that when an item is traded between users, its context ID will change as it moved out of a particular character's inventory.

Those are the two different types of "containers" in the Steam economy. Apps own contexts, and contexts own assets. Every asset on Steam has, in addition to its AppID and context ID, an asset ID which is guaranteed to be unique inside of a given AppID+ContextID combination. Notice that this means that asset IDs are not unique across all of Steam. They aren't even unique across a particular app. They are only unique inside of a given context. For example, there could be two items with asset ID 1 in the same game, as long as they have different context IDs. An item's asset ID may be referred to as "assetid" or just plain "id".

Context IDs and asset IDs are assigned by the game developer and can follow any pattern. They can change when traded or not. They may both be up to 64 bits in size. Consequently, Steam returns them (like all other 64-bit values) in JSON as strings.

Still following? All of what we've learned so far leads us to this conclusion: in order to uniquely identify an item, you need its AppID, its context ID, and its asset ID. Once you have these three things, only then can you uniquely identify it. In fact, this is how you link to a particular item in a user's inventory: steamcommunity.com/profiles/steamid/inventory#appid_contextid_assetid. Here's an example: https://steamcommuni...440_2_134161610

What on Earth are these "classid" and "instanceid" values though??
The observant reader may have noticed that there are two more IDs attached to a particular item which I haven't mentioned. These are the "classid" and "instanceid". These IDs are used to map an asset to its description.

What's a description? A description is what you need in order to actually display an item. An item's description contains its name, image, color, market_name, whether it's tradable or not, whether it's marketable or not, and more. There are many endpoints on Steam which return JSON objects representing assets that only contain the asset's AppID, context ID, asset ID, classid, instanceid, and amount. An item's amount is how big of a stack it is. Unstackable items always have an amount of 1. Stackable items (such as Steam gems) may have a larger amount. Stacked items always have the same asset ID.

What's the difference between a classid and an instanceid? Well in a nutshell, a classid "owns" an instanceid. The classid is all you need to get a general overview of an item. For example, items with the same classid will pretty much always have the same name and image. The instanceid allows you to get finer-tuned details such as how many kills are on a strange/StatTrak weapon, or custom names/descriptions.

You can turn a classid/instanceid pair into a description using the GetAssetClassInfo WebAPI method. Notice that the instanceid is actually optional: if you only have a classid that's fine, you just won't get finer details for the item.

Do note that it's possible for a game developer to flush Steam's asset cache entirely, which would change the classid/instanceid of every item. As of the time of this posting, I'm unaware of this ever having been done.

Name? Market Name? Market Hash Name? Halp?
Every asset on Steam has a name. Period. Without a name, there's nothing to show in your inventory. The item's name is the... (wait for it...) name property of its description (shocking, I know). The item's name may be localized if the game's developer has set it up to be.

Every marketable item also has a "market name". This name may be the same as, or different from the item's regular name. The item's market name is the market_name property of its description. This is the name that's displayed in the Steam Community Market when the item is up for sale. Why the distinction? There are some items which have value-affecting data that isn't in their name. For example, CS:GO skins have 5 different tiers of "wear", which isn't in their names. The wear tier is appended to each skin's market name however, so that the different tiers of wear are separated in the market. The market name may be localized or not, and may not exist at all if the item isn't marketable. It's up to the game's developer.

Finally, every marketable item also has a "market hash name", available under the market_hash_name property. This name is supposed to be the English version of the item's market name, but in practice it may vary. For example, Steam Community items prepend the AppID of the originating app to each item's market hash name, but not to the market name. The market hash name is never localized, and may not exist if the item isn't marketable. Again, it's up to the game's developer. You can view the Community Market listings for any marketable item using this URL formula: steamcommunity.com/market/listings/appid/market_hash_name. Here's an example: https://steamcommuni...upply Crate Key

Note that the Community Market has no concept of contexts. Consequently, market [hash] names are unique for a particular "class" of items per-app (and by extension per-context). This means that for marketable items, two items with identical market hash names will be worth roughly the same (with some exceptions, like unusual TF2 items).

Questions?
Ask below. I'm happy to help!


  • Mole, Andrew, trzyrazyzero and 3 others like this


#984 Cookies

Posted by Dr. McKay on 10 June 2016 - 12:33 PM

Every website out there (that doesn't use HTTP authentication) uses cookies to identify user sessions. Cookies usually contain session IDs, which are looked up on the server in order to determine who the session belongs to. Steam is no different.

 

All Steam websites (the store, community, the help site) use the same cookies to identify user sessions. There are four cookies which are required to identify a Steam session:

  • sessionid
  • steamLogin
  • steamLoginSecure*
  • steamMachineAuth<SteamID>*

* = this cookie should only be sent over HTTPS

 

Despite its name, the sessionid cookie is merely a CSRF token. Its value can be anything, as long as it matches the sessionid POST parameter in your POST requests. Steam will randomly assign you one the first time you hit one of the websites without already having one, even if you aren't logged in. They are not tied to accounts or to sessions.

 

steamLogin and steamLoginSecure are the actual session cookies. Their format is: (your 64-bit SteamID + two pipe characters, percent encoded as %7C + a 40-character uppercase hexadecimal token). The hexadecimal token will differ between the two cookies, but the SteamID will be the same. steamLoginSecure should be sent with all HTTPS requests, and only for HTTPS requests. These cookies are short-lived and once invalidated (the exact circumstances that cause them to be invalidated are unclear), you will be logged out.

 

steamMachineAuth<SteamID> is your Steam Guard identification cookie. You should replace <SteamID> with your actual 64-bit SteamID, so for example the name of my cookie would be steamMachineAuth76561198006409530. This cookie's value is simply a 40-character uppercase hexadecimal token. The cookie identifies a "machine" for Steam Guard, so that you don't have to provide an email code every time. This cookie is still present if you're using the mobile authenticator, even though you have to provide a code for every login. This cookie's issue date is also used as the "first sign in" date for purposes of determining trade restrictions. This cookie effectively lasts forever, so you should save it and reuse it between sessions. This cookie is required for trade offers to work.

 

How to Get Cookies

 

You can get Steam login cookies in one of three ways.

  1. You can log in to any Steam site in a browser, which will issue you cookies for that domain (and also do some JavaScript to set those cookies for other Steam domains). node-steamcommunity can do this for you.
  2. You can use the undocumented IMobileAuthService/GetWGToken WebAPI method with an oAuth token. node-steamcommunity can do this for you.
  3. You can use the ISteamUserAuth/AuthenticateUser WebAPI method with a nonce (loginkey) received from the CM. Sessions negotiated this way will have no steamMachineAuth cookie, and that cookie is unneeded for these sessions (trade offers will still work). Sessions negotiated this way will be invalidated as soon as the client session which received the CM nonce disconnects. node-steam-user can do this for you.

Once you have cookies, you can use them with any of a number of modules, e.g. node-steam-trade, node-steamcommunity, node-steamstore, etc.

 

Cookie Usage

 

I'll briefly explain how cookies and sessions work in my libraries. A quick overview on statefulness: HTTP is stateless. Each request is distinct from every other request, and thus there is no way to link two requests together (except by using cookies). For this reason, to keep track of which user is logged in, every site on the planet uses cookies. Typically, cookies contain an opaque session ID which the server looks up to see which account you're using. Steam is no exception. TCP is stateful. Each message sent over a TCP connection belongs to that connection and thus it's easy to link two messages together.

  • node-steam-user connects to the CM using TCP (or optionally UDP, but it acts like TCP anyway). This is a stateful connection, and there is no need to use cookies to identify it.  Therefore, node-steam-user has no need for cookies. While it is capable of producing cookies, it does not save them and doesn't use them in any way except to make them available to the end-user for use elsewhere.
  • node-steamcommunity communicates with Steam over HTTP, which is stateless. Thus, cookies are required in order to authenticate your requests to your account. node-steamcommunity can either accept cookies using the setCookies method (which can accept cookies obtained by any means, including node-steam-user), or it can produce cookies using the login method. Either method will save the cookies internally in the SteamCommunity object and those cookies will be used to authenticate every HTTP request.
  • node-steamstore is identical to node-steamcommunity, although it cannot create cookies (i.e. it can only accept them using setCookies).
  • node-steam-tradeoffer-manager is identical to node-steamstore, except it uses node-steamcommunity under the hood for its HTTP communication. Thus, if you instantiate TradeOfferManager and pass a community instance to the constructor, calling setCookies on the TradeOfferManager will also call setCookies on the SteamCommunity, and therefore you need not call setCookies on SteamCommunity (although it doesn't hurt anything, either).

In list form, where a producer can create cookies and a consumer can use cookies:


  • Royalgamer06 and ArturkA like this


#734 Trading and Escrow -- Mobile Trade Confirmations

Posted by Dr. McKay on 27 April 2016 - 03:19 PM

As of December 2015, all users who are losing items in a trade must have the Steam Guard Mobile Authenticator enabled, or else the trade will be held for three fifteen days. It's also no longer possible to opt-out of trade confirmations.

 

This means that effectively, all trading bots need a mobile authenticator and need to accept mobile trade confirmations. You don't need an actual physical phone to act as your mobile authenticator, however. Through the efforts of myself and others, you can emulate a mobile authenticator right from node.js, and also accept trade confirmations.

 

Enabling a Mobile Authenticator

 

The Steam Guard Mobile Authenticator provides two-factor authentication security (hereinafter "2FA") for your account, which is more secure than standard email-based Steam Guard. This is done using a "shared secret" which is known to both the Steam servers and to your authenticator. Both sides run this secret through an algorithm along with the current time, which produces a 5-character alphanumeric code. This code is only valid for 30 seconds, and can only be used once. Attempts to reuse a 2FA code (either through the Steam Client or by logging in on steamcommunity.com) will treat the code as incorrect and reject it. For this reason, you can't login more frequently than once in a 30-second period.

 

Enabling 2FA is a three-step process.

  1. Link and verify a phone number with your Steam account. You can do this manually from your account page, or programmatically using node-steamstore.
  2. Call enableTwoFactor using either node-steam-user or node-steamcommunity. If successful, this will return an object containing a bunch of properties. You should save this entire object. You can call JSON.stringify on it safely to turn it into a string. You'll need the revocation_code in the future if you ever want to disable 2FA. At this stage, 2FA isn't enabled yet. Steam will send you an SMS containing a code which you'll need in step 3.
  3. Call finalizeTwoFactor using either node-steam-user or node-steamcommunity. You will need the value of the shared_secret property from the object returned in step 2, and the numeric activation code from your SMS. If successful, your Steam account now has 2FA.

Logging in With a Mobile Authenticator

 

If you have 2FA enabled, then for every login you will need to provide a twoFactorCode (unless you're logging in with node-steam-user using a loginKey). You can generate this code using node-steam-totp and your shared_secret which you obtained (and should have saved) when you enabled 2FA.

 

Mobile-Confirming Trades

 

You are now required to confirm all trades in which you lose items. If you don't have 2FA enabled, then these confirmations will go to your email and the trades will be held for fifteen days. If you do have 2FA enabled, then the confirmations must be accepted through Steam's mobile confirmation interface. You can also accept mobile confirmations through node.js.

 

node-steam-tradeoffer-manager doesn't have anything built-in to accept mobile confirmations. This is because mobile confirmations encompass more than just trades -- market listings also require confirmation, and potentially other things in the future.

 

node-steamcommunity can accept your confirmations for you. In order to accept mobile confirmations, you will need the identity_secret (not the shared_secret used for login) from when you enabled 2FA. The best way to do this is to call acceptConfirmationForObject right after each trade offer you send/accept or market listing you create.


  • Andreabum and AndrewRoni like this


#6087 how can i input my username&password like SteamGuard

Posted by venfiw on 24 September 2018 - 11:45 AM

hello every one i made it now, here is my code

test2.png


  • Dr. McKay and MrPotato like this


#5497 i thought offer.accept do not work now

Posted by Eradicate on 16 April 2018 - 02:59 PM

Whenever you get an offer you need to confirm it, or the bot does.

 

You can do this by setting up a interval that confirms the confirmations every X seconds, but this method is deprecated I believe, you should now be using;
 

           community.acceptConfirmationForObject(data.identity_secret, offer.id, function(err){
              if(err){
                console.log(err);
                return;
              }

              console.log('Succesfully confirmed the offer.');
            })


Replace with your bots identity secret and the offerid of the sent out offer.

Edit: might of misread it.


  • Dr. McKay and venfiw like this


#5237 How do I choose the right server host?

Posted by Dr. McKay on 07 March 2018 - 06:23 PM

DigitalOcean is fine. I'd recommend them more now that they've dropped their prices than I would in the past. If you're going with a VPS then you need to read up on security so you don't get pwned.

 

You probably want at least 2 GB of RAM. 1 GB might work but keep in mind that it also needs to support the entire OS too.

 

On a reputable host your files are safe. You don't need to encrypt them unless you're really paranoid, and if you do go that route you can't store the key on the server or it'll defeat the purpose.


  • Go Fast and derogs like this


#5119 Asking for steam guard code after few hours working

Posted by Vanilla on 09 February 2018 - 08:00 AM

Correct me if I'm wrong, but isn't it should supposed to be like this?

community.on('sessionExpired', function(err) {
	if (err) {
		console.log('sessionExpired: '+err);
		client.webLogOn();
	}
	
	community.stopConfirmationChecker();
});

Also, another way to bypass Steam Guard Code is using loginKey


  • Igaresha and McMuffinDK like this


#497 Error sending trade offer (15)

Posted by danek on 05 April 2016 - 01:53 PM

Hello.

What mean this error:

 

Error: There was an error sending your trade offer.  Please try again later. (15)

 


  • loyare74 and clisteri like this


#4199 Send/receive messages to/from non-friends

Posted by Dr. McKay on 23 August 2017 - 04:24 PM

You should be able to send messages to non-friends if you're in a group chat with them, but that's about it I think.


  • Kim and TheGoldenPotato like this


#3982 How do I get comments in a steam profile?

Posted by Vanish on 28 July 2017 - 05:26 AM

How to get a comment that is posted in a steam profile


  • LeighHyday and ReighHyday like this


#2838 Send items problem

Posted by Soska on 03 March 2017 - 10:56 AM

Hello. There was such problem: when the bot sends two DIFFERENT trades at the same time, for example where there are two or three of the same case. One trade is accepted, the other gets the status "Items unavailable for trade"
 
Items are sent by Market name (the classid and instanceid is always the same. they do not have sense). assetid in the offer and the inventory are different.
 
The task such: to send items that are not currently in other trades of the account.

  • ArlaSokindy and Penneyliz like this


#1537 Minimal code to stay logged in forever...

Posted by Dr. McKay on 06 August 2016 - 11:03 PM

That all looks fine to me. sessionExpired is only emitted when a request you make fails because you aren't logged in. It doesn't check automatically, it only checks whenever the library makes a request somewhere.

 

Starting a new confirmation checker without stopping the old one is just fine. It'll stop an old one if you call it while one is running.

 

I recommend updating to v3.23.1 if you're going to use webchat.


  • yellowish and klonaway like this


#143 TradeOfferManager v2

Posted by Dr. McKay on 03 March 2016 - 02:10 PM

Here's an idea. Three options for createOffer():

  1. manager.createOffer(steamID); // create an offer without a token. you can set it later
  2. manager.createOffer(steamID, token); // create an offer with a token
  3. manager.createOffer(tradeURL); // automatically extract the SteamID and token from the trade URL

  • Mole and PEPZ like this


#1243 What's in a SteamID?

Posted by Dr. McKay on 01 July 2016 - 06:34 PM

Ever wondered what's behind that big long number that we call a "SteamID"? It isn't just random; there are actually four numbers packed into it.
 
A SteamID has four parts:

  • Universe - The "instance of Steam" in which this ID is used. There is only one public Steam instance. Its name is "public", and its number is 1. The other universes are used internally at Valve for testing.
  • Type - A SteamID can actually stand for several different types of accounts. The most common is individual, which is an individual user account. There are also types for clans (Steam groups), gameservers, anonymous gameservers, anonymous users, and more.
  • Instance - This number is a bit finnicky. For the most part it's just a static number. For example, for individual SteamIDs the instance is pretty much always 1 (for desktop).
  • Account ID - This is the actual ID of the account. Account IDs increment over time. If you know what universe, type, and instance an ID is for, then this is all you need to uniquely identify the account.

As I mentioned previously, a 64-bit SteamID is actually broken down into four parts:

  • 8 bits for the universe
  • 4 bits for the type
  • 20 bits for the instance
  • 32 bits for the account ID

This means that in order to get an account ID out of a 64-bit SteamID, all you need to do is steamID & 0xFFFFFFFF.
 
Warning: The Steam WebAPI and Steam Community website actually don't care about the instance as long as you've set the type and universe correctly. This means that if you're taking user input for SteamIDs, you could end up with duplicate accounts. For example, the SteamIDs 76561198006409530 and 76561202301376826 are considered identical because the universe, type, and accountids are the same. Try it for yourself: https://steamcommuni...561198006409530 https://steamcommuni...561202301376826
 
Failure to take this into account can result in such exploits as this:
 
Attached File  marked.png   98.47KB   62 downloads Attached File  notmarked.png   79.36KB   36 downloads
 
(Yes, those are actually the same Steam account)
 
Common SteamID Confusion
SteamID aspects are a common source of confusion. For starters, what do you call various SteamID formats?

  • This is the 64-bit SteamID (or just SteamID) format: 76561198006409530
  • This is the Steam3 format: [U:1:46143802]
  • This is the Steam2 format: STEAM_0:0:23071901 (or the newer Steam2 format: STEAM_1:0:23071901)

The "partner ID" in trade offer URLs is actually the account's account ID.
 
Reading Rendered IDs

Here's how to interpret the rendered ID formats.

 

Steam3 Format

 

[T:U:A] or [T:U:A:I]

  • T - This is a single letter (case-sensitive) which tells you what type of account this is. The characters are documented on the Valve developer wiki.
  • U - This is the universe to which this SteamID belongs. Unless you work for Valve, this will always be 1.
  • A - This is the account ID for this SteamID.
  • I - This is the SteamID's instance number. May be omitted if the instance is the default for that ID type or can be determined in other ways.

Steam2 Format

 

The Steam2 rendered format can only be used for individual SteamIDs.

 

STEAM_X:Y:Z

  • X - This is the universe to which this SteamID belongs. Older games use 0 to stand for public, newer ones use 1.
  • Y - This is the SteamID's accountid modulo 2.
  • Z - This is the SteamID's accountid halved and rounded down.

Working with SteamIDs in code

If you're using Node.js, you can use node-steamid to parse, create, and deal with SteamIDs.

If you're using PHP, you can use php-steamid.

If you're using C#, SteamKit has a SteamID class.


  • Andrew and ArturkA like this


#1088 not confirm trade after running a while

Posted by speicher on 17 June 2016 - 03:38 PM

ok, that should work based on your wiki.
community.on('sessionExpired', function(err) {
	if (err) {
		console.log('sessionExpired: '+err);
	}
	
	community.stopConfirmationChecker();
	
	
	if (client.steamID) {
		client.webLogOn();
	} else {
		client.logOn(logon_details);
	}
});

  • T1MOXA and Royalgamer06 like this


#891 Uses of steam-user

Posted by Dr. McKay on 20 May 2016 - 06:37 PM

You can use getPersonas to get persona data. Off the top of my head (this might not work), getting an avatar URL would go something like this:

user.getPersonas(["76561198006409530"], (personas) => {
    var hash = personas["76561198006409530"].avatar_hash.toString('hex');
    var url = "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/" + hash.substring(0, 2) + "/" + hash + "_full.jpg";
});

  • metuero likes this


#4767 Get node-steam client Object for node-csgo from node-steam-user

Posted by Dr. McKay on 03 December 2017 - 12:29 PM

There is no other way to do it. Steam imposes limits on how frequently you can send inspect requests.


  • exellian likes this


#4129 Getting item id

Posted by TomYoki on 15 August 2017 - 08:17 AM

just call 

manager.getExchangeDetails();

https://github.com/D...failed-callback


  • LuciFer likes this


#2123 Bot running 24/7 - Quick question

Posted by Dr. McKay on 13 November 2016 - 02:21 PM

That will create a new interval every time your session expires. Either use setTimeout or create the internal outside of that event callback.

 

Also, you may want to listen for the sessionExpired event.


  • EthanBOT likes this


#1862 Will I get 7 day penality ?

Posted by Dr. McKay on 09 October 2016 - 08:47 PM

If you're using two-factor authentication (via SDA or whatever), then there's no new-device cooldown, so no.

 

But if you aren't, then the answer is still no because "devices" are remembered by sentry files. Your sentry file is saved by steam-user in your appdata directory, so it will always be reused on the same machine (until you reformat or whatever).


  • boxxy likes this