Dev tool

ASCII Table

This ASCII table lists every code from 0 to 127 with its decimal, hex, octal, and binary value beside the character. Type text into the converter to see its codes, or search the table to jump to any character or number. Control codes are named, printable characters are shown, and you can copy any value. It's free and private, you won't need an account, and it's handy for coding, debugging, classwork, and puzzles. You'll see the codes the moment you type.

Full 0 to 127
Dec, hex, binary
Search any code
Text to ASCII
Control names

Last updated June 17, 2026 Standard 7-bit ASCII Reviewed by the Calcowa team

ASCII codes

72 105

decimal, from Hi

Text to ASCII Search the table

The converter reads standard characters; search by character, decimal, hex, or a control name like tab or line feed.

The full ASCII table

Codes 0 to 127. Control codes are named; printable characters are shown.

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

The basics

How does ASCII encode text?

ASCII gives every basic character a number from 0 to 127, which fits in 7 bits, so a computer can store a letter as a small whole number. The printable characters run from 32, the space, up to 126, the tilde, and they include the digits, uppercase and lowercase letters, and common punctuation in a tidy order. The first 32 codes plus 127 are control codes that signal actions rather than print a glyph, like a tab or a new line. Because the order is fixed, A through Z sit at 65 to 90 and a through z at 97 to 122, so shifting case is just adding or subtracting 32. You don't have to memorize any of it, since the table's right here and the converter does the lookup. This table shows each code in decimal, hex, octal, and binary, because the same value turns up in all four forms across code and data, and it's handy to have them lined up. That's the part that trips people up when they're reading a hex dump or a byte stream.

A = 65 = 0x41 = 01000001

Step by step

Looking up a code, step by step

Here's the quick routine, whether you have text or a number:

1
Convert textType a word and you'll see each letter's ASCII code.
2
Or searchType a character, a number, or a control name to filter.
3
Read the rowSee the decimal, hex, octal, and binary together.
4
Copy what you needGrab the codes from the converter for your project.

FAQ

Frequently asked questions

ASCII is a character-encoding standard that pairs each letter, digit, symbol, and control code with a number from 0 to 127. The table below lists every one, with its decimal, hex, octal, and binary value next to the character. Codes 0 to 31 and 127 are control codes like tab and line feed, while 32 to 126 are the printable characters you type. It's the shared map computers use to store and send text.

Type it into the converter at the top and you'll see its decimal code right away, or search the table for the character to read its row. A capital A is 65, a lowercase a is 97, the digit 0 is 48, and a space is 32. Once you know one letter, the rest of its run follows in order, so B is 66 and C is 67, and you won't need to look each one up. That's what makes the codes easy to reason about once you've got the first.

They're the same number written three ways. Decimal is base 10, the everyday count; hex is base 16, the compact form used in code and color values; and binary is base 8 bits, how the byte actually looks in memory. The table shows all three for each character, so 65 is 41 in hex and 01000001 in binary, and you can grab whichever your project needs.

Control characters are the first 32 codes plus 127, and they do not print a visible glyph. Instead they signal actions: tab (9) moves across, line feed (10) starts a new line, carriage return (13) returns to the margin, and null (0) marks an empty value. They date back to teletype machines, and a few, like tab and newline, are still everywhere in text files today.

ASCII is the original 128-code set, and Unicode is the much larger standard that grew from it to cover every writing system and emoji. The good news is that Unicode keeps the first 128 codes identical to ASCII, so A is still 65 in both. That's why an ASCII table is still useful: it covers the core English letters, digits, and symbols that sit at the base of modern text, and you'll meet them in almost every file you'll ever open.

Yes, it's completely free, with no sign-up, and it runs right in your browser, so nothing you type leaves your device. Search the table, copy any value, or use the converter to turn text into codes in a tap. Bookmark it for coding, debugging an encoding issue, a computer-science class, or a puzzle, and you'll have the full reference and a quick converter ready whenever you need them.

Keep going

Related tools

More dev and text tools.

All dev tools

Text, code, and number utilities.

Binary Translator

Text to binary and number bases.

Gematria Calculator

Letter values across ciphers.

Decoding some text?

Look it up above, or browse all the dev tools.

Dev Tools