Standard ASCII contains exactly 128 code positions, numbered from decimal 0 through decimal 127, and a bulk ASCII chart lists every one of those positions in a single reference. Each row pairs a character (or its standard control abbreviation) with the same value written in four number systems at once: decimal, two-digit hexadecimal, three-digit octal, and seven-digit binary. That fixed structure is what makes the table useful for bulk lookup: you can scan an entire block of codes, isolate a category with a filter, or search for a specific row by name, abbreviation, decimal, or prefixed hex, octal, or binary value, then copy the complete row to your clipboard. Because standard ASCII is strictly 7-bit, decimal 128 through 255 are not part of the chart at all; those byte values belong to separate encodings such as ISO-8859-1, Windows-1252, or CP437, and including them under the label ASCII would hide an important ambiguity. The chart is built and filtered in your browser, so search terms and copied rows never leave your machine. For code comments, network traces, data-cleaning rules, and protocol notes, this kind of one-stop bulk reference saves the work of converting between radixes by hand every time.
What the Bulk ASCII Chart Includes
Standard ASCII is a 7-bit coded character set defined in ECMA-6 and in IETF RFC 20, and the chart holds exactly 128 rows by design. Each row represents one integer from 0 through 127, and the row's number columns are all derived from that same integer rather than looked up independently. The visible character (when printable) sits in its own column alongside its descriptive name and a practical category. The standard's control positions, decimal 0 through 31, carry the RFC 20 abbreviations such as NUL, HT, LF, and CR, because those codes have no ordinary printable glyph. Decimal 32 is shown as SP for Space, and decimal 127 is shown as DEL for Delete. The graphic positions from decimal 33 through 126 carry punctuation, the digits 0 through 9, the uppercase Latin letters A through Z, and the lowercase Latin letters a through z. Naming for those graphics follows the Unicode Basic Latin code chart, while the code positions match RFC 20 exactly.
How to Scan All 128 Codes and Copy Them in Bulk
- Open the ASCII Table and browse all 128 rows in a single scrolling view, or type into the search box to narrow the set immediately.
- Enter a name (line feed), a control abbreviation (LF, CR, NUL, HT), a plain decimal value (65), a prefixed radix value (0x41, 0o101, or 0b1000001), or a literal form such as char:0 or char:space to focus on one entry fast.
- Pick a category from the filter when you want to isolate a block: Controls, Punctuation, Digits, Letters, Space, or Delete. Every matching row stays visible; the tool does not silently truncate a large result set.
- Review the decimal, hexadecimal, octal, and seven-digit binary columns for each remaining row, then select Copy on the row you need to write a complete text record to your clipboard.
- If the browser denies clipboard access, the page reports the failure instead of claiming success; changing the search or category clears the earlier copy message and you can try again.
Searching and Filtering for Targeted Bulk Lookups
The search box is built around a small set of exact, predictable rules, which matters when you are running bulk lookups and want each query to behave the same way. Plain digits are treated as decimal, so typing 65 lands on capital A. To find the same code in another radix, prefix the value: 0x for hexadecimal, 0o for octal, and 0b for binary. Because of those prefixes, you can paste a code from a network trace, a packet capture, or a code review and find its row regardless of which radix the source used. The form char:value lets you anchor on the literal character itself, including whitespace forms like char:space or a literal control byte such as char:0, which is useful when you are reading bytes from a file and want to confirm what character they should map to under standard ASCII. Empty results show a clear no-match state instead of leaving stale output on screen.
The category filter then divides the chart into recognizable blocks. Controls covers decimal 0 through 31 with their standard RFC 20 abbreviations. Punctuation covers the graphic marks and operators. Digits isolates 0 through 9. Letters groups the uppercase A through Z and lowercase a through z. Space holds decimal 32 only, because RFC 20 treats Space as a normally non-printing graphic rather than as a control code. Delete holds decimal 127 only, because RFC 20 notes that DEL is not a control character in the strict sense, and the chart respects that distinction so the categories stay honest.
Reading the Four Number Systems Side by Side
Every row shows the same integer written in four notations: decimal (unprefixed, the source value), two-digit uppercase hexadecimal, three-digit octal, and seven-digit binary. The fixed-width prefixes in the display make the radix explicit, which matters because documentation, source code, network traces, and command-line tools each have their own conventional notation. A bulk reference lets you read across the row instead of converting in your head.
For example, capital A is decimal 65. Written in two-digit hexadecimal with the 0x prefix, that row reads 0x41. The octal column carries 0o101, because 64 + 1 = 65 in base 8. The binary column carries 0b1000001, the seven-digit binary form of the same integer. Lowercase a is decimal 97 and hexadecimal 0x61, so the offset between the uppercase and lowercase of the same Latin letter is 32, a constant worth remembering when you write character arithmetic.
The table below shows how a few representative rows line up across all four number systems. Each row is an officially defined code position from RFC 20 and the Unicode Basic Latin chart, not a value computed by hand.
| Decimal | Hex | Octal | Binary | Char / Abbr. | Name | Category |
|---|---|---|---|---|---|---|
| 0 | 0x00 | 0o000 | 0b0000000 | NUL | Null | Controls |
| 9 | 0x09 | 0o011 | 0b0001001 | HT | Horizontal Tabulation | Controls |
| 10 | 0x0A | 0o012 | 0b0001010 | LF | Line Feed | Controls |
| 13 | 0x0D | 0o015 | 0b0001101 | CR | Carriage Return | Controls |
| 32 | 0x20 | 0o040 | 0b0100000 | SP | Space | Space |
| 48 | 0x30 | 0o060 | 0b0110000 | 0 | Digit Zero | Digits |
| 65 | 0x41 | 0o101 | 0b1000001 | A | Capital A | Letters |
| 97 | 0x61 | 0o141 | 0b1100001 | a | Lowercase a | Letters |
| 126 | 0x7E | 0o176 | 0b1111110 | ~ | Tilde | Punctuation |
| 127 | 0x7F | 0o177 | 0b1111111 | DEL | Delete | Delete |
Why a Bulk Reference Stops at Decimal 127
The 7-bit boundary in the standard is deliberate, not an arbitrary cutoff. RFC 20 and ECMA-6 define exactly 128 code points, and values from 128 through 255 are not part of standard ASCII. In practice, those higher byte values are interpreted by many different encodings, including ISO-8859-1, Windows-1252, and IBM CP437, each of which assigns a different character to the same byte. Mixing them under the label extended ASCII hides that ambiguity, which is exactly why a careful chart stops at 127. The ASCII Table follows that boundary exactly: only integer positions 0 through 127 are generated, and every radix representation is derived from that integer. When you need to decode a byte above 127, the right first step is to identify the encoding that produced it; the number alone is not enough. ASCII is also a subset of Unicode: Unicode keeps the ASCII range at the same code points (the Basic Latin block) and extends well beyond it, which is useful when you later need characters outside the original 7-bit set.
Practical Bulk Reference Workflows
A bulk ASCII chart earns its place when several lookups would otherwise interrupt your flow. Common workflows include writing code comments and docstrings that quote a code point in all four notations, reviewing network traces where one side shows octal and the other shows decimal, and building data-cleaning rules that strip or replace a known set of punctuation or whitespace characters. The same chart also fits teaching materials that need to show the same row in decimal, hex, octal, and binary without rebuilding the conversion each time, and protocol notes that compare what different encoders actually emit for a fixed byte by reading the same value back in each notation.
Because the table runs entirely in your browser and search terms or copied rows are not sent to a remote service, you can use it for internal documentation, protocol notes, and bug reports without worrying about leakage. The Copy button writes one complete row in a readable text format, including the display value, name, and all four number systems, which lines up well with how those notes are usually written. For a broader walk through applying these values inside source code and data pipelines, the practical guide to ASCII code for programming and data tasks shows how the same row conventions carry into everyday developer work.