How does it know which base I typed?

By the prefix: 0x for hexadecimal, 0b for binary, 0o for octal, the same convention JavaScript, Python, Rust and C all use in source code. Anything with no recognised prefix is read as plain decimal. Set From base explicitly if your input has no prefix and is not decimal.

Why does a very large hex value convert without losing digits?

Because the conversion is done with an arbitrary-precision integer type, not a plain JavaScript number, which starts losing precision above 2 53 . 0xFFFFFFFFFFFFFFFF (2 64 − 1) converts exactly to 18446744073709551615 ; a plain-number implementation would round that.

What’s the difference between a plain minus sign and two’s complement?

By default, a negative number just gets a minus sign in every base: -5 in binary is -101 , which is simple but only meaningful if you already know the number is signed. Two’s complement instead encodes the sign into a fixed number of bits, the way processors and most typed languages actually store signed integers: -5 as a signed 8-bit integer is 11111011 . Turn it on when you need the bit pattern a real 8/16/32/64-bit signed variable would hold.

What happens if a number does not fit in the bit width I picked?

It is rejected rather than silently wrapped or truncated: 200 does not fit as a signed 8-bit integer (whose range is −128 to 127), so it stops with "200 does not fit in a signed 8-bit integer (range -128 to 127)". Pick a wider bit width, or use the plain minus-sign form instead.

Number Base Converter: Binary, Octal, Decimal, Hex

How to use

Paste a number (with a 0x, 0b or 0o prefix, or plain decimal digits) or pick its base explicitly from From base.
Read the four results: binary, octal, decimal and hexadecimal, all computed from the same parsed value. Under them, the Bit map shows the binary in groups of four with each group's hex digit above it (hover a bit for its position), and In fixed-width storage shows how the value reads as an unsigned and a signed 8, 16, 32 and 64-bit integer.
For a negative number, tick Show as two's complement and pick the Bit width if you need the fixed-width bit pattern rather than a plain minus sign.
Click any result to copy it: the prefix (0x/0b/0o) is included so it pastes straight into most languages' source code.

Why more than one way to write the same number

Binary is what the hardware actually stores; hexadecimal is a compact, human-readable stand-in for binary (each hex digit is exactly 4 bits, so conversion between them is mechanical); octal shows up mostly in Unix file permissions and some older systems; decimal is what everyone reads and writes by hand. Reading a value in one base while thinking in another (a permission bitmask, a color's hex packed into a 32-bit integer, a memory address) is common enough that doing the arithmetic by hand is both slow and easy to get wrong.

Example

The number 0xCAFEBABE (the magic number at the start of every compiled Java .class file) is, in every base:

0b11001010111111101011101010111110
0o31277535276
3405691582
0xcafebabe

Options explained

From base: Auto-detect / Binary / Octal / Decimal / Hexadecimal: Auto-detect reads the 0x/0b/0o prefix if present and otherwise assumes decimal; pick a base explicitly for input with no prefix that is not decimal (plain ff, for instance, is ambiguous between hex and an invalid decimal number without it).
Bit map: one hex digit is always exactly four bits, which is why hex is the usual shorthand for binary; the map lines them up so that is visible. It is drawn for values up to 64 bits. For a negative number it shows the magnitude until two's complement is ticked, then the stored bit pattern.
In fixed-width storage: for each width, the value as an unsigned integer and the same bits read as a signed one. A reading in amber differs from the number you typed: 0xCAFEBABE is 3405691582 unsigned but -889275714 as a signed 32-bit integer, the classic overflow surprise. "Does not fit" means the value needs more bits than that width has.
Show as two's complement and Bit width: see the FAQ. Only affects negative numbers; positive numbers look the same either way.
Load sample inserts 0xCAFEBABE; Clear empties the box.

Edge cases and common errors

Digits that don't fit the base. 12 read as binary stops with "That is not a valid binary (0-1) number". A binary number can only contain 0 and 1.
Empty input stops with "Enter a number" rather than showing four blank results.
Thousands separators and underscores are tolerated: 1,000,000 and 1_000_000 both parse as one million, matching how many languages let you write a large literal.
Values beyond 2⁵³ convert exactly: see the FAQ; this is the one place a naive base-converter built on plain numbers would quietly give the wrong answer.
Two's complement out of range: see the FAQ.
The prefix is always included in the copied value (0x, 0b, 0o); if your target expects bare digits, just drop the first two characters after copying.

Do the same thing in code

// JavaScript
(3405691582).toString(16);   // 'cafebabe'
parseInt('cafebabe', 16);    // 3405691582 (loses precision above 2**53)
BigInt('0xcafebabe');        // 3405691582n (exact at any size)

# Python
hex(3405691582)              # '0xcafebabe'
int('cafebabe', 16)          # 3405691582 (Python ints have no size limit)

Python's integers are arbitrary-precision by default, so it never has the precision problem JavaScript's plain Number does. This tool uses JavaScript's BigInt for the same reason Python doesn't need one.

Runs entirely in your browser: this page is a static file with no server behind it, so nothing you paste can be uploaded. Last reviewed 25 September 2026 by Parthesh Gupta.