Binary to Text

This tool takes a string of 0 and 1 characters — a sequence of bits written out as text — and converts it back to the characters those bits represent. The conversion runs in your browser; nothing leaves your machine. For the inverse direction, see text to binary.

How the conversion works

Input:  01001000 01100101 01101100 01101100 01101111
Group:  every 8 characters = 1 byte
Bytes:  0x48     0x65     0x6c     0x6c     0x6f
ASCII:   H        e        l        l        o
Output: Hello

Each byte (8 bits) is interpreted as a number 0–255. For values 0–127, that’s an ASCII character. For values 128–255, the interpretation depends on the encoding — most modern systems use UTF-8, where the high-bit bytes form multi-byte character sequences.

What inputs are valid

The tool above accepts:

• Strict 8-bit groups. 01001000 01100101 ... with spaces between bytes. The cleanest form.
• Continuous bit string. 0100100001100101... with no spaces. The tool groups by 8 from the start.
• Mixed whitespace. Tabs, newlines, multiple spaces. All collapsed to delimiters.
• Short groups. A space-separated group shorter than 8 bits is read as a number: 1000001 is 65, the same byte as 01000001 (A).

It does not accept:

• Anything other than 0, 1, and whitespace. A stray 2 or letter aborts the conversion with an error naming the offending character.
• A continuous bit string whose length isn’t a multiple of 8. A trailing partial byte raises an error rather than being silently padded.
• Space-separated groups longer than 8 bits. Each group has to fit in one byte.

UTF-8 in binary

A single Unicode character above ASCII range becomes multiple bytes in UTF-8:

Character: é (U+00E9)
UTF-8 bytes: 0xC3 0xA9
Binary:      11000011 10101001

Character: ✓ (U+2713)
UTF-8 bytes: 0xE2 0x9C 0x93
Binary:      11100010 10011100 10010011

The high bits of each byte signal the byte’s role:

• 0xxxxxxx → ASCII character (single byte)
• 110xxxxx → start of 2-byte character
• 1110xxxx → start of 3-byte character
• 11110xxx → start of 4-byte character
• 10xxxxxx → continuation byte (not a start)

The tool above interprets bytes as UTF-8, so multi-byte sequences come out as the corresponding character. Invalid UTF-8 sequences (a continuation byte without a start byte, an unfinished sequence) show up as the replacement character � rather than stopping the conversion.

When you’ll actually use this

Binary representation of text is rarely a transit format — it’s 8× larger than the bytes themselves. It shows up in:

• Education. Learning how characters become bytes; demonstrating ASCII or UTF-8 mechanics.
• Low-level debugging. Reading a memory dump or a corrupted-byte sample where the source already shows bits.
• Embedded systems output. Microcontroller serial output sometimes prints character bits for diagnostic visibility.
• Steganography puzzles and CTFs. Hidden messages encoded as bit sequences in image LSBs or whitespace.

Binary vs hex

Hex is the more compact and conventional way to write bytes:

For looking at bytes in any practical context, hex to text is the tool you want — it does the same conversion in 2-character hex form instead of 8-character binary form. Binary form exists when you specifically want to see the bit pattern.

Common pitfalls

• Wrong endianness assumption. Within a byte, the standard convention is most-significant-bit first (01000001 = decimal 65 = A). Some niche systems write bits LSB first (10000010 for the same A). Most binary-to-text tools assume MSB; the tool above does the same.
• Forgetting the leading zero. 1000001 is 7 bits and ambiguous — is it the start of a multi-byte sequence or an incomplete byte? Always pad to 8 bits per byte.
• Mixing encodings mid-stream. A binary string that’s part ASCII (single bytes) and part UTF-8 multi-byte is fine, but if some bytes are intended as Latin-1 and others as UTF-8, the decoder gets confused. Pick one encoding for the whole input.
• Whitespace-only delimiters. Some sources use 00100000 (the binary for ASCII space) as a delimiter between binary “characters.” Then the literal space bit pattern looks like a delimiter to a too-clever parser. Stick to actual whitespace as delimiter and bits as content.

For the encoding direction (text → binary), see text to binary. For the more common hex form, see hex to text.