The ASCII Table is a browser-based reference that lists all 128 standard 7-bit ASCII code points from decimal 0 through 127, each shown as a visible character or an RFC 20 control abbreviation alongside its decimal, two-digit hexadecimal, three-digit octal, and seven-digit binary value. The table is constructed and filtered in your browser, so search terms and copied rows are not sent to a remote service, and the 7-bit boundary is deliberate. Standard ASCII does not contain decimal values 128 through 255, because those bytes are interpreted differently by ISO-8859-1, Windows code pages, IBM PC code pages such as CP437, and other encodings. Calling all of them extended ASCII hides an important ambiguity. This table therefore stops at 127 and does not combine incompatible 8-bit mappings. The 7-bit boundary is what RFC 20 and ECMA-6 define as the standard scope, so the table lines up with the references it draws from. If you routinely deal with values above 127, you can still use the table to confirm the ASCII range and then turn to an encoding-specific resource for the higher bytes.
The 128 codes and the 7-bit boundary
The table is built from exactly 128 entries. Decimal is the source integer for every row, and the other three number systems are derived from it: uppercase hexadecimal is padded to two digits, octal to three digits, and binary to seven digits. RFC 20 supplies the standard code table, the control abbreviations, the control terminology, SP for Space, and DEL for Delete. The Unicode Basic Latin code chart independently supplies and cross-checks the graphic character names and code positions, while ECMA-6 confirms the 7-bit, 128-character scope. Because all three sources agree on the same 0 to 127 range, the table does not have to pick a winner between competing extensions.
The design treats the 7-bit boundary as a feature. If you need to decode a byte above 127, the first step is to identify the actual character encoding that produced it. Choosing an encoding is part of decoding; the number alone is not enough. Common encodings such as UTF-8, ISO-8859-1, and Windows-1252 each map those higher bytes to different characters, and guessing usually produces mojibake. For exact 7-bit lookup and conversion the table is the right tool; for byte interpretation above 127 you need an encoding-aware decoder.
Graphic entries from decimal 33 through 126 include punctuation, the digits 0 through 9, uppercase Latin letters, and lowercase Latin letters. Their names follow the Unicode Basic Latin code chart, while the code positions agree with the RFC 20 ASCII table. For example, capital A is decimal 65, hexadecimal 0x41, octal 0o101, and binary 0b1000001. Lowercase a is decimal 97 and hexadecimal 0x61. The fixed-width prefixes in the display make the radix explicit, which is useful when documentation, source code, network traces, and command-line tools use different notations.
How to search the ASCII Table for any code
The search box accepts several kinds of input, so you can look up a code from whatever angle you already have. A visible character, a control abbreviation, a name, a category, or an exact code all work. The tool interprets unprefixed digits as decimal, so typing 65 finds capital A. To search a different radix, use the explicit prefixes: 0x for hexadecimal, 0o for octal, 0b for binary. The same capital A row is reached by 0x41, 0o101, and 0b1000001, which lets you confirm a value regardless of how it was written down. The literal character form, written as char:value, is useful when you want to find a specific printable character or whitespace by what it actually looks like; char:space targets the SP row directly, and char:0 targets the digit zero row.
- Open the ASCII Table and either scan all 128 rows from top to bottom or type a query in the search box. Use a name like line feed, a control abbreviation like LF, a decimal like 65, a prefixed radix like 0x41, or a literal like char:space.
- Choose a category from the filter when you want to narrow the visible rows to a single group such as controls, punctuation, digits, uppercase letters, lowercase letters, Space, or Delete. The filter does not silently truncate large result sets; every match remains on screen.
- Review each row in context. The visible character (or its RFC 20 abbreviation), the descriptive name, the category, and the four number systems are all in one place, so you can read off the code in whichever notation matches the surrounding document.
- Select Copy on the row you need. The button writes one complete row to the clipboard in a readable text format that includes the display value, the name, and all four number systems. If the browser denies clipboard permission, the page reports the failure instead of claiming success, and changing the search or category clears the earlier copy message.
An empty result shows a clear no-match state rather than leaving stale output on screen, which keeps the workflow honest when you mistype a prefix or a value. The search is exact rather than approximate, so a query of 65 will not accidentally surface a row that merely contains the characters 6 and 5.
Filter the table by category
The category filter is independent of the search box, so you can combine them. Set the category to digits and the table shows only the ten rows for 0 through 9. Set it to uppercase letters and the 26 capital letters appear. Set it to lowercase letters and the 26 lowercase letters appear. Set it to controls and you get the 32 non-printing positions from decimal 0 through 31, each with its RFC 20 abbreviation. Space (decimal 32) is shown explicitly as SP and lives in its own Space category, because it is a normally non-printing graphic character rather than a control code in the strict sense. Delete (decimal 127) is shown as DEL and placed in its own Delete category, because RFC 20 notes that DEL is not a control character in the strict sense. Punctuation isolates the graphic punctuation and symbol rows from decimal 33 through 47, 58 through 64, 91 through 96, and 123 through 126.
Splitting Space and Delete from the rest keeps the visible categories accurate. Treating every non-printing position as identical would hide the differences that matter in text protocols, terminal handling, and file format specs, and it would also misrepresent what RFC 20 says about DEL in particular.
Read the four number systems correctly
The table always presents decimal first, then two-digit hex with the 0x prefix, three-digit octal with the 0o prefix, and seven-digit binary with the 0b prefix. Padding matters: hex is zero-padded to two digits so 0 through 15 appear as 0x00 through 0x0F, octal is zero-padded to three digits so the smallest value is 0o000 and the largest is 0o177, and binary is zero-padded to seven digits so every row lines up at the same width. The padding is not cosmetic; it makes the radix unambiguous and keeps the columns aligned when you scan many rows at once.
| Decimal | Hex | Octal | Binary | Display |
|---|---|---|---|---|
| 65 | 0x41 | 0o101 | 0b1000001 | A |
| 97 | 0x61 | 0o141 | 0b1100001 | a |
| 48 | 0x30 | 0o060 | 0b0110000 | 0 |
| 32 | 0x20 | 0o040 | 0b0100000 | SP |
| 13 | 0x0D | 0o015 | 0b0001101 | CR |
| 127 | 0x7F | 0o177 | 0b1111111 | DEL |
Each row's conversions come straight from the ASCII Table tool, which derives every radix from the same integer. The 32-step gap between uppercase A (decimal 65) and lowercase a (decimal 97) reflects the layout RFC 20 defines, and the table makes that gap visible in every radix at once.
Identify control characters, Space, and Delete
Decimal 0 through 31 are control codes with no ordinary printable glyph. The table shows their RFC 20 abbreviations so the cells are not empty or misleading. NUL is decimal 0, the null character. HT is decimal 9, Horizontal Tabulation. LF is decimal 10, Line Feed. CR is decimal 13, Carriage Return. Other rows in that range include BEL (7, the bell), BS (8, Backspace), FF (12, Form Feed), ESC (27, Escape), and the rest of the C0 control set. These abbreviations are stable across operating systems and protocols, which is why the table leans on RFC 20 instead of inventing its own names.
Decimal 32 is SP, Space, the space character between words. Decimal 127 is DEL, Delete. RFC 20 describes DEL as not a control character in the strict sense, so the tool gives Delete its own category rather than tucking it into the controls group. The same logic gives Space its own group. CR, LF, and CRLF conventions still differ by protocol and platform, which is a reminder that ASCII assigns code points but does not on its own explain how every application interprets a control operation, how a text file chooses line endings, or how a modern Unicode string is encoded into bytes. Use the table for exact 7-bit lookup, then consult the relevant file format or protocol when behavior depends on context.
Unicode includes the ASCII range at the same Basic Latin code points, so a Unicode-aware tool agrees with this table for decimal 0 through 127. Unicode also extends far beyond that range, which is the next step up when the bytes you are looking at are not standard 7-bit ASCII.
Copy a complete row for your notes or code
The Copy button is the bridge between the table and the rest of your work. Each click writes one row in a readable text format that includes the display value, the descriptive name, and all four number systems. The format is meant to drop into a code comment, a bug report, a protocol note, a teaching slide, or a data-cleaning rule without further editing. For a code review comment that mentions a stray byte, copying the row lets you cite decimal, hex, octal, and binary in one line so a colleague reading any of those notations can match it to the same character.
Clipboard access depends on browser permission. If the page reports a copy failure, the browser is refusing the write, and nothing has been added to your clipboard. Changing the search or category clears the earlier copy message, which keeps the visible state consistent with what you actually have on the clipboard. The table does not claim that a copy succeeded when the browser blocked it, and the empty-result state for an unmatched search is shown as a clear no-match message rather than a stale row from a previous query.
Open the ASCII Table when you need a fixed, standards-backed 7-bit reference. For related reading on how those codes show up in specific programming tasks, the rest of this site's developer guides cover the same tool from language-specific angles; for byte values above 127, switch to an encoding-aware decoder rather than reaching for an 8-bit extension.