Binary to Text

Bits back into words — eight at a time, decoded as UTF-8, with invalid bytes marked instead of silently turned into the wrong character.

Runs 100% in your browser•Nothing is uploaded to a server•Free forever

Binary

Binary digits — separated into bytes or one long run

01001000 01100101 01101100 01101100 01101111

Text

Copied!

Eight bits at a time

Decoding binary back into text means cutting the stream into bytes and looking each one up. The converter accepts the bits in whatever shape you have them — one long unbroken run, or groups separated by spaces, commas or underscores — and treats every eight bits as one byte. Where the input has no separators it chunks from the right, so a run whose length is not a multiple of eight keeps its low bytes intact and only the leading byte comes up short.

Get the alignment wrong and the output is not slightly wrong, it is unrecognisable. A single stray or missing bit shifts every subsequent byte and turns readable text into a run of unrelated symbols. If your output looks like noise from the first character, the usual cause is a bit count that is not a multiple of eight.

Not every byte is a letter

Values below 32 are control codes, not characters, and they are why a decoded string sometimes has invisible content or line breaks you did not expect:

Byte values that are not letters
Decimal	Name	Binary	What it does
0	`NUL`	`00000000`	end of a C string
7	`BEL`	`00000111`	the terminal bell
8	`BS`	`00001000`	backspace
9	`TAB`	`00001001`	horizontal tab
10	`LF`	`00001010`	newline on Unix
13	`CR`	`00001101`	the other half of a Windows newline
27	`ESC`	`00011011`	opens an ANSI escape sequence
32	`SP`	`00100000`	a space is a character like any other
127	`DEL`	`01111111`	delete, and the last 7-bit code

The pair to watch is 13 and 10. A Windows line ending is both — 00001101 00001010 — while a Unix one is just 10. Binary that decodes with a stray character at the end of every line is usually a CRLF file being read as if it were LF.

When the bytes are not text at all

Binary that came from an image, an archive or an encrypted blob is not going to decode into anything meaningful, and that is not a failure of the converter. This page decodes as UTF-8 and follows the standard's rule for invalid input: every byte that cannot start or continue a valid sequence becomes U+FFFD, the replacement character �. So a scattering of � means specific bytes were invalid, while a solid wall of them means the data was never UTF-8 text.

Truncation shows up the same way. The euro sign is three bytes; feed in only the first two and you get a replacement character, because a partial sequence is not a character.

Related: text to binary for the return trip, hex to text which is the same job in a more compact notation, and the number base converter.