Binary to String Converter
Paste a binary string to convert it to text — strict UTF-8 decoding with a per-byte breakdown, show-your-work steps, honest errors, and a reverse text-to-binary mode.
▸ Convert
Auto-detects direction: binary digits decode to text, anything else encodes to binary.
Per-byte breakdown
Show your work
⚠ Scope check — is this the right tool?
This tool = binary (0/1 bit strings) ↔ text (characters), decode-first. It answers “what text do these bits encode?” — e.g. 01001000 01101001 → “Hi” — with a per-byte proof and strict, honest UTF-8 error handling. The reverse tab encodes text back to bits.
Not this: binary-to-decimal / binary-to-hex ask “what NUMBER is this bit string?” — the same bits as a numeric value (01000001 = 65), not as characters (01000001 = “A”). Numbers vs characters are different jobs.
Sibling: ascii-to-binary is the encode-focused lab (bit visualizer, ASCII table, MSB/LSB) — this page is its decode-focused counterpart: paste bits, verify what they say.
Also different: base64 is a separate transport encoding (A–Z, a–z, 0–9, +, /), not 0/1 bits. Hex-text converters work on base-16, not binary.
Same job, other names: binary to string conversion is also searched as binary to ascii converter, binary string to text, or binary code to string — ASCII is simply UTF-8's first 128 characters, so all of it is covered here. Binary to decimal and binary to hex are the numeric-value variants (numbers, not characters); binary string vs base64 is answered in the FAQ.
Note on older pages: nrtechstudio.com hosts earlier general translators (binary-to-text, binary-converter, binary-decoder) from the mass-build era. This page is the new, independently verified build for the “binary to string” query — strict UTF-8 validation, byte-level breakdown, and worked examples.
▸ Worked examples
Every step below is computed by the same engine that powers the converter — verify them yourself in the box above.
1 Decode “Hi” — ASCII bytes
- Group into bytes: the space marks byte boundaries → 01001000 and 01101001.
- Byte 1: 01001000 = 0·128 + 1·64 + 0·32 + 0·16 + 1·8 + 0·4 + 0·2 + 0·1 = 72. Code 72 is “H” (U+0048).
- Byte 2: 01101001 = 0·128 + 1·64 + 1·32 + 0·16 + 1·8 + 0·4 + 0·2 + 1·1 = 105. Code 105 is “i” (U+0069).
- Result: “Hi” — both bytes start with 0, so each is a complete 1-byte UTF-8 character.
2 Decode “é” — a 2-byte UTF-8 character
- Byte 1: 11000011 = 0xC3 = 195. It starts with 110, the marker for a 2-byte UTF-8 character; the payload bits are 00011.
- Byte 2: 10101001 = 0xA9 = 169. It starts with 10, a valid continuation byte; payload bits are 101001.
- Combine: code point = 00011₂ × 64 + 101001₂ = 3 × 64 + 41 = 233 = U+00E9 = “é”.
- Why not one byte? 195 and 169 are both above 127 — neither can be a character on its own in UTF-8. Together they form exactly one character.
3 Reverse: “café” → binary
- UTF-8 encode each character: c → 0x63, a → 0x61, f → 0x66, é → 0xC3 0xA9 (two bytes).
- Write each byte as 8 bits: 0x63 = 01100011, 0x61 = 01100001, 0x66 = 01100110, 0xC3 = 11000011, 0xA9 = 10101001.
- Result: 5 bytes for 4 characters — the breakdown shows bytes 4–5 grouped under the single character “é”.
✕ Honest error, not a guess
The tool refuses: invalid character “X” — only 0, 1 and separators are allowed. And 11000011 alone gives an incomplete UTF-8 sequence error naming the starting byte, instead of silently inventing a character.
▸ Methodology — how decoding works
No black box: these are the exact rules the engine applies, in order.
1. Tokenizing (format auto-detect)
| Input shape | Rule | Example |
|---|---|---|
| Separated groups | Split on spaces, commas, semicolons, pipes, newlines; strip 0b prefixes | 0b01001000, 01101001 |
| Continuous stream | Chunked every 8 bits only if length is a multiple of 8 | 0100100001101001 → 2 bytes |
| Wrong group size | Honest error naming the group (e.g. 7 bits) | 0100100 → rejected |
| Foreign characters | Honest error naming the character | X, 2 → rejected |
2. UTF-8 decoding (strict)
| First byte pattern | Bytes | Payload bits | Example char |
|---|---|---|---|
0xxxxxxx | 1 | 7 | A (U+0041) |
110xxxxx + 10xxxxxx | 2 | 11 | é (U+00E9) |
1110xxxx + 2× 10xxxxxx | 3 | 16 | € (U+20AC) |
11110xxx + 3× 10xxxxxx | 4 | 21 | 😀 (U+1F600) |
Rejected outright: overlong encodings (a character written with more bytes than needed), UTF-16 surrogates (U+D800–U+DFFF), code points above U+10FFFF, stray continuation bytes, and truncated sequences. A decoder that guesses at these produces mojibake; this one reports the exact byte.
3. Error taxonomy
| Code | Meaning |
|---|---|
EMPTY | No binary digits found in the input. |
BAD_CHAR | A character other than 0/1/separator — the message names it. |
BAD_GROUP | A group that isn't 8 bits — the message names the group number and size. |
INCOMPLETE | A multi-byte character cut off at the end — names the starting byte. |
INVALID_SEQ | Bad continuation byte, overlong form, or surrogate — names the byte. |
INVALID_BYTE | A byte (e.g. 0xFF) that can never start a UTF-8 character. |
▸ Convert binary to string in code
The same conversion, in your language — each snippet decodes 01001000 01101001 to Hi.
Python
bits = "01001000 01101001"
text = bytes(int(b, 2) for b in bits.split()).decode("utf-8")
print(text) # HiJavaScript
const bits = "01001000 01101001";
const bytes = bits.trim().split(/\s+/).map(b => parseInt(b, 2));
const text = new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(bytes));
console.log(text); // HiJava
String bits = "01001000 01101001";
String[] groups = bits.trim().split("\\s+");
byte[] bytes = new byte[groups.length];
for (int i = 0; i < groups.length; i++)
bytes[i] = (byte) Integer.parseInt(groups[i], 2);
String text = new String(bytes, java.nio.charset.StandardCharsets.UTF_8);
System.out.println(text); // HiC#
string bits = "01001000 01101001";
byte[] bytes = bits.Split(' ').Select(b => Convert.ToByte(b, 2)).ToArray();
string text = System.Text.Encoding.UTF8.GetString(bytes);
Console.WriteLine(text); // HiSQL Server
-- binary column -> text (UTF-8 bytes stored in VARBINARY) SELECT CAST(CAST(0x0100100001101001 AS VARBINARY(MAX)) AS VARCHAR(MAX)); -- 0x4869 = 'Hi'
PHP
$bits = "01001000 01101001";
$text = implode('', array_map(
fn($b) => chr(bindec($b)), preg_split('/\s+/', trim($bits))));
echo $text; // HiGo
bits := "01001000 01101001"
var buf []byte
for _, g := range strings.Fields(bits) {
v, _ := strconv.ParseUint(g, 2, 8)
buf = append(buf, byte(v))
}
fmt.Println(string(buf)) // HiRust
let bits = "01001000 01101001";
let bytes: Vec<u8> = bits.split_whitespace()
.map(|b| u8::from_str_radix(b, 2).unwrap()).collect();
let text = String::from_utf8(bytes).unwrap(); // strict UTF-8
println!("{}", text); // HiPowerShell
$bits = "01001000 01101001"
$bytes = $bits -split '\s+' | ForEach-Object { [Convert]::ToByte($_, 2) }
[System.Text.Encoding]::UTF8.GetString($bytes) # HiC
#include <stdio.h>
#include <string.h>
int main(void) {
const char *groups[] = {"01001000", "01101001"};
for (int i = 0; i < 2; i++) {
unsigned v = 0;
for (int j = 0; j < 8; j++) v = (v << 1) | (groups[i][j] - '0');
putchar(v); /* ASCII only — use a UTF-8 library for multibyte */
}
return 0; /* prints: Hi */
}▸ Frequently asked questions
Straight answers — the same text search engines see in the structured data below.
Paste binary digits into the converter above — for example 01001000 01101001. The tool groups the bits into 8-bit bytes, turns each byte into a number (01001000 = 72), and maps that number to its UTF-8 character (72 = H). 01001000 01101001 decodes to Hi. Spaced, comma-separated, newline-separated, 0b-prefixed, or continuous bitstreams are all auto-detected.
A binary string is a sequence of 0s and 1s (bits) that represents something else. Two common meanings: (1) a bit sequence grouped into 8-bit bytes where each byte encodes one character — e.g. 01000001 is the letter A; (2) in programming, a string object that holds raw binary data rather than readable text. This tool handles meaning (1): decoding bit sequences into human-readable text.
Yes. Each character is assigned a number (its code point), and that number is written in base 2. UTF-8 — the dominant encoding — uses 1 byte for basic English (A = 01000001), 2 bytes for accented letters (é = 11000011 10101001), 3 bytes for symbols like €, and 4 bytes for emojis like 😀. Any string of characters can therefore be represented as one long binary string.
Three steps. (1) Grouping: the bit stream is split into 8-bit bytes — separators like spaces or commas are used when present, otherwise a continuous stream is chunked every 8 bits. (2) Byte value: each byte is read as a base-2 number, e.g. 01101001 = 64 + 32 + 8 + 1 = 105. (3) Character mapping: the byte sequence is decoded as UTF-8 — byte 105 is the character i. The per-byte breakdown table above shows all three steps for your exact input.
Spaces (01001000 01101001), commas (01001000,01101001), semicolons, pipes, and newlines are all treated as byte boundaries. A 0b prefix on each group (0b01001000) is stripped automatically. A single continuous stream (0100100001101001) is chunked into bytes when its length is a multiple of 8. Every group must be exactly 8 bits — the tool tells you the exact group number if one isn't.
That means the input ends in the middle of a multi-byte character. For example, 11000011 alone starts the 2-byte letter é but the required continuation byte is missing — so there is nothing honest to decode it to. Complete the sequence (for é, add 10101001) and it will decode. The error names the byte where the sequence starts.
The bytes don't form legal UTF-8. Common causes: a stray continuation byte like 10000000 appearing where a character should start, an overlong encoding (a character written with more bytes than necessary), or bytes that would decode to a UTF-16 surrogate (U+D800–U+DFFF), which can never be real characters. Instead of silently guessing, this tool rejects the input and points at the offending byte.
They answer different questions about the same bits. Binary-to-string asks "which characters do these bits encode?" — 01000001 is the letter A. Binary-to-decimal asks "what number is this?" — 01000001 is the number 65. If you want a numeric value from a bit string, use a base converter; if you want readable text, you're in the right place.
A binary string is the raw 0/1 representation of data; base64 is a different text encoding (using A–Z, a–z, 0–9, +, /) designed to transport binary data through text-only channels like email. 01000001 (binary string for A) and QQ== (base64 for A) encode the same byte two different ways. This tool decodes raw 0/1 bits, not base64.
Switch to the "String → Binary" tab and type any text. Each character is UTF-8 encoded and each byte is written as 8 bits — Hi becomes 01001000 01101001. You can change the byte delimiter (space, comma, newline, or none) and add a 0b prefix per byte. Accented characters and emojis produce multiple 8-bit groups, one per UTF-8 byte.
Yes — full UTF-8 is supported, not just ASCII. 11000011 10101001 decodes to é (2 bytes), 11100010 10000010 10101100 decodes to € (3 bytes), and 11110000 10011111 10011000 10000000 decodes to 😀 (4 bytes). The byte breakdown shows which bytes belong to each character so you can see the multi-byte grouping.
Binary is base 2: each bit position represents a power of 2. In an 8-bit byte the positions are worth 128, 64, 32, 16, 8, 4, 2, 1 from left to right. Add the values where the bit is 1: 01000001 = 64 + 1 = 65, and code 65 is the character A. That's the whole trick — bits → number → character.
The simplest correct way: bytes(int(b, 2) for b in "01001000 01101001".split()).decode("utf-8") gives 'Hi'. For a continuous bitstream, chunk it first: [s[i:i+8] for i in range(0, len(s), 8)]. Python's bytes.decode("utf-8") is strict by default and raises on invalid sequences — same honesty as this tool. More snippets (JavaScript, Java, C#, SQL) are in the code section above.
Yes, it's private. This converter runs 100% in your browser with plain JavaScript — no server, no analytics payload, no request carrying your input anywhere. You can disconnect from the internet after the page loads and it keeps working. Nothing you paste is stored or transmitted.