Free Binary to ASCII Converter

Turn binary into ASCII characters and see each character’s code. Works with 7-bit and 8-bit binary.

  • Free
  • No sign-up
  • Runs in your browser
  • 7-bit & 8-bit
Text
BinaryDecimalCharacter
Free7-bit & 8-bit

Runs in your browser. Nothing you type is uploaded.

Paste binary and this binary to ASCII converter shows the character for each byte, with its decimal ASCII code next to it. It doubles as an ASCII translator and ASCII decoder for all 128 codes, including the invisible control characters most converters print as nothing. To decode a whole message with emoji or accents, use the binary code translator instead.

How to convert binary to ASCII

To convert binary to ASCII, split the binary into groups of eight digits (or seven, for 7-bit ASCII). Turn each group into a number using place values 128, 64, 32, 16, 8, 4, 2, 1. Then find that number in the ASCII table: 01001000 = 72 = H. New to place values? How to read binary walks through it step by step, with practice.

  1. Split into bytes. 010010000110100100100001 becomes 01001000 01101001 00100001. Count before you split: 24 digits means three bytes. If you get 23, a digit went missing somewhere, and every byte after that point will decode to the wrong character.
  2. Turn each byte into its ASCII code. 72, 105, 33. (In 01001000, the 1s sit under 64 and 8. Add them: 72.)
  3. Look up each code in the table below. 72 is H, 105 is i, 33 is an exclamation mark. Hi!

Here’s a shortcut that catches a lot of mistakes. Every ASCII code is 127 or less, so the first digit of an 8-bit ASCII byte is always 0. A byte that starts with 1 isn’t ASCII at all, and no table on this page will have it.

Binary to ASCII table (0–127)

This is the full ASCII code translator chart: all 128 codes in 8-bit and 7-bit binary, with the decimal code for each. Type a character, a binary code or a number into the search box to jump to its row.

ASCII binary table. Every code checked against RFC 20.

DecimalBinary (8-bit)7-bitCharacter / name
Control characters (0–31)
0000000000000000NUL (null)
1000000010000001SOH
2000000100000010STX
3000000110000011ETX
4000001000000100EOT
5000001010000101ENQ
6000001100000110ACK
7000001110000111BEL (bell)
8000010000001000BS (backspace)
9000010010001001TAB (horizontal tab)
10000010100001010LF (line feed / new line)
11000010110001011VT
12000011000001100FF
13000011010001101CR (carriage return)
14000011100001110SO
15000011110001111SI
16000100000010000DLE
17000100010010001DC1
18000100100010010DC2
19000100110010011DC3
20000101000010100DC4
21000101010010101NAK
22000101100010110SYN
23000101110010111ETB
24000110000011000CAN
25000110010011001EM
26000110100011010SUB
27000110110011011ESC (escape)
28000111000011100FS
29000111010011101GS
30000111100011110RS
31000111110011111US
Space, punctuation and digits (32–64)
32001000000100000(space)
33001000010100001!
34001000100100010"
35001000110100011#
36001001000100100$
37001001010100101%
38001001100100110&
39001001110100111'
40001010000101000(
41001010010101001)
42001010100101010*
43001010110101011+
44001011000101100,
45001011010101101-
46001011100101110.
47001011110101111/
480011000001100000
490011000101100011
500011001001100102
510011001101100113
520011010001101004
530011010101101015
540011011001101106
550011011101101117
560011100001110008
570011100101110019
58001110100111010:
59001110110111011;
60001111000111100<
61001111010111101=
62001111100111110>
63001111110111111?
64010000001000000@
Uppercase letters and symbols (65–96)
65010000011000001A
66010000101000010B
67010000111000011C
68010001001000100D
69010001011000101E
70010001101000110F
71010001111000111G
72010010001001000H
73010010011001001I
74010010101001010J
75010010111001011K
76010011001001100L
77010011011001101M
78010011101001110N
79010011111001111O
80010100001010000P
81010100011010001Q
82010100101010010R
83010100111010011S
84010101001010100T
85010101011010101U
86010101101010110V
87010101111010111W
88010110001011000X
89010110011011001Y
90010110101011010Z
91010110111011011[
92010111001011100\
93010111011011101]
94010111101011110^
95010111111011111_
96011000001100000`
Lowercase letters and symbols (97–126)
97011000011100001a
98011000101100010b
99011000111100011c
100011001001100100d
101011001011100101e
102011001101100110f
103011001111100111g
104011010001101000h
105011010011101001i
106011010101101010j
107011010111101011k
108011011001101100l
109011011011101101m
110011011101101110n
111011011111101111o
112011100001110000p
113011100011110001q
114011100101110010r
115011100111110011s
116011101001110100t
117011101011110101u
118011101101110110v
119011101111110111w
120011110001111000x
121011110011111001y
122011110101111010z
123011110111111011{
124011111001111100|
125011111011111101}
126011111101111110~
Delete (127)
127011111111111111DEL (delete)

No ASCII code matches that. ASCII only covers 0–127.

Control characters: the invisible quarter of ASCII

Look at the first 32 rows and the last one. None of them is a character you can see. These 33 codes were commands for teleprinters and terminals: ring the bell, move the paper up a line, send the carriage back to the left. Some still do real work in every text file you open. The ones you’ll actually meet:

DecimalBinaryNameWhat it does
000000000NULNothing. Often marks the end of a piece of text
900001001TABTab
1000001010LFNew line on Linux and macOS
1300001101CRCarriage return. Windows ends lines with CR then LF
2700011011ESCEscape
12701111111DELDelete

DEL is the odd one out, sitting alone at the very end. That’s because 1111111 means all seven holes punched on paper tape, and punching every hole was how you crossed out a mistake.

If your decoded text has gaps, or line breaks you didn’t type, a control code is usually why. 0010110 is a common one people paste in: it’s 22, called SYN, a control code rather than a letter.

Only need letters? The binary alphabet chart has A–Z on its own.

What about codes above 127?

ASCII stops at 127. That surprises people, because a byte can hold up to 255.

Codes 128 to 255 are often called “extended ASCII”, but there’s no single extended ASCII. Windows-1252 and Latin-1 are two different tables that both fill that range, and older systems used others. UTF-8, which almost every web page uses now, treats those bytes differently again: a byte above 127 is only ever one part of a longer character (RFC 3629).

Take 10101010, which is 170. In Windows-1252 and Latin-1 it’s ª, a small raised a. In UTF-8, on its own, it isn’t a character at all. That’s why this converter flags it instead of guessing. If your binary has accents or emoji in it, paste it into the binary code translator linked at the top of the page, which reads UTF-8.

ASCII to binary

ASCII to binary is the same lookup run backwards: find the character’s code in the table above, then write that number in 8 bits. Capital A is 65, so it becomes 01000001. To convert a whole message at once, type it into the text to binary converter.

Frequently asked questions

What does ASCII stand for?

American Standard Code for Information Interchange. It was first published in 1963 and defines 128 codes, numbered 0 to 127. RFC 20 adopted it for network interchange in 1969, and the first 128 characters of Unicode are still the same.

Is ASCII 7-bit or 8-bit?

7-bit. Computers store each code in an 8-bit byte with a 0 in front, so 1000001 and 01000001 are both A. This converter accepts either.

How do I convert ASCII to binary?

Find the character in the table above and read across to its binary code. For a whole sentence, a text to binary tool is quicker than looking up each letter.

How many ASCII characters are there?

128. Of those, 95 are printable (the space, punctuation, digits and letters) and 33 are control characters.

Why are some characters blank or strange when I decode?

Either they’re control characters (codes 0–31 and 127), which have no visible shape, or they’re bytes above 127, which aren’t ASCII at all. The converter names the first kind and flags the second.

What is an ASCII decoder?

A tool that turns ASCII codes back into characters, from binary or from decimal. This page is one: paste 01001000 and you get H.

What code converts binary to ASCII?

Two one-liners that give the same result as this converter for 8-bit ASCII:

''.join(chr(int(b, 2)) for b in s.split())
s.trim().split(/\s+/).map(b => String.fromCharCode(parseInt(b, 2))).join('')
Is ASCII text the same as ASCII art?

No. ASCII text is plain text that only uses the 128 ASCII characters. ASCII art is a picture drawn with those characters. This page converts codes into characters, not pictures.

Every code in the table was generated and checked against RFC 20.

Sources: RFC 20, ASCII format for network interchange · RFC 3629, UTF-8