Binary Hex Decimal Converter

Common uses

• Debugging bit flags
• Color and memory values
• CS homework checks

The arithmetic is exact at any size, which is unusual in a browser tool

This converter parses your number digit by digit into a BigInt, so there is no floating-point step and no rounding. That matters more than it sounds, because the ordinary number type in JavaScript cannot hold a whole number above 9,007,199,254,740,991 without losing precision, and most quick converters are built on it.

Measured here:

• 9007199254740993, which is that limit plus two and the classic case an ordinary number gets wrong, converts to hex 20000000000001 and comes back exactly.
• A 40-digit decimal number converts to a 130-digit binary string and a 33-digit hex string with every digit intact.

So you can paste a long identifier, a hash fragment or a large key value in here and trust the result. If you need to check it, convert the answer back the other way.

Negative numbers and decimal points are refused, not rounded

The parser accepts only digits valid for the base you chose, and a minus sign and a full stop are not digits. Measured, both in decimal:

• -5 gives “Invalid digit for base 10”.
• 10.5 gives the same message.

Refusing is the right behaviour, because there is no single correct answer to either question. A negative number in binary could be a sign bit, one’s complement or two’s complement, and those give three different answers for the same input, depending on a word size nobody has told the tool. A fraction in another base is usually non-terminating, so it would need a precision the tool would have to guess. Both would mean inventing an assumption and presenting it as a result.

If you need two’s complement, decide your word width first, add the number to that power of two, and convert the result: for an 8-bit representation of -5, convert 251. If you need a fraction, convert the whole part here and work out the fractional digits separately.

It is tolerant about how you type the number and strict about the digits

Before parsing, the input is trimmed, all internal whitespace is removed, and a leading 0x or 0b is dropped. Measured:

• 0xFF in hex gives 255. 0b1010 in binary gives 10.
• 1010 1010 in binary gives 170, so you can paste bytes with spaces in them.
• ff in hex gives 255, so case does not matter on input.
• 0000042 in decimal gives 42; leading zeros are harmless.

What it will not forgive is a digit that does not belong to the base. Measured: 12 in binary gives “Invalid digit for base 2”, because there is no digit 2 in binary. That message does not say which character was wrong or where, so on a long string you have to find it yourself. The usual culprits are a letter O typed for a zero, a letter l for a one, and a hex string pasted while the base is still set to decimal.

You always get all four bases out, whichever one you came from

The input base is a choice between binary, octal, decimal and hexadecimal, and the output is always all four at once. There is no arbitrary base: you cannot convert to base 7 or base 36 here, and there is no option to.

Hex output is upper case and binary output has no grouping, so a 32-bit value arrives as 32 unbroken digits. If you want it in bytes of eight, Text to Binary groups its output that way, though it works on text rather than on a number.

What this tool deliberately does not do

• No negative numbers and no two’s complement, for the reason above.
• No fractions.
• No bases other than 2, 8, 10 and 16, in or out.
• No bit operations. It will not shift, mask, and, or or xor anything.
• No byte grouping on the binary output, and no choice of upper or lower case on the hex.
• No character conversion. It converts numbers, so it will not tell you that 65 is the letter A. Text to Binary does that.
• No history. Nothing is saved, so refreshing loses what you typed.

Nothing is uploaded. The conversion is a few lines of JavaScript running in your browser, and the number never leaves your device.

Sources

• Why an ordinary JavaScript number cannot hold large integers exactly: Number.MAX_SAFE_INTEGER. developer.mozilla.org
• The exact-integer type this tool uses instead: BigInt. developer.mozilla.org
• The floating-point format behind that limit: IEEE 754, as described in the ECMAScript number type. tc39.es/ecma262
• Converting a value to a string in a given radix, which is how the four outputs are produced: BigInt.prototype.toString. developer.mozilla.org

Every behaviour and every converted value on this page was measured against this tool as it is published, in a browser, on 14 October 2026. Where the page says what the tool does not do, that is a statement about this tool, not about base conversion in general.