Every printable character on a US keyboard has a fixed integer between 32 and 126 in the ASCII table, and including the 33 control characters the complete standard covers decimal 0 through 127. Converting ASCII to integer means replacing each character in your text with that assigned decimal number — for example, the letter "A" becomes the integer 65, the digit "0" becomes 48, and a single space becomes 32. The mapping is defined by IETF RFC 20 and matches the Unicode C0 Controls and Basic Latin chart, so the same integers work in every modern system that follows the standard. The catch is that "ASCII" is strict: anything beyond code point 127, including accented letters, emoji, and many punctuation marks, simply has no ASCII integer and must be handled by a different encoding such as UTF-8. So when someone searches for a way to convert ASCII to integer, they usually want a tool that takes their plain English text, hands back a clean list of decimal numbers, and refuses to invent values for characters that fall outside the 7-bit range. That is exactly what the ASCII Converter does.
What "Converting ASCII to Integer" Actually Means
ASCII assigns a unique integer to each of its 128 characters. The 32 control codes occupy decimal 0 through 31, the printable space sits at 32, then come punctuation, digits, and letters in clearly grouped blocks, and finally the DEL control code at 127 brings the non-printing total to 33. The integer is simply the character's position in that table — there is no formula to memorize, only a fixed lookup. Most reference tables present the mapping in three columns: decimal, hexadecimal, and the character glyph itself.
For practical work, the integers you will see most often cluster in three familiar blocks:
- Space is 32, "!" is 33, the digits "0" through "9" run consecutively from 48 to 57, and ":" is 58.
- Uppercase "A" through "Z" occupy 65 through 90, exactly one integer per letter, in alphabetical order.
- Lowercase "a" through "z" occupy 97 through 122, also consecutive and alphabetical.
Because the digits and letters sit in tidy runs, you can often predict the integer of a nearby character without a table. The uppercase-to-lowercase gap is exactly 32 (97 − 65 = 32), which is why so many programming languages convert case by adding or subtracting 32. Once you know where the runs start and end, almost every other printable value falls out by counting.
The Decimal Range: Why 0 to 127 Is the Whole Story
ASCII is a 7-bit code, so it defines 27 = 128 positions, and decimal 0 through 127 is the complete range. Values 128 through 255 are not part of standard ASCII — they belong to a family of "extended ASCII" encodings such as Windows-1252 or ISO-8859-1 that assign different characters in the same numeric range. That is why the phrase "extended ASCII" can refer to incompatible code pages: the same numeric position can map to entirely different characters depending on which code page is in use. Treating those values as standard ASCII is one of the most common sources of garbled text in legacy systems.
The ASCII Converter enforces the strict 0–127 boundary rather than guessing. Encoding rejects the first character outside 7-bit ASCII and reports its position so you can locate the problem in long inputs. Decoding requires plain unsigned decimal integers and rejects signed numbers, fractions, hexadecimal prefixes like 0x, empty tokens, and values above 127. The eight standard fixtures that pin the implementation are the lower boundary (0), TAB (9), LF (10), space (32), digit zero (48), uppercase A (65), lowercase a (97), and the upper boundary (127), matching the assignments in RFC 20 and the Unicode chart. For reference, here is how the ASCII range is structured:
| Decimal range | Contents |
|---|---|
| 0–31 | C0 control characters (NUL, TAB, LF, CR, ESC, etc.) |
| 32 | Space |
| 33–47 | Punctuation: ! " # $ % & ' ( ) * + , - . / |
| 48–57 | Digits 0–9 |
| 58–64 | Punctuation: : ; < = > ? @ |
| 65–90 | Uppercase letters A–Z |
| 91–96 | Punctuation: [ \ ] ^ _ ` |
| 97–122 | Lowercase letters a–z |
| 123–126 | Punctuation: { | } ~ |
| 127 | DEL control character |
The input limit is 100,000 UTF-16 code units, with a 50,000-code bound on decoding, so even multi-page ASCII documents convert in a single pass without hitting the boundary. Everything runs in the current browser tab, which keeps private text and proprietary inputs from leaving your machine.
How to Convert ASCII to Integer (and Back)
The fastest way to get exact decimal integers from ASCII text — or to rebuild ASCII text from a list of integers — is the ASCII Converter. Processing happens in the current browser tab, so nothing is uploaded. Follow these steps for a clean conversion in either direction:
- Open the ASCII Converter and pick the direction. Choose text to codes to convert ASCII characters into a list of decimal integers, or choose codes to text to decode a list of decimal integers back into exact ASCII characters.
- In text to codes mode, type or paste your ASCII-only text into the input area. The tool treats the input as plain 7-bit ASCII and assigns one decimal integer per character, in order.
- In codes to text mode, enter decimal integers in the range 0 through 127, separated by spaces, commas, or line breaks. Plain unsigned integers are required; values such as +65, 65.0, or 0x41 will be rejected with a visible error.
- Click Convert ASCII. The tool validates every character or every token, performs the conversion, and surfaces clear errors when input falls outside the 7-bit range or the token count is excessive.
- Read the result. For text to codes, the output is a space-separated list of decimal integers; for codes to text, the output is the rebuilt ASCII string. Use the copy control to move the result into your editor, terminal, or source code.
For a quick worked example, take the two-character string "Hi". Looking up the table: "H" is 72 and "i" is 105, so the converter returns the decimal integers 72 105. Feeding 72 105 back into codes-to-text mode rebuilds the original string exactly. This round trip is the cleanest way to verify that the integers you have correspond to the characters you expect, and it works because the mapping is a bijection — every code unit in 0–127 maps to exactly one character and back.
Common ASCII Integer Values at a Glance
Most ASCII-to-integer tasks only need a handful of values. The table below covers the constants that come up in nearly every project — printable anchors on one side, important control codes on the other. Use it as a quick check whenever you are not sure of an assignment, or as a sanity check against the converter output.
| Character | Decimal | Why it matters |
|---|---|---|
| (space) | 32 | The only printable character below the digits |
| "0" | 48 | Start of the consecutive digit run 48–57 |
| "9" | 57 | End of the digit run |
| "A" | 65 | Start of the uppercase letter run 65–90 |
| "Z" | 90 | End of the uppercase letter run |
| "a" | 97 | Start of the lowercase letter run 97–122 |
| "z" | 122 | End of the lowercase letter run |
| NUL | 0 | Lower boundary of the ASCII range |
| TAB | 9 | Horizontal tab, often invisible in the output textarea |
| LF | 10 | Line feed, the standard newline on Unix-like systems |
| CR | 13 | Carriage return, used with LF on Windows and in classic Mac files |
| DEL | 127 | Upper boundary of the ASCII range |
Decimal Integers vs Hex, Binary, and Octal
The same ASCII character can be written in several bases, and the integer you see depends on which base you are reading. The letter "A" is 65 in decimal, 0x41 in hexadecimal, 101 in octal, and 1000001 in binary. Decimal integers are usually the easiest to read and to compare across systems, which is why most documentation and most high-level programming languages default to base 10 when discussing ASCII values. Hexadecimal is more compact — every 7-bit value fits in exactly two hex digits — and it is the standard in memory dumps, color codes, and low-level code, while binary is most useful for explaining bit patterns such as the high bit that separates ASCII from extended encodings.
| Base | Form of "A" | Where it shows up |
|---|---|---|
| Decimal | 65 | General reading, most high-level programming |
| Hexadecimal | 0x41 | Memory dumps, color codes, low-level code, HTML and CSS escapes |
| Octal | 101 | Legacy Unix file permissions, some C string escapes |
| Binary | 1000001 | Bit-level documentation, teaching the 7-bit range |
If you want to take the same input further into hexadecimal or binary, the ASCII Converter gives you a clean decimal list first, and the follow-up walkthrough in our decimal-to-hex guide explains how to read those same integers as 0x values without losing precision. The reverse direction — turning a list of integers back into the characters they represent, with extra detail on token formats and control characters — is covered in the decimal codes to text guide.
When Decimal Integers Are Not the Right Tool
ASCII is intentionally small. If your text contains accented letters such as é or ñ, characters from non-Latin scripts, emoji, or any punctuation beyond the printable ASCII block, those code points do not have an ASCII integer and the converter will reject the first offending character rather than invent a value. The same is true if you are looking at bytes that were encoded in UTF-8, Windows-1252, ISO-8859-1, or any other named code page: a single character such as é can be one byte in Windows-1252, two bytes in UTF-8, and a different byte in Latin-1, and the ASCII Converter is not the right place to disambiguate those. For Unicode code points, multi-byte encodings, or locale-specific conversion, choose a converter that explicitly names the encoding it is using instead of treating the input as ASCII. The strict 0–127 boundary is a feature, not a limitation: it guarantees that the integers you get out correspond to one universal standard and can be read by any system that implements RFC 20, with no ambiguity about which character a given integer represents.