Binary to Decimal Converter — Read Base-2 Numbers as Base-10

Read a binary value as a regular base-10 number. Position weights are powers of two: the rightmost bit is worth 1, then 2, 4, 8, 16, and so on. This page treats the entire input as one unsigned integer (no 32-bit ceiling, no sign bit assumed).

How binary to decimal works

Each bit is multiplied by a power of two based on its position from the right. For 1010: 1·2³ + 0·2² + 1·2¹ + 0·2⁰ = 8 + 0 + 2 + 0 = 10. Whitespace inside the input is stripped before parsing, so 1010 and 0000 1010 give identical results.

Quick examples

How to use

1. Paste binary digits into the Input box. Spaces and newlines between groups are ignored.
2. The decimal value appears immediately in Output. No length cap — BigInt handles 64-bit, 256-bit, even 1000-bit inputs.
3. Click Decimal → Binary at the top (or hit Swap) to reverse direction.
4. Use Copy to grab the result. Conversion runs in your browser; nothing is uploaded.

Real-world use cases

• Parsing network protocol fields. Packet captures often display raw bits for length, flag, or TTL fields; converting them back to decimal makes the value match what the spec actually documents.
• CTF and reverse-engineering challenges. Flags and hidden numeric payloads frequently arrive as long bit strings. Dropping them straight into a base-2 reader is faster than writing a one-off script.
• Teaching positional notation. Showing 1010 next to "8 + 2" is the cleanest way to demonstrate why a base is just a choice of column weights — and why digits past the radix never appear.
• Inspecting memory dumps and registers. A debugger that prints r0 = 10110100 is easier to reason about once the value lands in decimal for mental arithmetic.
• Reading bitwise-operation results. After applying AND, OR, or XOR to a value, the binary pattern shows you which bits flipped; the decimal form tells you what the new number is.
• Verifying hand-computed arithmetic. Classroom exercises that add or subtract in binary become trivially checkable by running both operands and the result through this converter.

From bits to numbers — how the conversion works

Every place in a binary number carries a positional weight — a power of two that grows by a factor of two each step to the left. The rightmost column is worth 2⁰ = 1, then 2¹ = 2, 2² = 4, 2³ = 8, and so on. To convert, multiply each bit by its column weight and add the results. For 1010 this is 1·8 + 0·4 + 1·2 + 0·1 = 10; for 11111111 it is 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255. Nothing magical happens — it is the same algorithm that turns the decimal digits 347 into 3·100 + 4·10 + 7·1, only with base two instead of base ten.

The idea predates electronics. Gottfried Wilhelm Leibniz set out a full positional binary system in his 1703 paper "Explication de l'Arithmétique Binaire", complete with addition and multiplication tables. A century and a half later George Boole's 1854 Laws of Thought gave the algebra that operates on those two values, and Claude Shannon's 1937 master's thesis showed that the same algebra describes electrical switching circuits — the bridge from pure mathematics to working hardware. Every register read and integer parse since traces back to that sequence of insights.

One practical note: this tool does the addition in JavaScript BigInt, not the usual 64-bit float. Plain Number loses precision past 53 bits, which silently corrupts long bit strings; parseInt(str, 2) has the same problem. BigInt has no such ceiling, so a 1,024-bit input round-trips exactly. If you want to go the other way after converting, the decimal to binary converter uses the same arithmetic, and binary to hex covers base-16 when that is a tidier representation.

Worked examples

Four short conversions, each opened with the column-weight method:

Common pitfalls

• Treating binary as BCD. Binary-coded decimal stores one decimal digit per nibble: 0010 0111 in BCD reads as "27", but in plain binary it is 39. This page does plain binary; if you have BCD, split into 4-bit groups and read each as a decimal digit.
• Signed vs unsigned confusion. 11111111 is 255 unsigned but −1 in 8-bit two's complement. Always check whether the source field was declared uint8 or int8 before deciding which result is "right".
• Reading the bits backwards. Positional weights run right-to-left, just like decimal: the rightmost bit is the ones place. Flipping the order turns 1100 (12) into 0011 (3) — a different number entirely.
• Hitting Number precision limits. Plain JavaScript Number and parseInt(str, 2) silently lose accuracy past 53 bits. This tool sidesteps the problem by using BigInt; if you are converting in your own code, do the same or expect strange off-by-one results on long strings.
• Counting separators as digits. The converter strips whitespace before parsing, so 1010 and 0000 1010 behave identically. But commas, dashes, or 0b prefixes are not whitespace — they will be rejected as non-binary characters. If your input is messy, head over to the binary code translator docs for a fuller breakdown of accepted formats.