Hex to Decimal Converter – uint256, bytes32 and int256 (Big Numbers)

Q: How is int256 handled?

If an unsigned value has its top bit set (greater than 2255 − 1) the page also shows the negative number it represents in two's complement; for a negative input it shows the 32-byte word a contract would store.

What is a hex to decimal converter?

A hex to decimal converter reads a base-16 string such as 0xde0b6b3a7640000 and returns the same number in base 10 (here 1,000,000,000,000,000,000, or 10¹⁸), and vice versa. For blockchain work the numbers are up to 256 bits, so the converter must use arbitrary-precision integers and also show the 32-byte zero-padded word and the signed (int256) reading that the EVM uses.

Handy values

Decimal	Hex	Meaning
1,000,000	0xf4240	1 USDT / USDC (6 decimals)
1,000,000,000	0x3b9aca00	1 gwei in wei; 1 SOL in lamports
10¹⁸	0xde0b6b3a7640000	1 ether in wei
2⁶⁴ − 1	0xffffffffffffffff	uint64 max
2¹²⁸ − 1	0xffff…ffff (32 f)	uint128 max
2²⁵⁶ − 1	0xffff…ffff (64 f)	uint256 max, the "unlimited" approve amount

Worked example

A storage slot read returns 0x00000000000000000000000000000000000000000000000000000000000f4240. Stripping the leading zeros leaves 0xf4240 = 15×16⁴ + 4×16³ + 2×16² + 4×16 + 0 = 983,040 + 16,384 + 512 + 64 = 1,000,000, which is 1 USDT in 6-decimal units. A word of 64 f characters is 2²⁵⁶ − 1 as a uint256 but −1 as an int256, which is how a contract stores negative one.

Common mistakes

Reading a decimal string as hex. 1000000 is one million in decimal but 16,777,216 in hex. The page treats digit-only input as decimal unless you add 0x.
Losing precision in a spreadsheet. Values above 2⁵³ (about 9 × 10¹⁵) are rounded by double-precision floats; wei and 18-decimal token amounts exceed that.
Forgetting the sign. A word whose first hex digit is 8 or higher has its top bit set and may represent a negative int256 rather than a huge uint256.
Odd-length hex. 0xabc is a valid number but not a whole number of bytes; it occupies 2 bytes once the leading nibble is padded.

Typical workflow

Copy a word from the calldata breakdown in the ABI decoder or from a storage slot in a block explorer.
Paste it here to read it as a decimal amount; then divide by the token's decimals with the token decimals converter or the Ethereum unit converter.
If the value looks like 0xffff…, check the int256 row: it may be a negative number or an "infinite" allowance.

Frequently asked questions

Why not use a normal hex converter?

Most convert through 64-bit or floating-point numbers and silently lose digits above about 16 decimal places. EVM words are 256 bits, so a token balance such as 0xde0b6b3a7640000 (10¹⁸) already breaks them. This page uses arbitrary-precision integers.

What is the bytes32 row?

The value left-padded with zeros to 32 bytes (64 hex characters), which is how it appears as a word in calldata, return data, storage and event data.

How is int256 handled?

If an unsigned value has its top bit set (greater than 2²⁵⁵ − 1) the page also shows the negative number it represents in two's complement; for a negative input it shows the 32-byte word a contract would store.

Does it accept hex without 0x?

Yes, when the string contains at least one letter a–f. A string of only digits is read as decimal; add 0x to force hex.

How do I convert hex to decimal by hand?

Multiply each digit by 16 raised to its position from the right, starting at 0, and add them up: 0x2a = 2×16 + 10 = 42. Letters a–f stand for 10–15. For 64-digit values the arithmetic is tedious, which is what this page is for.

Why do Ethereum RPC responses use hex?

The JSON-RPC specification encodes all quantities as 0x-prefixed hex strings without leading zeros so that 256-bit values survive JSON parsers that only support 64-bit numbers. Block numbers, balances, gas and nonces all arrive this way.

What does the byte length tell me?

How many bytes the number needs without padding. Useful for checking whether a value fits a uint8, uint64, uint128, and whether an address-sized value (20 bytes) has been passed where a uint was expected.