SteamID64, STEAM_0 and SteamID3 Share One Account Number

Paste a Steam profile link into something and it hands back a number that looks nothing like the link, plus two or three more numbers that do not look like each other either: 76561197960287930, STEAM_1:0:11101, [U:1:22202]. None of that looks like arithmetic. All of it is.

Already have an ID? Paste it into the SteamID Converter and every format above comes back at once, plus a vanity-URL lookup for the one case arithmetic can't touch.

One account number, three ways of writing it down

Every format a Steam tool has ever printed - the 17-digit SteamID64, the legacy STEAM_X:Y:Z, the newer [U:1:W] - is a container for the same 32-bit account number. Valve assigned that number once, when the account was created, and every identifier since is that number wrapped in a different amount of packaging.

Wrapping is the right word. Nothing here compresses, hashes or encrypts anything. It is bit placement, and it is placement a person can do on paper.

The 64 bits, and the 32 that never change

A SteamID64 is a 64-bit integer with four fields packed into it, narrowest first: the lowest bit is Y, the next 31 bits are the account number Z, the next 20 are an "instance" (1, for a normal user), the next 4 are an account type (1, for "Individual"), and the top 8 are a "universe" (1, for "Public").¹

Every ordinary profile shares the same top 32 bits - universe 1, type 1, instance 1 - so those bits pack to one fixed value: 0x0110000100000000, or 76561197960265728 in decimal. That number is not a coincidence you have to memorize; it falls straight out of shifting three constants into place and adding them, and it is the whole reason the next section works.

Why an ordinary account is just addition

Because 32 of the 64 bits are frozen, converting an ordinary account's SteamID64 is one line:

SteamID64 = 76561197960265728 + accountID

Take the example from the top. 76561197960287930 - 76561197960265728 = 22202, so the account number is 22202. Every other format is that same 22202, spelled differently:

One account, read four ways. Y is accountID % 2, Z is accountID / 2 rounded down.

Format	Value	Where it comes from
Account number	22202	The number Valve assigned
SteamID64	76561197960287930	76561197960265728 + 22202
STEAM_X:Y:Z	STEAM_1:0:11101	Y = 22202 % 2 = 0, Z = 22202 / 2 = 11101
SteamID3	[U:1:22202]	The account number, unpacked and printed as-is

Reversing any of them is the same arithmetic run backwards. Z * 2 + Y turns STEAM_1:0:11101 back into 22202. Subtract the base from 76561197960287930 and you get there too. Three formats, one small integer, and none of the arithmetic needs anything beyond what fits on the back of an envelope - which is the whole reason a static site can do this conversion entirely in the browser tab.

STEAM_0 became STEAM_1, and no account moved

The leading digit in STEAM_X:Y:Z names the universe, and it has a history that trips people who assume a format never changes. GoldSrc and the original Source engine games, Counter-Strike and Counter-Strike: Source among them, wrote 0 there. Valve's later titles - Left 4 Dead, Alien Swarm, Counter-Strike: Global Offensive, and now CS2 - write 1.¹ Nothing about the account changed between those two engines. The digit is an engine-era label, not a second universe some accounts quietly moved into, which is why this tool's converter only ever emits STEAM_1 and treats an incoming STEAM_0 as the same account.

What Z quietly gives away, and where it lies

The account number climbs with time, because Valve handed the numbers out in the order accounts were created. A profile with Z = 1,234 predates one with Z = 1,234,111 by roughly the gap you'd expect, and the SteamID alone is enough to say which of two accounts is older.¹

It is a trend, not a timestamp. Internet-cafe accounts were drawn from their own block, sitting roughly between account numbers 7,000,000 and 8,000,000 regardless of when the machine they were created on first went online, and that block also holds ordinary accounts that simply happened to register in the same window.¹ Treat the ordering as a rough sort, not a signup date.

The Y bit hiding at the very bottom of that same integer is smaller trivia with a specific job: Valve records which of two authentication servers handled the account in that single bit, not anything about the player.¹ It participates in the arithmetic - halve the account number and Y is the remainder - and carries no other meaning past that.

SteamID3's W is not another formula

It is easy to assume [U:1:W] runs its own conversion, because it looks like the odd one out: a letter, then two numbers, in a format neither of the other two use. It does not. W is the account number itself, the same Z * 2 + Y you would compute for STEAM_X:Y:Z, just handed back as one integer instead of split into two. There is no fourth number involved anywhere in this system - every identifier on this page decodes to the same 22202, and SteamID3 is the one that shows it to you plainly.

What arithmetic cannot do: a vanity URL

Every conversion above runs offline, because every format is a rearrangement of the same bits with no server involved. A vanity URL - steamcommunity.com/id/somename - breaks that. The custom name was chosen by the account holder and stored against their account on Valve's side; nothing about the string somename encodes the account number, so there is no formula to run backward.

Resolving one means asking Steam directly, through the Web API's ResolveVanityURL endpoint.² The SteamID Converter offers that lookup the moment it recognizes a vanity URL it cannot decode by math, routed through this site's own backend so the request is one name, nothing else, and nothing is stored on either end.

Why the tool reaches for BigInt, not Number

SteamID64 values run 17 digits long, past 9,007,199,254,740,992 - two to the fifty-third - where JavaScript's Number type stops being able to represent every integer exactly. Past that point, doubles can only land on every sixteenth integer at this magnitude, and everything in between rounds to whichever of those is closest.

The example from the top of this article demonstrates it without any coaxing. Assign 76561197960287930 to a plain JavaScript number and ask it to print itself back:

const id = 76561197960287930;
id.toString(); // "76561197960287940"

Ten higher than what went in, and nothing threw, warned, or looked wrong along the way - a plausible 17-digit SteamID64 came out the other end, decoding to a different account number than the one that was typed in. Paste that corrupted value into a converter and it does not stumble either: it decodes cleanly into a complete SteamID3 and profile URL, because 22212 is just as valid an account number as 22202 was.

BigInt does not round: 76561197960287930n stays exactly that, through every shift, mask and addition the converter runs on it, which is why the tool is written against BigInt throughout rather than Number. Paste any of the four formats into the converter and the other three come back instantly, computed the same way this article did it by hand - just without the risk of quietly losing a digit along the way.