ASCII Table - Complete 128-Character Reference

Full ASCII character table with decimal, hexadecimal, octal, and binary values. Search any character, filter by type, and convert between text and ASCII codes. Covers all 128 standard characters including control characters, printable characters, and their descriptions.

Standard ASCII Table (0-127)

Text to ASCII Converter

Control Characters (0-31)

The first 32 ASCII codes (0 through 31) plus code 127 (DEL) are designated as control characters. These non-printable characters were designed in the 1960s to control teletype machines, printers, and communication equipment. While most of their original purposes are obsolete, several remain basic to modern computing.

NUL (0) serves as the null terminator for strings in C and related languages. Every C string ends with a NUL byte, which is why C strings are sometimes called "null-terminated strings." This convention dates back to the earliest days of C language development at Bell Labs.

HT/TAB (9) is the horizontal tab character, universally used for indentation in code, aligning data in columns, and separating fields in tab-delimited files. The tab-vs-spaces debate in programming style guides revolves entirely around whether to use this character.

LF (10) is the line feed character, used as the line ending in Unix, Linux, and macOS systems. It moves the cursor to the next line.

CR (13) is the carriage return character. Windows uses the CR+LF combination (codes 13 and 10 together) for line endings. The names "carriage return" and "line feed" come directly from the mechanical operations of typewriters.

ESC (27) is the escape character, used to begin ANSI escape sequences that control terminal text color, cursor position, and other formatting in command-line environments.

Printable Characters (32-126)

ASCII codes 32 through 126 are the 95 printable characters: the space (32), digits 0-9 (48-57), uppercase letters A-Z (65-90), lowercase letters a-z (97-122), and 33 punctuation and symbol characters.

The arrangement is not arbitrary. Digits 0-9 occupy codes 48-57, so the numeric value of a digit character equals its ASCII code minus 48. Uppercase letters start at 65 and lowercase at 97, making the offset between cases exactly 32. This means toggling between upper and lower case requires only flipping bit 5 of the binary representation.

Extended ASCII (128-255)

Standard ASCII uses 7 bits, defining 128 characters. The 8th bit in a byte enables 128 additional characters (128-255), collectively called "extended ASCII." Unlike standard ASCII, there is no single extended ASCII standard. Multiple incompatible code pages exist.

The incompatibility between extended ASCII code pages was a major problem in the 1990s and is the primary reason Unicode was created. When a document encoded in Windows-1252 was opened on a system expecting ISO 8859-1, certain characters displayed incorrectly, a phenomenon colloquially known as "mojibake."

HTML Character Entities

HTML uses named and numeric entities to represent characters that have special meaning in markup or that cannot be typed directly. Every ASCII character can be represented as a numeric entity using the &#number; syntax.

The five characters that must be escaped in HTML content are the ampersand (&), less-than (<), greater-than (>), double quote ("), and single quote/apostrophe ('). Failing to escape these characters can break HTML rendering or create security vulnerabilities (cross-site scripting).

History of ASCII

ASCII emerged from the need to standardize character encoding across different computer manufacturers. Before ASCII, each manufacturer used its own encoding scheme, making data exchange between systems nearly impossible.

1960: The American Standards Association (ASA, later ANSI) formed a subcommittee X3.4 to develop a standard code for data interchange. The committee included representatives from IBM, AT&T, and other major computing companies.

1963: The first version of ASCII was published as ASA X3.4-1963 with 128 character codes. This initial version included some differences from modern ASCII, including a different position for the caret and underscore characters.

1967: A major revision (ANSI X3.4-1967) finalized the character assignments that persist to this day. Lowercase letters were added, and several character positions were reassigned.

1968: President Lyndon Johnson mandated ASCII for all computers purchased by the federal government, accelerating industry-wide adoption.

1986: The last revision (ANSI X3.4-1986) was published, making only minor editorial changes. This version remains the current official standard.

1991: The Unicode Consortium published Unicode 1.0, designed to eventually replace ASCII and all other character encodings with a universal standard. Unicode's first 128 code points were made identical to ASCII for backward compatibility.

ASCII and Unicode Relationship

Unicode was designed as a superset of ASCII. The first 128 Unicode code points (U+0000 through U+007F) map exactly to ASCII values 0 through 127. This means every valid ASCII file is automatically a valid UTF-8 file, which is the key reason UTF-8 achieved widespread adoption.

UTF-8, the dominant Unicode encoding on the web (used by over 98% of websites), uses variable-length encoding. ASCII characters (0-127) are encoded as a single byte identical to their ASCII value. Characters outside the ASCII range use 2 to 4 bytes. This design makes UTF-8 highly fast for English-language text while supporting every writing system in the world.

Binary Representation

ASCII uses 7 bits to represent each character, allowing values from 0000000 (0) to 1111111 (127). Each bit position has a specific weight: 64, 32, 16, 8, 4, 2, 1 from left to right. Understanding binary ASCII helps when debugging network protocols, file formats, and embedded systems.

The bit patterns in ASCII are deliberately organized. Control characters occupy codes 0-31, where the two highest bits are both 0 (00xxxxx). Uppercase letters have bit pattern 10xxxxx and lowercase letters have 11xxxxx, differing only in bit 5. This structure simplified hardware sorting circuits in early computers.

ASCII in Programming

Every major programming language provides functions for working with ASCII values.

Python: ord('A') returns 65. chr(65) returns 'A'. Python 3 strings are Unicode by default, but ASCII values work identically for the first 128 characters.

JavaScript: 'A'.charCodeAt(0) returns 65. String.fromCharCode(65) returns 'A'. JavaScript strings use UTF-16 internally but handle ASCII transparently.

C/C++: Characters are stored as integer values. (int)'A' gives 65. (char)65 gives 'A'. The <ctype.h> header provides functions like isalpha(), isdigit(), and toupper() that operate on ASCII values.

Java: (int)'A' returns 65. (char)65 returns 'A'. Java's char type is 16-bit Unicode, but ASCII values in the 0-127 range behave identically.

Common ASCII Values Quick Reference

Character Encoding Comparison

ASCII is one member of a family of character encoding standards that evolved over decades. Understanding the relationships helps when dealing with legacy data, internationalization, and file format compatibility.

EBCDIC (Extended Binary Coded Decimal Interchange Code) was IBM's alternative to ASCII, used on mainframes. Unlike ASCII, EBCDIC does not place letters in contiguous code ranges, which made string processing more complex. EBCDIC is still used on IBM Z-series mainframes today.

ISO 8859 series extended ASCII to 8 bits with 15 different "parts" covering various language groups. ISO 8859-1 (Latin-1) became the default character set for HTTP/1.1 and early HTML.

UTF-8 unified these competing encodings into a single standard. Its backward compatibility with ASCII, combined with the ability to represent every Unicode character, made it the clear winner. As of 2026, UTF-8 accounts for over 98% of web page encodings.

ASCII Art and Creative Uses

ASCII art is one of the most enduring creative applications of the character set. By arranging printable ASCII characters in patterns, artists create images that can be displayed in any text-only environment. This art form dates back to the earliest days of computing when graphical displays were unavailable.

The key to ASCII art lies in character density. Different characters occupy different amounts of visual "weight" on screen. The at sign (@) and hash (#) are visually heavy, while the period (.) and space are light. A gradient from darkest to lightest might use: @#%*+=-:. (space). By mapping pixel brightness values to these characters, any photograph can be converted to ASCII art.

I find that understanding ASCII art helps reinforce the distinction between character codes and their visual representations. Code 64 (@) and code 46 (.) are just numbers internally, but their printed forms have dramatically different visual weights. This concept extends to font design and typographic rendering in general.

Beyond art, ASCII characters are used creatively in emoticons (the original emoji, before Unicode graphics). The smiley :-) was first proposed by Scott Fahlman at Carnegie Mellon University on September 19, 1982. Other early emoticons include the wink ;-), the frown :-(, and the tongue-out :-P. These all use standard printable ASCII characters from codes 40-80.

Box-drawing is another creative application. While true box-drawing characters exist in extended ASCII (code page 437), many developers use the standard ASCII characters +, -, and | to create tables and borders in plain text. This technique remains common in command-line interfaces, log files, and configuration outputs.

Number Systems Explained

Understanding number systems is important for working with ASCII codes effectively. Each ASCII value can be represented in four common number systems: decimal (base 10), hexadecimal (base 16), octal (base 8), and binary (base 2). Here is how each system works and why it matters.

Decimal (Base 10)

Decimal is the number system we use daily. Each digit position represents a power of 10. The number 65 means 6 times 10 plus 5 times 1. In ASCII, decimal is the most human-readable representation, which is why it appears first in most ASCII charts.

Hexadecimal (Base 16)

Hexadecimal uses digits 0-9 and letters A-F to represent values 0-15. Each hex digit corresponds exactly to 4 binary bits, making hex a compact way to represent binary data. In ASCII, the hex range is 00 to 7F. The letter A (decimal 65) is hex 41, calculated as 4 times 16 + 1 = 65. Hex is universally used in programming for character codes, memory addresses, and color values.

Common hex patterns in ASCII are worth memorizing. The digit characters 0-9 span hex 30-39. Uppercase letters span 41-5A. Lowercase letters span 61-7A. Notice the elegant hex structure: lowercase is always uppercase plus hex 20 (decimal 32).

Octal (Base 8)

Octal uses digits 0-7, with each digit representing 3 binary bits. While less common today, octal was historically important in computing because early computers like the PDP-8 used 12-bit words that divided evenly into octal digits. Unix file permissions still use octal notation (755, 644, etc.), and C language escape sequences use octal for character codes (e.g., \101 for 'A').

Binary (Base 2)

Binary is the native language of computers. Each bit is either 0 or 1, and standard ASCII uses 7 bits per character (0000000 to 1111111). The letter A (65) in binary is 1000001. Understanding binary ASCII helps explain the structure of the character set:

Conversion Examples

ASCII in Networking and Protocols

Many foundational internet protocols are text-based and rely exclusively on ASCII characters. Understanding this helps explain why ASCII remains relevant decades after Unicode's introduction.

HTTP

The Hypertext Transfer Protocol uses ASCII text for all headers, methods, and status messages. When your browser requests a web page, it sends something like "GET /index.html HTTP/1.1" followed by headers, all in ASCII. The header names (Content-Type, Accept, Authorization) and values are ASCII strings. While HTTP can transmit binary data in the body, the protocol framing itself is pure ASCII.

SMTP (Email)

The Simple Mail Transfer Protocol was designed in 1982 as a pure ASCII protocol. Commands like HELO, MAIL FROM, RCPT TO, and DATA are all ASCII. This is why email originally supported only 7-bit ASCII text. Sending non-ASCII content (accented characters, images, attachments) required MIME encoding, which converts binary data into ASCII characters using Base64 or quoted-printable encoding.

DNS

Domain names were originally restricted to ASCII letters, digits, and hyphens (the "LDH rule"). Internationalized domain names (IDN) were introduced later using Punycode, which encodes Unicode domain names as ASCII-compatible strings. For example, the domain "munchen.de" with an umlaut over the u would be encoded as "xn--mnchen-3ya.de" in Punycode, using only ASCII characters.

FTP

The File Transfer Protocol distinguishes between ASCII mode and binary mode for file transfers. In ASCII mode, line endings are converted between the conventions of the sending and receiving systems (LF vs. CR+LF). This distinction was critical when transferring text files between Unix and Windows systems.

URL Encoding

URLs can only contain certain ASCII characters. Characters outside this safe set must be percent-encoded: each byte is represented as a percent sign followed by two hexadecimal digits. A space becomes %20, an ampersand becomes %26, and non-ASCII characters are first encoded as UTF-8 bytes, then each byte is percent-encoded. This is why URLs sometimes contain long strings of percent-encoded values.

Security Considerations

ASCII characters play a role in several security concerns that web developers and system administrators must understand.

Null Byte Injection

The NUL character (ASCII 0) terminates strings in C and many related languages. Attackers can inject null bytes into inputs to truncate strings at unexpected points. For example, a filename "report.pdf%00.exe" might pass a file extension check (seeing ".pdf") but be interpreted as "report.pdf" when the null byte truncates the name. Modern web frameworks sanitize null bytes in input, but legacy systems may still be vulnerable.

Control Character Injection

Injecting ASCII control characters into log files can manipulate how those logs are displayed. The carriage return (CR, code 13) can overwrite the beginning of a log line, making malicious entries appear benign. The escape character (ESC, code 27) can inject ANSI terminal codes that change text color or even execute commands in vulnerable terminal emulators. Always sanitize control characters from user input before writing to logs.

Homoglyph Attacks

While technically a Unicode issue, homoglyph attacks relate to ASCII because they exploit visual similarity between ASCII characters and characters from other scripts. The Cyrillic letter "a" (U+0430) looks identical to the Latin letter "a" (ASCII 65/97) on screen. Attackers use this to create phishing domains like "apple.com" where one or more letters are actually Cyrillic. Browsers now display Punycode for mixed-script domains to prevent this.

SQL Injection and Special Characters

Several ASCII characters have special meaning in SQL: the single quote (39), double quote (34), semicolon (59), and hyphen-minus (45, used in SQL comments as --). When user input containing these characters is inserted directly into SQL queries, it can modify the query structure. Parameterized queries (prepared statements) prevent this by separating data from SQL code.

Cross-Site Scripting (XSS)

The less-than sign (60), greater-than sign (62), and ampersand (38) are the primary ASCII characters involved in XSS attacks. When user input is reflected in HTML without escaping these characters, attackers can inject script tags. Proper output encoding converts these characters to their HTML entities (<, >, &) before rendering.

ASCII in File Formats

Many common file formats are ASCII-based, meaning they can be opened and read in any text editor. Understanding which formats are ASCII helps with debugging, version control, and data processing.

Plain Text Formats

CSV (Comma-Separated Values) files use ASCII commas (44), double quotes (34), and newlines to structure tabular data. The simplicity of CSV has made it the universal exchange format for spreadsheet and database data. Fields containing commas or quotes must be enclosed in double quotes, and literal double quotes within fields are escaped by doubling them.

JSON (JavaScript Object Notation) uses a handful of ASCII structural characters: curly braces (123, 125), square brackets (91, 93), colon (58), comma (44), and double quote (34). While JSON supports Unicode through \u escape sequences, the format structure itself is pure ASCII. This makes JSON files easy to transmit over ASCII-only protocols.

XML and HTML use angle brackets (60, 62), ampersand (38), and quotes to define markup structure. The five characters that must be escaped in XML (&, <, >, ", ') are all basic ASCII. XML documents declare their encoding in the XML prolog, but the prolog itself must be ASCII so parsers can read it.

Configuration Files

INI files use equals signs (61), square brackets (91, 93), and semicolons (59) for structure. YAML uses colons (58), hyphens (45), and indentation (spaces, code 32). TOML uses equals signs, square brackets, and double quotes. All of these formats are human-readable because they use only standard ASCII characters for their syntax.

Source Code

Most programming languages restrict their syntax to ASCII characters. Keywords, operators, and delimiters are all ASCII. Even in languages that support Unicode identifiers (like Python 3, Java, and Swift), the vast majority of real-world code uses only ASCII characters. This means source code files are almost always valid ASCII, regardless of their declared encoding.

Terminal Escape Sequences

ANSI escape sequences start with the ESC character (ASCII 27, hex 1B) followed by specific ASCII characters to control terminal behavior. These sequences are the foundation of colored terminal output, cursor positioning, and text formatting in command-line environments.

Common Escape Sequences

The most widely used sequences begin with ESC followed by [ (known as CSI, Control Sequence Introducer). The full sequence is ESC[parametersm for text formatting, where parameters are ASCII digit strings separated by semicolons.

These sequences are composed entirely of printable ASCII characters (except for the initial ESC). The digit characters (48-57), semicolon (59), and specific letter terminators (m = 109, H = 72, J = 74) form a mini-language within the ASCII character set. Terminal emulators parse these sequences and apply the formatting instead of displaying the raw characters.

Color Support in Modern Terminals

Modern terminal emulators support 256-color mode (ESC[38;5;nm for foreground, ESC[48;5;nm for background) and true color (ESC[38;2;r;g;bm). Even these extended sequences use only ASCII characters: digits, semicolons, and the letter m. The entire ANSI color system is built from about a dozen ASCII characters.

I use ANSI escape sequences in my own development workflow for colored log output, progress bars, and test result formatting. Understanding the underlying ASCII codes helps when debugging situations where escape sequences are not interpreted correctly and appear as raw text. This happens frequently when piping output between programs that have different terminal capabilities, or when viewing log files that contain embedded escape codes.

Practical ASCII Patterns for Developers

Here are patterns I have found useful when working with ASCII values in production code.

Case-insensitive comparison without locale issues: Instead of calling toLower() or toUpper() (which can behave unexpectedly with locale-sensitive characters), compare ASCII letters by OR-ing each character with 0x20 (hex for 32). This forces both uppercase (65-90) and lowercase (97-122) to their lowercase form. This works because the only difference between cases in ASCII is bit 5.

Fast digit validation: A character c is an ASCII digit if (c - 48) is an unsigned value less than 10. In C, this is: (unsigned)(c - '0') < 10. This single comparison replaces the slower c >= '0' && c <= '9'.

ASCII-safe Base64: Base64 encoding converts arbitrary binary data into a string using only 64 ASCII characters: A-Z (26), a-z (26), 0-9 (10), + (1), and / (1), plus = for padding. This makes it safe to embed binary data in text formats like JSON, XML, email, and URLs (with URL-safe variants using - and _ instead of + and /).

Hexadecimal encoding: Each byte of data can be represented as two ASCII hex characters (0-9, A-F or a-f). This doubles the data size but produces output that uses only 22 distinct ASCII characters and is safe in any text context. Hex encoding appears in hash outputs (SHA-256 produces 64 hex characters), MAC addresses, and color codes.

Frequently Asked Questions

Is ASCII still used in modern computing?

Yes. While Unicode (UTF-8) has largely replaced ASCII as a file encoding, ASCII remains the foundation of UTF-8. Every UTF-8 file that contains only characters in the 0-127 range is byte-identical to an ASCII file. HTML, CSS, JavaScript, JSON, and most programming language source code use almost exclusively ASCII characters.

What is the highest ASCII value?

Standard ASCII goes up to 127 (binary 1111111, hex 7F), which is the DEL character. Extended ASCII code pages use values 128-255, but these are not part of the original ASCII standard and vary between implementations.

How do I type ASCII control characters?

On most systems, control characters can be entered by holding the Ctrl key and pressing a letter. Ctrl+A produces ASCII 1 (SOH), Ctrl+C produces ASCII 3 (ETX, commonly used to interrupt a program), Ctrl+M produces ASCII 13 (CR), and Ctrl+J produces ASCII 10 (LF). The mapping follows the pattern: Ctrl+letter = ASCII code of the uppercase letter minus 64.

Why is the space character code 32?

The space character (code 32) is the first printable ASCII character and sits at the boundary between control characters (0-31) and visible characters (33-126). Its position at 32 (binary 0100000) means it occupies the first code where bit 5 is set and all other bits are 0, which gave it special properties in sorting algorithms and early hardware implementations.

Can ASCII represent characters from other languages?

Standard ASCII (0-127) only includes English letters, digits, and basic punctuation. It cannot represent characters from other languages like accented letters (e, u with accents), Chinese characters, Arabic script, or Cyrillic letters. Extended ASCII (128-255) added some European characters but varied by code page. For true multilingual support, Unicode (specifically UTF-8) is required. UTF-8 is backward-compatible with ASCII, so any ASCII document is automatically valid UTF-8.

What does ASCII stand for?

ASCII stands for American Standard Code for Information Interchange. The name reflects its origins as an American standard (developed by the ASA, later ANSI) designed to facilitate data exchange between different computer systems. The word "interchange" emphasizes that ASCII's primary goal was compatibility, not just character representation.

How is ASCII different from ANSI?

ASCII is a character encoding standard defining 128 characters. ANSI refers to the American National Standards Institute, the organization that published the ASCII standard. The term "ANSI encoding" is often loosely used to refer to Windows-1252 or other Windows code pages, but this is technically imprecise. ANSI is the standards body; ASCII (formally ANSI X3.4) is one specific standard they published.

What are the most commonly used ASCII characters in English?

After the space (code 32), which is by far the most frequent, the most common ASCII characters in English text are: e (101), t (116), a (97), o (111), i (105), n (110), s (115), h (104), and r (114). This frequency distribution is the basis for Huffman coding, Morse code letter assignments, and many cryptanalysis techniques. In typical English prose, the space character accounts for roughly 18% of all characters.

How do I find the ASCII value of a character on my keyboard?

Use the search bar in the ASCII table above. Type any character and the table will filter to show its decimal, hexadecimal, octal, and binary values. Alternatively, type the character in the converter tool and select your preferred output format. In a programming environment, you can use functions like Python's ord() or JavaScript's charCodeAt().

References and Sources

• Unicode Consortium - C0 Controls and Basic Latin Chart (U+0000-U+007F)
• RFC 20 - ASCII Format for Network Interchange (Cerf, 1969)
• ISO/IEC 646:1991 - Information Technology - ISO 7-bit Coded Character Set
• Mackenzie, C.E. (1980). Coded Character Sets, History and Development. Addison-Wesley. ISBN 0-201-14460-3.

Related Free Tools

This tool runs entirely in your browser. No data is stored, transmitted, or collected. Your inputs stay on your device. Built for all modern browsers including Chrome, Firefox, Safari, and Edge.