Technology

Binary & ASCII Translator

Free binary translator. Convert text to binary, hex, decimal or octal and decode it back, with real UTF-8 bytes and the full ASCII table.

Start from an example

Number base

Character encoding

Text

Anything you can type or paste — letters, accents, emoji, tabs and newlines all count.

Separator between codes

Binary

The full ASCII table

All 128 positions of the 7-bit set defined by ECMA-6: 95 printable characters (32 to 126) and 33 control codes (0 to 31, plus 127). Scroll the table to find any code.

Decimal	Character	Hex	Binary	Octal
0	NUL — Null	00	00000000	000
1	SOH — Start of Heading	01	00000001	001
2	STX — Start of Text	02	00000010	002
3	ETX — End of Text	03	00000011	003
4	EOT — End of Transmission	04	00000100	004
5	ENQ — Enquiry	05	00000101	005
6	ACK — Acknowledge	06	00000110	006
7	BEL — Bell	07	00000111	007
8	BS — Backspace	08	00001000	010
9	HT — Horizontal Tab	09	00001001	011
10	LF — Line Feed	0A	00001010	012
11	VT — Vertical Tab	0B	00001011	013
12	FF — Form Feed	0C	00001100	014
13	CR — Carriage Return	0D	00001101	015
14	SO — Shift Out	0E	00001110	016
15	SI — Shift In	0F	00001111	017
16	DLE — Data Link Escape	10	00010000	020
17	DC1 — Device Control 1	11	00010001	021
18	DC2 — Device Control 2	12	00010010	022
19	DC3 — Device Control 3	13	00010011	023
20	DC4 — Device Control 4	14	00010100	024
21	NAK — Negative Acknowledge	15	00010101	025
22	SYN — Synchronous Idle	16	00010110	026
23	ETB — End of Transmission Block	17	00010111	027
24	CAN — Cancel	18	00011000	030
25	EM — End of Medium	19	00011001	031
26	SUB — Substitute	1A	00011010	032
27	ESC — Escape	1B	00011011	033
28	FS — File Separator	1C	00011100	034
29	GS — Group Separator	1D	00011101	035
30	RS — Record Separator	1E	00011110	036
31	US — Unit Separator	1F	00011111	037
32	space	20	00100000	040
33	!	21	00100001	041
34	"	22	00100010	042
35	#	23	00100011	043
36	$	24	00100100	044
37	%	25	00100101	045
38	&	26	00100110	046
39	'	27	00100111	047
40	(	28	00101000	050
41	)	29	00101001	051
42	*	2A	00101010	052
43	+	2B	00101011	053
44	,	2C	00101100	054
45	-	2D	00101101	055
46	.	2E	00101110	056
47	/	2F	00101111	057
48	0	30	00110000	060
49	1	31	00110001	061
50	2	32	00110010	062
51	3	33	00110011	063
52	4	34	00110100	064
53	5	35	00110101	065
54	6	36	00110110	066
55	7	37	00110111	067
56	8	38	00111000	070
57	9	39	00111001	071
58	:	3A	00111010	072
59	;	3B	00111011	073
60	<	3C	00111100	074
61	=	3D	00111101	075
62	>	3E	00111110	076
63	?	3F	00111111	077
64	@	40	01000000	100
65	A	41	01000001	101
66	B	42	01000010	102
67	C	43	01000011	103
68	D	44	01000100	104
69	E	45	01000101	105
70	F	46	01000110	106
71	G	47	01000111	107
72	H	48	01001000	110
73	I	49	01001001	111
74	J	4A	01001010	112
75	K	4B	01001011	113
76	L	4C	01001100	114
77	M	4D	01001101	115
78	N	4E	01001110	116
79	O	4F	01001111	117
80	P	50	01010000	120
81	Q	51	01010001	121
82	R	52	01010010	122
83	S	53	01010011	123
84	T	54	01010100	124
85	U	55	01010101	125
86	V	56	01010110	126
87	W	57	01010111	127
88	X	58	01011000	130
89	Y	59	01011001	131
90	Z	5A	01011010	132
91	[	5B	01011011	133
92	\	5C	01011100	134
93	]	5D	01011101	135
94	^	5E	01011110	136
95	_	5F	01011111	137
96	`	60	01100000	140
97	a	61	01100001	141
98	b	62	01100010	142
99	c	63	01100011	143
100	d	64	01100100	144
101	e	65	01100101	145
102	f	66	01100110	146
103	g	67	01100111	147
104	h	68	01101000	150
105	i	69	01101001	151
106	j	6A	01101010	152
107	k	6B	01101011	153
108	l	6C	01101100	154
109	m	6D	01101101	155
110	n	6E	01101110	156
111	o	6F	01101111	157
112	p	70	01110000	160
113	q	71	01110001	161
114	r	72	01110010	162
115	s	73	01110011	163
116	t	74	01110100	164
117	u	75	01110101	165
118	v	76	01110110	166
119	w	77	01110111	167
120	x	78	01111000	170
121	y	79	01111001	171
122	z	7A	01111010	172
123	{	7B	01111011	173
124	\|	7C	01111100	174
125	}	7D	01111101	175
126	~	7E	01111110	176
127	DEL — Delete	7F	01111111	177

How UTF-8 spends its bytes

UTF-8 is variable width. The first 128 code points are one byte and identical to ASCII; everything else costs two, three or four.

Byte counts and bit patterns are from RFC 3629 §3.

Code points	Bit pattern	Bytes
U+0000–U+007FBasic Latin, identical to ASCII	0xxxxxxx	1
U+0080–U+07FFAccented Latin, Greek, Cyrillic, Arabic, Hebrew	110xxxxx 10xxxxxx	2
U+0800–U+FFFFMost CJK, Indic scripts, currency symbols	1110xxxx 10xxxxxx 10xxxxxx	3
U+10000–U+10FFFFEmoji, rare CJK, historic scripts	11110xxx 10xxxxxx 10xxxxxx 10xxxxxx	4

Did this calculator solve your problem today?

Contributor

Reviewed by

Last updated: September 16, 2026

Support

Related Calculators

You might also find these calculators useful

Binary Calculator

Binary arithmetic and base conversion, exact past 64 bits

Hex Calculator

Convert, add and mask hex, binary, octal and decimal

SHA-256 & MD5 Hash Generator

Generate and verify SHA-256, MD5, SHA-1, SHA-512 and SHA-3 digests

Morse Code Translator

Convert text to Morse code and Morse code to text

Translate text to binary, and binary back to text

Type a sentence and read it as binary, hexadecimal, decimal or octal; paste a run of ones and zeros and read it back as words. Every conversion goes through real UTF-8 bytes, so accented letters, Chinese characters and emoji come out the way an actual computer stores them — not as a number that only looks right.

What ASCII is, and where UTF-8 takes over

ASCII is a 7-bit code: 128 positions, numbered 0 to 127, standardised as ECMA-6 and ISO/IEC 646. Positions 33 to 126 are the printable characters — digits, the Latin alphabet in both cases, and punctuation. Position 32 is the space, and the remaining 33 are control codes that once drove teleprinters and still mark the end of a line today. ASCII has no position for é, for 東, or for an emoji, so the web uses UTF-8 instead: a variable-width encoding that keeps the first 128 code points byte-for-byte identical to ASCII and spends two, three or four bytes on everything above. That backward compatibility is why plain English text is the same bytes in both, and why a tool that quietly treats a code point as a byte gets the right answer for English and the wrong one for everything else.

What a conversion actually does

How to use the binary translator

Common use cases

Decoding a binary puzzle

Paste eight-bit groups from a CTF challenge, a game or a message board and read the plain text out.

Diagnosing mojibake

Compare what the bytes should be against what a system produced; a é that arrives as C3 83 C2 A9 was encoded twice.

Validating an ASCII-only field

Run the string through the 7-bit mode before it hits a system that will reject or mangle anything above 127.

Reading strings out of a packet capture

Paste the hexadecimal from Wireshark or a hex editor and see which parts are readable text.

Teaching character encoding

Show a class the same letter as a character, a code point, a decimal value and eight bits, in one screen.

Writing escape sequences

Octal and hexadecimal byte values are exactly what a C, shell or regex escape needs.

Why translate text to binary?

Reading a binary message

Puzzles, CTF flags, T-shirts and birthday cards all hide text in eight-bit groups. Paste the groups and the sentence comes back.

Debugging an encoding bug

When a name arrives as Ã© instead of é, the byte view tells you whether it was encoded twice, decoded as Latin-1, or never was UTF-8 at all.

Checking a field is pure ASCII

Bank files, DNS labels, HTTP headers and legacy databases often accept only 0–127. The ASCII mode refuses the string and names the character that broke it.

Working from a hex dump

A hex editor, a packet capture or a memory view gives you bytes. Paste them and read the strings inside without guessing.

Learning how characters are stored

Seeing 'A' become U+0041, then 65, then 01000001 makes the abstraction concrete in a way a table alone does not.

Counting the real size of a string

Characters and bytes are not the same number once you leave English. The tile row shows both, plus how many characters cost more than one byte.

Frequently asked questions

Each character becomes a number, and that number is written in base 2. In UTF-8 an English letter is one byte, so it becomes eight bits: 'A' is 65, which is 01000001. Type your text above and the binary appears below, one eight-bit group per byte.

Split the ones and zeros into groups of eight, read each group as a number, and look the number up as a character. Press Swap, paste your binary, and the tool does it — and tells you if a group is not eight bits long instead of guessing.

ASCII assigns the capital letter A to position 65. In base 2, 65 is 1000001 — seven bits. A byte is eight bits, so a leading zero is added: 01000001. Every uppercase letter follows on from there, and the lowercase letters start 32 higher, at 97 for 'a'.

ASCII defines 128 characters in 7 bits. UTF-8 defines all 1,114,112 Unicode code points using one to four bytes, and deliberately encodes the first 128 exactly as ASCII does. Any pure-ASCII text is therefore identical in both. They differ the moment you use an accent, a non-Latin script, a curly quote or an emoji.

é is U+00E9, which is above the 127 that fits in one byte. UTF-8 lays code points from U+0080 to U+07FF into two bytes with the pattern 110xxxxx 10xxxxxx, giving C3 A9. A tool that prints a single byte E9 for é is using Latin-1, not UTF-8, and its output will not decode correctly anywhere that expects UTF-8.

Four. Emoji live above U+FFFF, and UTF-8 spends four bytes on that range. The waving-hand emoji is U+1F44B, which is F0 9F 91 8B. Some emoji you see are several code points joined together — a family emoji can be four people plus three joiners, well over twenty bytes for one picture.

The 33 positions with no printable shape: 0 to 31 plus 127. They include NUL (0), BEL (7) which once rang a bell, BS (8) backspace, HT (9) tab, LF (10) line feed, CR (13) carriage return, ESC (27) which starts terminal escape sequences, and DEL (127). Most are historical, but LF, CR, HT and ESC are in constant use.

ASCII is only 0 to 127. "Extended ASCII" is a loose name for any of the incompatible 8-bit sets that filled 128 to 255 differently — Latin-1, Windows-1252, code page 437 and dozens more. The same byte meant different characters in each, which is the exact problem Unicode was created to end. This tool does not guess between them.

Yes. Choose Hex as the base, press Swap so the tool is decoding, and paste your bytes — with or without 0x prefixes, separated by spaces, commas or line breaks. A token that is not valid hexadecimal is reported rather than silently skipped.

Almost always one of three things: the groups are not eight bits, a stray character got pasted in with the digits, or the bytes are not valid UTF-8 because they came from a Latin-1 tool. The error message names which of the three it is and points at the offending code.

32 in decimal, 20 in hexadecimal, 040 in octal, and 00100000 in binary. It is the first printable position and the only one with no visible shape, which is why it sits between the control codes and the punctuation.

In everyday use, yes — "binary code" usually means text written as ones and zeros, which is what this page produces. Strictly, binary is just base 2; it describes any number written with two digits, including the machine instructions in a program, which are binary but are not text.

Not if the width is fixed. Binary bytes are always eight digits and hex bytes are always two, so a continuous run splits cleanly. Decimal is the exception: 72105 could be many things, so choosing no separator pads every code to three digits and writes 072105, which does split cleanly.

No. The conversion runs in your browser. Nothing you type is uploaded, logged or stored, which matters if you are pasting real data out of a capture or a database to inspect it.