Binary to Text Converter

This converter reads binary as whole bytes and gives back the text they spell. For one code value rather than a message, use Binary to ASCII; for a plain number, use Binary to Decimal.

Going the other way? Convert text back to binary →

How do you convert binary to text?

Binary to text conversion reads each group of binary digits as one code, then replaces that code with the character it stands for, so 2 groups give 2 characters.

1. Split the input into 8-digit groups. The first group is 01001000.
2. Read that group as a number. 01001000 is 72.
3. Replace the number with its character. 72 is H.
4. Repeat for every group and join the characters in order: 01001000 01101001 = Hi.

Binary to Text Conversion Table

Every letter, digit and the space, with its code in all four bases. Find the character in the first column and read across: the Dec column is the code the method uses, and the Bin column is what this converter reads — 8 digits per character, zero-padded on the left. That column uses the digit set 0, 1 and nothing else, each place worth 2ⁿ, and a value marked with the 0b prefix means the same thing. This page shows the rows you need; ASCII code chart (decimal, hex, octal, binary) carries all 128.

The base this page writes, defined by the digits it uses, how a value is marked, and what each position is worth.

Worked Example: 01001000 01101001 to Text

One group at a time, with the working written out. This is the same grid the converter shows when you turn on "show steps".

Start at the left. The first group is 01001000, which reads as 72, and 72 is the code for H. The groups are all the same width, so there is no guesswork about where one ends and the next begins.

The rest follow the same way: 01101001 is 105, which is i. Joining the characters in the order the groups arrived gives Hi. Read a group in the wrong place and every character after it shifts, which is why the width matters more than the separator does.

Check it in reverse

The value goes back the way it came. Read 01001000 is 72, and 72 is H; read 01101001 is 105, and 105 is i. Nothing is lost on the return trip, because every character keeps one group of its own and the groups keep their order. A decoder needs no extra information from the encoder — the fixed width tells it where each group ends, and the table tells it what each code means. To verify the result by hand, encode the text back to binary and compare it with what you started from.

Worked examples: binary to text

Each example gives the value first, then the working. Click a value to load it in the converter.

Every example above reverses exactly — encode the same words back into 8-bit groups.

What Changes the Text Output?

Spaces and line breaks

A space is a character like any other: code 32, or 00100000. A trailing space converts too, which is the usual reason an output runs one group longer than expected.

Characters outside ASCII

UTF-8 encodes each character in 1 to 4 bytes. Characters 0–127 use one byte identical to ASCII, so ASCII text is valid UTF-8. Above code 127 UTF-8 uses more than one byte per character, so the byte count stops matching the character count. é is U+00E9 and encodes as C3 A9 (2 bytes); € is U+20AC and encodes as E2 82 AC (3 bytes); 😀 is U+1F600 and encodes as F0 9F 98 80 (4 bytes). Written the way this page writes them, those are é = 11000011 10101001, € = 11100010 10000010 10101100 and 😀 = 11110000 10011111 10011000 10000000. the encoding rules behind this converter sets out why.

Width and padding

ASCII defines 128 characters, codes 0–127, using 7 bits; in practice each code is stored in one 8-bit byte with a leading 0. That is why A is 01000001 here, not 1000001. Uppercase and lowercase differ by 32, which is bit 5, so a is 01100001.

Separator choice

The space between groups is a display choice; the bytes do not change. iToolHub's text-to-binary and text-to-hex converters write one 8-bit byte per character, separated by spaces. Pick no separator when the output feeds another program, a comma for a spreadsheet.

Binary to Text in Code

The same rule in one line. Both read the codes and return the original string.

Python: bytes(int(g, 2) for g in s.split()).decode('utf-8')

JavaScript: new TextDecoder().decode(new Uint8Array(s.split(/\s+/).map(g => parseInt(g, 2))))

Common Mistakes

• Dropping the leading zero, so A reads 1000001 instead of 01000001. The output then splits into the wrong groups.
• Mixing widths inside one string. The first half decodes; the rest is noise.
• Pasting codes instead of characters — that is a different conversion, and it lives on bin to ASCII code lookup.
• Forgetting that the space between words is its own group, 00100000. The counts then disagree.

Frequently Asked Questions

Related Conversions

• To ASCII codes by the same route — bin to ASCII code lookup.
• To decimal by the same route — binary to decimal with the power-of-2 row.
• To hex by the same route — change binary into hex four bits at a time.
• Input in ASCII codes instead? convert ASCII code to text.
• Input in decimal instead? convert a decimal code to its character.
• Input in text instead? encode a string as hex bytes.

The rest of the family sits on the binary converter index.