A binary to text cheat sheet is a quick reference that maps 8-bit binary codes, the groups of eight 0s and 1s that computers group into bytes, to the letters, digits, and punctuation they represent, with one byte per character. The ASCII table covers English letters A–Z and a–z, digits 0–9, and common punctuation, each assigned a fixed binary value: capital A is 01000001, lowercase z is 01111010, the digit 5 is 00110101, and a space is 00100000. These values come from the original ASCII standard, where every character is stored as one byte from 00000000 to 01111111, leaving the high bit free for extensions. That is the heart of any cheat sheet: a lookup table that lets you decode a short string by eye, the same way you would read a multiplication table. For anything longer, with accents, emoji, or unfamiliar scripts, a static cheat sheet stops being enough and you need a real converter. The free Binary To Text tool handles both directions, decodes and encodes with full UTF-8 support, and runs the entire conversion inside your browser so your input never leaves your device.
The Printable ASCII Cheat Sheet
Every cheat sheet starts with the same backbone: the printable ASCII range from decimal 32 (the space character) to decimal 126 (the tilde ~). That window of 95 characters covers everything most English-language text needs, and each character has a single, fixed 8-bit binary representation. Memorize a handful of the most common ones and you can decode short strings without a table at all, but having the full reference saves you when a less common symbol shows up. The combined letter table below covers all 52 English letters; the second table covers digits and the punctuation you meet in casual messages.
| Character | Decimal | Binary |
|---|---|---|
| A | 65 | 01000001 |
| B | 66 | 01000010 |
| C | 67 | 01000011 |
| D | 68 | 01000100 |
| E | 69 | 01000101 |
| F | 70 | 01000110 |
| G | 71 | 01000111 |
| H | 72 | 01001000 |
| I | 73 | 01001001 |
| J | 74 | 01001010 |
| K | 75 | 01001011 |
| L | 76 | 01001100 |
| M | 77 | 01001101 |
| N | 78 | 01001110 |
| O | 79 | 01001111 |
| P | 80 | 01010000 |
| Q | 81 | 01010001 |
| R | 82 | 01010010 |
| S | 83 | 01010011 |
| T | 84 | 01010100 |
| U | 85 | 01010101 |
| V | 86 | 01010110 |
| W | 87 | 01010111 |
| X | 88 | 01011000 |
| Y | 89 | 01011001 |
| Z | 90 | 01011010 |
| a | 97 | 01100001 |
| b | 98 | 01100010 |
| c | 99 | 01100011 |
| d | 100 | 01100100 |
| e | 101 | 01100101 |
| f | 102 | 01100110 |
| g | 103 | 01100111 |
| h | 104 | 01101000 |
| i | 105 | 01101001 |
| j | 106 | 01101010 |
| k | 107 | 01101011 |
| l | 108 | 01101100 |
| m | 109 | 01101101 |
| n | 110 | 01101110 |
| o | 111 | 01101111 |
| p | 112 | 01110000 |
| q | 113 | 01110001 |
| r | 114 | 01110010 |
| s | 115 | 01110011 |
| t | 116 | 01110100 |
| u | 117 | 01110101 |
| v | 118 | 01110110 |
| w | 119 | 01110111 |
| x | 120 | 01111000 |
| y | 121 | 01111001 |
| z | 122 | 01111010 |
Notice a pattern in the upper half of that table. Every capital letter begins with 010 and the last five bits encode the letter's position: A is 00001, B is 00010, all the way to Z at 11010. Lowercase letters start a few rows later because they live between decimal 97 and 122, and every one begins with 011 instead. Those two leading-bit patterns are enough to read the case of any letter without consulting the rest of the byte.
| Character | Decimal | Binary |
|---|---|---|
| 0 | 48 | 00110000 |
| 1 | 49 | 00110001 |
| 2 | 50 | 00110010 |
| 3 | 51 | 00110011 |
| 4 | 52 | 00110100 |
| 5 | 53 | 00110101 |
| 6 | 54 | 00110110 |
| 7 | 55 | 00110111 |
| 8 | 56 | 00111000 |
| 9 | 57 | 00111001 |
| space | 32 | 00100000 |
| ! | 33 | 00100001 |
| . | 46 | 00101110 |
| , | 44 | 00101100 |
| ? | 63 | 00111111 |
| @ | 64 | 01000000 |
Every digit from 0 to 9 begins with 0011, and the last four bits encode the digit itself in binary. A space is its own byte at 00100000, and the rest of the lower punctuation lives in the same neighborhood. Together with the letter table, this gives you enough fixed codes to decode any short English string by hand as long as the input is grouped into clean eight-bit bytes.
How to Decode Binary to Text Using the Cheat Sheet
The decoding procedure is straightforward. Split the input into blocks of eight bits, look each block up in the cheat sheet, and write down the matching character in order. Working through a concrete example makes the steps concrete: take 01001000 01101001. Split into two bytes: 01001000 and 01101001. From the letter table, 01001000 matches H (decimal 72, since 64 + 8 = 72) and 01101001 matches i (decimal 105, since 64 + 32 + 8 + 1 = 105). Reading the bytes left to right, the result is the two-letter word "Hi". The same arithmetic works for every other byte.
- Split the binary string into 8-bit chunks. Insert a space every eight digits so each chunk is a single byte. Spaces, tabs, and line breaks in the input are ignored, but the bits themselves must form complete bytes.
- Look each byte up in the cheat sheet. Match the eight bits against the printable ASCII table above, or fall back to a converter when the string is longer than a handful of characters.
- Read the characters in order. Each byte is one character, and the position of the byte in the original string is the position of the decoded character in the output text.
- For longer strings, use the Binary To Text converter. Paste the full binary string into the Binary → Text direction and the decoded text appears directly under the input, with no manual lookup needed.
- Verify the result. A working decode is always an exact multiple of eight bits. If the bit count is not divisible by eight, the input is malformed and the converter will flag it instead of returning garbled output.
The same tool runs in the opposite direction for encoding. Switch the toggle to Text → Binary, type any text, and the 8-bit output appears byte by byte below the input box. Each byte becomes exactly eight bits, separated by a space, ready to paste into a message, log, or worksheet. Non-ASCII characters such as accents, non-Latin scripts, and emoji span two, three, or four bytes, so their binary representation runs longer than eight bits. Use the Copy button to grab the result, or Swap direction to feed the output straight back as the next input.
Three Shortcuts for Reading Binary by Eye
The full table is fine for reference, but a few patterns let you decode common characters almost instantly. These are the shortcuts that turn a cheat sheet into something you can use in your head rather than a step you take for every byte.
- Watch the high bits. If a byte starts with 010, it is a capital letter or one of the symbols between @ and Z (decimal 64 to 90). If it starts with 011, it is a lowercase letter or a symbol between ` and ~ (decimal 96 to 127). You can read case from the first three bits alone.
- Identify digits and spaces by their leading bits. Digits 0 to 9 all start with 0011 and a space is 00100000. Any byte that starts with 0010 is one of the lower punctuation marks such as space, !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /.
- Decode powers of two first. The value of each bit position doubles from right to left: 1, 2, 4, 8, 16, 32, 64, 128. Find the largest power of two that fits into the byte, subtract it, and repeat. Doing this on 01101001 gives 64 + 32 + 8 + 1 = 105, which is the letter i. The same arithmetic works for every byte.
Combined, those three habits let you skim a binary string without flipping back to the table for every byte. The cheat sheet then becomes a fallback for unusual characters rather than a step you take for each one.
Beyond ASCII: When the Cheat Sheet Stops Working
The printable ASCII table only covers 95 characters. Real-world text quickly runs past it: a French menu has é, a Japanese email has characters like 你好, and any chat message can contain an emoji like ☕. Those characters live above decimal 127, which means their bytes start with a leading 1 rather than a 0. ASCII alone cannot describe them, so modern software uses UTF-8, a variable-width encoding that keeps plain English as single bytes but stretches accented letters, non-Latin scripts, and emoji across two, three, or four bytes each.
UTF-8 is the reason a static cheat sheet runs out of room. An accented letter like é is no longer a single byte to look up; it is two bytes (11000011 10101001) whose meaning only emerges when you decode both together. A smiley emoji can be four bytes long. Trying to read multi-byte UTF-8 by hand from a fixed lookup table is impractical, which is exactly the situation a converter is built for. The Binary To Text tool encodes and decodes through UTF-8, so the word café and the phrase "你好" round-trip without corruption, even though their binary representations run longer than eight bits per character. If you want the longer explanation of how UTF-8 keeps ASCII identical while extending it, the step-by-step guide to binary-to-text conversion walks through the same logic with more examples.
When you see a binary string whose bytes start with a 1, you are looking at UTF-8 territory. The byte count no longer tells you the character count, and the cheat sheet gives way to the converter.
Common Errors That Break a Binary Cheat Sheet
Cheat sheets fail in predictable ways. Knowing the usual mistakes saves you from trusting a decode that is actually nonsense.
- Bits that don't add up to a multiple of eight. Every byte is exactly 8 bits, so the total bit count should be divisible by 8. If it is not, you have dropped or added a digit. The Binary To Text converter surfaces this with an explicit message rather than producing a partial decode.
- Confusing UTF-8 bytes with single characters. An accented letter or emoji takes more than one byte in UTF-8. Treating each byte as a separate character produces gibberish, the same way reading Chinese stroke-by-stroke would not give you a word.
- Ignoring the leading zero. A is 01000001, not 1000001. Many people drop leading zeros because they look unnecessary, but every byte must be exactly eight digits. 1000001 is decimal 65 read as seven bits, which is a different value than the eight-bit byte at the same position.
- Mixed endianness or bit order. Some old systems write bits right-to-left within a byte. The cheat sheet above assumes standard left-to-right (MSB-first) order, which is what UTF-8 and almost every modern format use. If your decode looks like nonsense, the bit order is the first thing to check.
Aim your binary string at the cheat sheet when it is short, ASCII-only, and grouped cleanly into eight-bit bytes. Send anything else through the Binary To Text converter, which catches these errors automatically and supports every character that UTF-8 can describe. Everything runs locally in your browser using plain JavaScript, so nothing you type is uploaded, logged, or sent to any server, and the conversion keeps working even if you go offline after the page has loaded.
If you're weighing options, Convert Encoding to UTF-8: Hex, Decimal, and Binary covers this in detail.