Binary Translator_
Paste binary in any shape it arrives — 8-bit groups split by spaces, commas, or line breaks, one continuous bit stream, or messy mixed separators — and read it as text instantly. Classroom-style 7-bit ASCII is detected and offered explicitly, and errors point at the exact character or group that broke, not just "invalid input".
Decoding is strict and local: bytes that aren't valid UTF-8 switch to a hex dump with a Latin-1 view instead of silent � replacement characters, and the whole translation runs in this tab — it works with your network unplugged.
- Input
- Ones and zeros in whatever shape you were given them: 8-bit groups separated by spaces, commas, tabs or newlines, a continuous unbroken stream, or 7-bit groups from an older source.
- Output
- The characters those bits stand for. When the bytes are not valid text the view switches to a hex dump rather than printing replacement squares, and Latin-1 is one click away for older data.
- Processing
- Translated in this tab as you type. A string pulled out of a log or a capture stays with you.
- Limits
- No length cap. A group that is not a whole byte, or a character that is not 0 or 1, is reported with its exact position instead of being silently dropped.
- Going the other way?
- Turning your own text into ones and zeros is the text to binary tool. This page is for binary you did not write.
A binary to text converter that shows its work
How binary becomes text
How to convert binary to text, in three steps: split the bits into 8-bit bytes, turn each byte into a number, and look that number up in a character encoding. 01000001 is 65, and 65 is "A" — that lookup table is ASCII, and reading binary to text yourself is just doing it repeatedly (the reference table below covers the printable range). This page automates the same binary to text translation live as you type: framing bits into bytes, decoding the bytes as UTF-8, and reporting exactly how it framed them — 8 groups × 8 bits → 8 bytes — so you can check its reading against your intent.
7-bit vs 8-bit — the classroom trap
ASCII is historically a 7-bit code: "H" is 72, which needs only 1001000. Modern computing stores it in an 8-bit byte as 01001000, but worksheets, puzzles, and older material often write the 7-bit form. Most converters either reject it or — worse — silently glue the 7-bit groups into one stream and re-slice it into 8-bit bytes, producing convincing-looking garbage. This page refuses to guess: when every group is 7 bits, it says so and offers a one-click "Decode as 7-bit" mode that reads each group as one character.
What UTF-8 looks like in binary
Every ASCII character fits one byte starting with 0. Everything else — accents, currency signs, CJK, emoji — is encoded as a multi-byte sequence: the first byte starts 110, 1110, or 11110 (announcing 2, 3, or 4 bytes), and every continuation byte starts 10. That is why one emoji becomes four binary groups, and why chopping a sequence in half doesn't yield "half a character" — it yields invalid UTF-8. When that happens here, decoding fails loudly: you get a hex dump and a Latin-1 view instead of replacement characters, because � is data loss dressed up as output.
In code, and what this page is not
To decode binary to text in Python: bytes(int(b, 2) for b in s.split()).decode('utf-8'). In JavaScript: map each group through parseInt(b, 2) into a Uint8Array and hand it to TextDecoder. And mind the boundary: this page decodes bytes as characters. If you want the numeric value of one binary number (10100110 = 166), that is the binary to decimal converter's job; for the reverse direction use the text to binary converter.
Paste the ones and zeros, get the characters back
- 01Paste the binary code — or Upload a file, or press Sample. The binary to text translation runs live: spaces, commas, tabs, and line breaks all work as separators, in any mix, and a continuous bit stream works too.
- 02Read the status line: it reports the framing it used (groups × bits → bytes), so you can verify the translator read your input the way you meant it.
- 03If every group is 7 bits, the page flags it as classroom-style ASCII and offers Decode as 7-bit — nothing is silently re-framed. Errors name the exact character or group, with a caret pointing at it.
- 04Take the text with Copy, or save it with Download. When the bytes are not valid text at all, the Hex and Latin-1 views show you what the binary actually decoded to.
Four inputs people actually paste
Classroom 7-bit worksheet
Homework and puzzle binary is often written in 7 bits per letter. Instead of garbling it, the page detects the shape and offers the right mode.
1001000 1100101 1101100 1101100 1101111
Every group is 7 bits — this looks like 7-bit ASCII… [Decode as 7-bit] → Hello
Spaced byte dump
The standard shape: one byte per group, spaces between. Decodes live, with the framing reported.
01001000 01101001 00100001
Hi! ✓ Decoded 3 groups × 8 bits → 3 bytes
Continuous bit stream
Tool output with the separators stripped. As long as the count divides by 8, it decodes; if not, the error names the leftover bits and where they start.
0100100001101001
Hi ✓ Decoded 16 bits → 2 bytes (continuous stream)
Emoji in binary (UTF-8)
One 👋 is four bytes: a 11110-leading byte and three 10-continuations. The sample button loads this exact sequence.
11110000 10011111 10010001 10001011
👋
Binary to ASCII — the printable range
| Character | 8-bit binary | 7-bit form | Decimal |
|---|---|---|---|
| space | 00100000 | 0100000 | 32 |
0 … 9 | 00110000 … 00111001 | 0110000 … | 48–57 |
A … Z | 01000001 … 01011010 | 1000001 … | 65–90 |
a … z | 01100001 … 01111010 | 1100001 … | 97–122 |
! ? . | 00100001 00111111 00101110 | — | 33, 63, 46 |
Each range is sequential, so one anchor is enough to read the rest. Lowercase is uppercase + 32 — in binary, exactly one flipped bit: 01000001 (A) vs 01100001 (a). The 7-bit form is the same value without the leading 0.
UTF-8 byte patterns in binary
| Code points | Binary pattern | Bytes | Example |
|---|---|---|---|
| U+0000–U+007F (ASCII) | 0xxxxxxx | 1 | A → 01000001 |
| U+0080–U+07FF | 110xxxxx 10xxxxxx | 2 | é → 11000011 10101001 |
| U+0800–U+FFFF | 1110xxxx 10xxxxxx 10xxxxxx | 3 | € → 11100010 10000010 10101100 |
| U+10000–U+10FFFF | 11110xxx + three 10xxxxxx | 4 | 👋 → 11110000 10011111 10010001 10001011 |
A byte starting 10 is always a continuation — it never stands alone. Dropping or truncating one is what turns a paste into invalid UTF-8, which this page reports instead of papering over.
Reading binary that someone else produced
- Paste as-is. Spaces, commas, tabs, and line breaks are all separators, mixed freely — no need to clean the input first, and the notices row tells you what was normalized.
- Check the framing in the status line before trusting the output: “8 groups × 8 bits” means byte groups; “joined into one stream” means the groups weren’t uniform and the bits were concatenated.
- If the result looks like nonsense Latin characters, suspect a 7-bit/8-bit mismatch — decoding 7-bit groups as an 8-bit stream shifts every subsequent character.
- A bit count that isn’t a multiple of 8 usually means a lost digit in copy-paste. The error tells you how many bits are left over and where they start — count back from there.
- Binary numbers and binary text are different questions: 10100110 as a value is 166 (binary to decimal converter); as a byte of text it’s not valid UTF-8 on its own.
- For the reverse direction — writing text as binary — use the text to binary converter; the pair round-trips cleanly, emoji included.
When a binary string refuses to become text
7-bit groups decoded as an 8-bit stream
Concatenate classroom ASCII (7 bits per letter) and re-slice it into bytes and you get plausible-looking garbage — every character after the first borrows bits from its neighbor. This page detects the all-7-bit shape and refuses to decode it until you pick the explicit 7-bit mode.
One character is not always one byte
Anything beyond ASCII — é, €, emoji — becomes 2 to 4 bytes in UTF-8. Expecting one group per character makes multi-byte text look “too long” or truncates it mid-sequence. The UTF-8 pattern table above shows exactly how the byte counts fall out.
Mixed or missing separators change the framing
With uniform 8-bit groups the separators are decoration. But non-uniform groups force a choice: this page joins them into one stream only when the total forms whole bytes, and says so in a notice — silent re-framing is how wrong answers look right.
Decoded bytes that aren’t text
Binary dumps of files, ciphertext, or sensor data decode into bytes that fail UTF-8 validation. Tools that substitute � for every bad sequence destroy the information; here the decode fails fatally and the hex and Latin-1 views show the actual bytes.
Binary values vs binary text
“Convert 1101 to binary text” is usually a numbers question, not a text question — 1101 is 13, and 13 is a control character, not a letter. If you want arithmetic, the binary to decimal page does exact math on values of any size.
Grouping, encodings and input tolerance
- Input shapes
- 8-bit groups with space/comma/tab/newline separators in any mix; continuous bit streams; non-uniform groups joined into a stream when they form whole bytes (reported, never silent)
- 7-bit ASCII
- All-7-bit-group input (and continuous streams divisible by 7 but not 8) is flagged and decoded only via the explicit Decode-as-7-bit mode
- Error reporting
- First invalid character with its exact position and a caret excerpt; broken groups named with their bits and position; leftover-bit counts for continuous streams
- Text handling
- Bytes are decoded as UTF-8 in fatal mode, so a sequence that is not valid text sends you to the hex dump rather than a page of U+FFFD. Single-byte legacy data has its own Latin-1 view.
- Views
- Text · Hex (grouped byte pairs) · Latin-1, with Copy following the active view
- Large inputs
- A megabyte of binary digits is 125 KB of text, and parsing it is one linear scan. Only the on-screen preview is bounded: 300k characters of text, 4,096 bytes of hex. Copy and Download are unaffected and always carry the complete result.
- File handling
- Uploads are read inside the page with the browser File API and are never transmitted; Download writes out what is already in the tab. You get decoded.txt for valid text and decoded.bin for raw bytes.
- Network
- None from tool code. A test sweep calls every function this page uses with
fetchandXMLHttpRequestreplaced by stubs that throw, so a stray request fails the build instead of shipping. Disconnect from the network and the page still works.
Questions about translating binary
How do I convert binary to text by hand?
Split the bits into groups of 8, convert each group to decimal, and look the number up in an ASCII table: 01001000 → 72 → “H”. The printable-range table above gives you the anchors; every range (digits, uppercase, lowercase) is sequential from there.
Why does my binary decode to gibberish?
The usual causes, in order: 7-bit groups being read as 8-bit (check for the Decode-as-7-bit offer), a missing or extra bit shifting everything after it (the leftover-bits error tells you where), or bytes that were never text in the first place — check the hex view.
What does “not a multiple of 8” mean?
Text bytes are 8 bits each, so the total bit count must divide by 8. If it doesn’t, some bits can’t form a whole byte — the error reports how many are left over and the position where they start, which is usually where a copy-paste lost a digit.
Does it handle emoji and non-English text?
Yes — the decoder is full UTF-8, so multi-byte sequences (accents, CJK, emoji up to 4 bytes) decode correctly. Try the Sample button: it ends with a wave emoji encoded as four binary groups.
Can it convert binary to a decimal number?
That’s a different operation: this page decodes bytes into characters, while the binary to decimal converter evaluates a binary numeral into its numeric value with exact math at any size. Cross-links, not guesses — the two questions only look similar.
Is anything I paste uploaded?
No — and binary dumps are worth asking about, since they come out of memory captures and firmware images rather than out of nowhere. The work is JavaScript running in this tab. Every function it calls is covered by a test that stubs fetch and XMLHttpRequest to throw, so a request that slipped in would break the build rather than reach a server — and you can confirm it for yourself by disconnecting and carrying on.