Decoding binary means running the encoding process in reverse. When text was stored, each character turned into a number (its ASCII value), and that number got written out as 8 binary digits. To recover the original text, you just undo those two steps: read 8 bits at a time, convert each group to its decimal value, then look up which character that decimal value represents.
The process is mechanical. There is no guesswork, and you do not need to know the content in advance. Any string of ones and zeros whose length is a multiple of 8 can be decoded to ASCII text using nothing but arithmetic and a lookup table.
Splitting binary into 8-bit groups
The first move is to divide the binary string into groups of exactly 8 bits. Each group is one byte, which encodes one character. If the string was written with spaces between groups, the work is already done for you. If not, count from left to right and insert a boundary every 8 digits.
Take this string: 0100100001101001
Counting from the left: bits 1 through 8 give 01001000, bits 9 through 16 give 01101001. Two groups, which means two characters.
If the string has spaces already, 01001000 01101001, the groups are visible. Either format works. The key rule is that you always start from the left edge and take 8 digits at a time. Do not start from the right, and do not try to split at what looks like a natural boundary inside a group.
Converting each group to decimal
Binary is positional notation in base 2. Each digit position represents a power of 2, starting at 2^0 (which is 1) on the right and doubling for each position to the left. For an 8-bit group, the positions are worth 128, 64, 32, 16, 8, 4, 2, and 1, from left to right.
To get the decimal value, multiply each binary digit by its position's value and add the results. Skip any position where the digit is 0, since multiplying by 0 contributes nothing.
For the group 01001000:
- Position 128: digit 0, contributes 0
- Position 64: digit 1, contributes 64
- Position 32: digit 0, contributes 0
- Position 16: digit 0, contributes 0
- Position 8: digit 1, contributes 8
- Position 4: digit 0, contributes 0
- Position 2: digit 0, contributes 0
- Position 1: digit 0, contributes 0
Total: 64 + 8 = 72.
Worked example: 01001000 01101001 decodes to "Hi"
Two groups from above. Group one converts to 72. Group two, 01101001, works out like this:
- 64 + 32 + 8 + 1 = 105
So the two decimal values are 72 and 105. Now look those up in the ASCII table.
ASCII 72 is the uppercase letter H. ASCII 105 is the lowercase letter i. The decoded text is "Hi."
That is the whole process. Split into 8-bit groups, convert each to decimal, look up each decimal in ASCII. For longer strings, the only thing that changes is the number of repetitions.
ASCII lookup table for common characters
This table covers the characters that appear most often in practice. Knowing the anchor values (A = 65, a = 97, 0 = 48, space = 32) lets you work out neighbouring characters quickly without memorizing the entire table.
| Binary (8-bit) | ASCII (decimal) | Character |
|---|---|---|
| 01000001 | 65 | A |
| 01000010 | 66 | B |
| 01011010 | 90 | Z |
| 01100001 | 97 | a |
| 00100000 | 32 | space |
| 00110000 | 48 | 0 |
| 00110001 | 49 | 1 |
| 00100001 | 33 | ! |
| 00111111 | 63 | ? |
Notice that the digit character "0" (ASCII 48, binary 00110000) and the number zero in binary (just 00000000) look completely different. If you are decoding a binary string and your result seems to be all zeros, double-check whether the source was a text encoding or a raw numeric value.
What if the binary length is not a multiple of 8?
This is the first sign that something went wrong upstream. Standard ASCII text encoding always produces a total bit count that divides evenly by 8. A string of, say, 17 bits cannot represent whole characters under ASCII.
A few things can cause this. The most common is a transcription error: a stray digit was dropped or an extra one was added. Count the total bits, subtract from the next multiple of 8 or from the previous one, and see if removing or adding a digit at a plausible position produces a sensible result.
Another possibility is leading-zero truncation. If the encoder that produced the binary string dropped leading zeros and stored some groups as fewer than 8 digits, you need to pad each short group on the left before decoding. A group of 7 digits gets one leading zero; a group of 6 digits gets two; and so on.
Some less common encodings use 7 bits per character (matching the original 7-bit ASCII specification) rather than 8. If you suspect this, try splitting at every 7 digits instead and see if the decoded characters make sense.
Using the tool at /
The binary decoder on the home page handles all of the above automatically. Paste the binary string, click decode, and the result appears immediately. The tool accepts binary with or without spaces between groups, and it will tell you if the input length is invalid rather than silently producing garbled output. It runs entirely in your browser, with nothing sent to a server.
For one-off lookups, the manual process is fine. For anything longer than a sentence, the tool saves considerable time and eliminates arithmetic errors.
Extended ASCII and Unicode limits
Standard ASCII covers values 0 through 127. Bytes in the range 128 through 255 are sometimes called "extended ASCII," but that term refers to several incompatible standards: Windows-1252, ISO-8859-1 (Latin-1), and others. If you decode a byte with a value of 200, what character it represents depends on which extended set the encoder used.
For modern text that includes non-English characters, emoji, or mathematical symbols, the encoding is almost certainly UTF-8. UTF-8 uses 1 byte for standard ASCII characters (values 0 to 127) and 2 to 4 bytes for everything else. That means a single emoji might be 4 bytes, or 32 bits of binary. Decoding UTF-8 binary by hand follows the same convert-to-decimal logic, but the lookup is more involved because multi-byte sequences have a specific bit structure that signals how many bytes belong together.
If you are decoding text that was definitely plain English from a standard keyboard, standard 8-bit ASCII is the right assumption and the tool handles it correctly. If you are not sure of the encoding, the safest approach is to use the tool, which attempts UTF-8 first before falling back to Latin-1.
FAQ
What should I do if my binary string has extra spaces?
Extra spaces between 8-bit groups are fine and actually helpful because they mark the character boundaries. Spaces inside a group, or leading and trailing spaces on the whole string, can be ignored. The decoder only needs to identify each clean 8-bit sequence.
What does it mean if my decoded text shows a question mark or a box?
A question mark or a small box (the Unicode replacement character) usually means the binary value does not map to a printable character in the encoding being used. ASCII values above 127 fall outside standard ASCII. Values in the range 128 to 255 belong to extended ASCII or Latin-1, and a value above that range suggests the input may be UTF-8 rather than plain ASCII.
Can I decode binary that was not space-separated?
Yes, as long as the total length is a multiple of 8. Split the string into groups of 8 digits starting from the left, then convert each group. The tool on the home page handles unseparated binary automatically.
Is binary the same as hexadecimal?
No. Binary is base 2, using only 0 and 1. Hexadecimal is base 16, using digits 0 through 9 and letters A through F. Both represent the same underlying data, and you can convert between them, but a hex string like 48 69 and a binary string like 01001000 01101001 look very different even though they both decode to the word Hi.