ASCII Table — full 0–127 reference with converter

The ASCII table is the original character-encoding standard that maps the numbers 0 through 127 to the letters, digits, punctuation marks, and invisible control codes that every computer still understands today. This page gives you the complete table — decimal, hexadecimal, octal, and binary side by side with each character and its plain-English description — plus a converter that turns any character into its codes, or any code back into its character, instantly.

We built this ASCII table as a free reference tool because Arb Digital's own engineers reach for one constantly when debugging encoding issues, writing regular expressions, or explaining a weird character showing up in a client's form submissions. It runs entirely in your browser, with no signup and no data ever leaving your machine.

What This ASCII Table Does

Enter a single character in the converter box and it returns the decimal, hexadecimal, octal, and binary representation of that character instantly. Enter a number instead — decimal like 65, hex like 0x41, or an octal-looking value — and it returns the matching character along with its name. Below the converter sits the full 128-row reference table covering every ASCII code from 0 (NUL) to 127 (DEL), and you can filter that table live by typing any part of a character, code, or description into the search box. There is no page reload, no external API call, and no lag — everything is computed with a small embedded lookup table baked directly into the page's JavaScript.

This matters because ASCII, despite being over 60 years old, is still the foundation almost every modern encoding builds on. UTF-8 — the encoding behind virtually every website, JSON payload, and email on the internet — is fully backward-compatible with ASCII for the first 128 code points. That means every character in this ASCII table means exactly the same thing in UTF-8, which is one reason ASCII knowledge never really goes out of date for developers.

How to Use the ASCII Table

1. Convert a character. Type a single letter, digit, or symbol into the input box and click Convert. The result panel shows its decimal, hex, octal, and binary values.
2. Convert a code. Type a decimal number (like 97), a hex value with a 0x prefix (like 0x61), or paste a code you found elsewhere, and click Convert to see the matching character and its name.
3. Browse the full table. Scroll the reference table below the converter to see all 128 ASCII codes at once, each with its decimal, hex, octal, binary, character, and description.
4. Search or filter. Type into the search box above the table to instantly narrow it down — search "tab" to find the tab character, search "0x" plus a hex digit, or search a decimal number.
5. Handle control codes. For codes 0–31 and 127, which have no visible glyph, the table and converter show the standard three-letter abbreviation (like LF for line feed or ESC for escape) instead of a blank square.

How ASCII Encoding Actually Works

ASCII (American Standard Code for Information Interchange) assigns every character a 7-bit number between 0 and 127. That 7-bit range is exactly why the table stops at 127 rather than going up to 255 — the eighth bit was historically reserved for parity checking or later repurposed by extended, non-standard 8-bit encodings. The specification was first published in 1963 and standardized by ANSI, and it's documented today by organizations including the MDN Web Docs glossary, which explains its ongoing relationship to Unicode and UTF-8.

The 128 codes split into two clean halves. Codes 0 through 31, plus code 127, are non-printable control codes — things like CR (carriage return), LF (line feed), TAB, BEL (the terminal bell), and ESC (escape, used to start ANSI terminal color codes). These exist because ASCII was designed in an era of teletypewriters and needed a way to instruct hardware to do things — ring a bell, advance a line, feed a new page — not just display a symbol. Codes 32 through 126 are the printable characters: space, digits 0–9, uppercase and lowercase letters, and every common punctuation mark on a US keyboard.

Converting between number systems is straightforward binary math. Decimal 65 is the letter A. In hexadecimal that's 0x41, because 65 = 4×16 + 1. In octal it's 101, because 65 = 1×64 + 0×8 + 1. In binary it's 01000001, an 8-bit representation with a leading zero since ASCII only needs 7 bits. Every column in this table represents the exact same underlying value — just written in a different base, which is why programmers reach for hex and octal so often: they map more cleanly onto binary byte boundaries than decimal does.

Why Control Codes Still Matter Today

It's tempting to think control codes are historical trivia, but several of them run your development environment right now. Line feed (code 10) is the newline character on Linux and macOS; carriage return (code 13) combined with line feed is the Windows newline pair, which is exactly why files sometimes show stray ^M characters when moved between operating systems — that's carriage return rendering visibly because the receiving tool doesn't expect it. Escape (code 27) kicks off every ANSI terminal color and cursor-movement sequence, which is how your terminal renders colored text, progress bars, and cursor repositioning. Tab (code 9) is the actual tab character your editor may be silently converting to spaces. Null (code 0) terminates C-style strings and shows up constantly in binary file formats and low-level protocol parsing. Understanding these codes explains a lot of "invisible bug" behavior — a file that looks identical in two editors but fails a byte-for-byte diff almost always differs in its control characters, line-ending style, or trailing whitespace.

ASCII, Unicode, and UTF-8 — How They Relate

A common point of confusion is whether ASCII is obsolete now that Unicode exists. It isn't, because Unicode was deliberately designed to keep ASCII as its first 128 code points. UTF-8, the dominant Unicode encoding on the web, encodes those first 128 characters as a single byte with the exact same bit pattern as classic ASCII. That means any valid ASCII text file is automatically also a valid UTF-8 file — no conversion required. Where things diverge is beyond code point 127: UTF-8 uses multi-byte sequences to represent everything else, from accented Latin letters to emoji to CJK scripts, while classic 8-bit "extended ASCII" encodings like Latin-1 (ISO-8859-1) and Windows-1252 diverge from UTF-8 immediately after byte 127, which is the real root cause of the classic "mojibake" garbled-text bug when a file's declared encoding doesn't match how it's actually being read.

Practical Developer Uses for This Table

• Regular expressions. Character classes and escape sequences like \x41 or A reference exact ASCII/Unicode code points — this table lets you look up the hex value for any character you need to match.
• Debugging file encoding issues. When a text diff shows unexpected characters, comparing byte values against this table quickly reveals whether you're looking at a line-ending mismatch, a stray control character, or a genuine encoding mismatch.
• Keyboard shortcuts and terminal escape sequences. Many terminal and hotkey definitions reference control codes by number (Ctrl+C sends code 3, ETX) rather than by name.
• Parsing binary or legacy protocol data. Older network protocols, serial communication formats, and file headers frequently use specific control bytes as delimiters or markers.
• Teaching and learning number systems. Converting the same value between decimal, hex, octal, and binary side by side is one of the clearest ways to internalize how positional number systems work.

Common Mistakes to Avoid

• Confusing extended ASCII with standard ASCII. Standard ASCII is strictly 0–127. Anything above 127 (like Windows-1252's curly quotes) is a separate, non-standard extension and not part of this table.
• Assuming control codes print as blank spaces. They don't display at all in most contexts — they trigger an action (like a newline) or are simply invisible, which is different from the visible space character at code 32.
• Mixing up decimal and hex when reading documentation. A value like 41 is a completely different character depending on whether it's decimal (the ')' character) or hex (the 'A' character) — always check which base a source is using.
• Forgetting the CRLF vs LF distinction. Copying a file between Windows and Unix-based systems without normalizing line endings frequently introduces subtle bugs, especially in shell scripts and shebang lines.
• Treating ASCII as sufficient for international text. ASCII has no accented letters, no non-Latin scripts, and no emoji — for anything beyond basic English text and code, you need full Unicode/UTF-8 support.

Related Free Tools From Arb Digital

Pair this ASCII table with our HTTP Status Code Lookup for another everyday developer reference, or our MIME Type Lookup when you're dealing with file types and content headers. If you're working with text encoding more broadly, try the Base64 Encoder/Decoder or the Case Converter. Curious about a browser's raw identity string? Check out the User-Agent Parser. You can find every free utility we've built in the free online tools hub.

Frequently Asked Questions

This ASCII table runs entirely in your browser — no data is sent to any server, and no signup is required.