Unicode Code Point Converter
Convert text into Unicode code points or decode Unicode code point values back into text. Work with standard U+ notation, hexadecimal and decimal values, HTML numeric character references and JavaScript Unicode escapes while inspecting exact Unicode scalar values.
—
—
—
Unicode Code Point Converter
The Unicode Code Point Converter translates Unicode text into the numeric code points assigned to its characters and converts valid code point values back into text. It supports standard U+ notation as well as hexadecimal, decimal, HTML numeric references and JavaScript Unicode escape notation.
Every Unicode character is associated with a numeric code point. For example, the Latin capital letter A is U+0041, the euro sign is U+20AC and the grinning face emoji is U+1F600.
This tool is useful for software development, Unicode debugging, HTML authoring, JavaScript development, character identification, encoding analysis and understanding how characters are represented independently of UTF-8, UTF-16 or UTF-32.
How to Convert Text to Unicode Code Points
Select Text → Unicode Code Points, enter the text you want to inspect and choose an output notation. The converter reads the input as Unicode code points rather than simply processing individual UTF-16 code units.
Text:
A€😀
Unicode code points:
U+0041 U+20AC U+1F600
Hexadecimal:
0041 20AC 1F600
Decimal:
65 8364 128512Supplementary characters such as emoji are therefore returned as one Unicode code point rather than incorrectly appearing as two UTF-16 surrogate values.
How to Convert Unicode Code Points to Text
Select Unicode Code Points → Text, choose the notation used by your input and enter one or more valid code points. The converter validates each value before constructing the corresponding Unicode text.
Input:
U+0041 U+20AC U+1F600
Output:
A€😀Values above U+10FFFF and surrogate values from U+D800 through U+DFFF are rejected because they are not valid Unicode scalar values.
What Is a Unicode Code Point?
A Unicode code point is a numeric value used to identify an element in the Unicode codespace. Code points are commonly written with the prefix U+ followed by hexadecimal digits.
| Character | Unicode | Hexadecimal | Decimal |
|---|---|---|---|
| A | U+0041 | 0041 | 65 |
| é | U+00E9 | 00E9 | 233 |
| € | U+20AC | 20AC | 8364 |
| 中 | U+4E2D | 4E2D | 20013 |
| 😀 | U+1F600 | 1F600 | 128512 |
Unicode U+ Notation
U+ notation is the conventional human-readable way to identify a Unicode code point. The U+ prefix indicates Unicode, while the digits following it are hexadecimal.
A = U+0041
é = U+00E9
€ = U+20AC
中 = U+4E2D
😀 = U+1F600U+1F600 does not mean that the character is stored in memory using the literal text “U+1F600”. It identifies the character’s Unicode code point. The actual stored bytes depend on the selected character encoding.
Unicode Code Point in Hexadecimal and Decimal
A code point is a number, so it can be represented using different number systems. Unicode documentation usually uses hexadecimal, while some APIs and programming contexts expose decimal values.
Character:
€
Unicode notation:
U+20AC
Hexadecimal:
20AC
Decimal:
8364Hexadecimal 20AC and decimal 8364 identify exactly the same Unicode code point.
Unicode Code Points as HTML Numeric References
HTML numeric character references allow a Unicode code point to be represented in markup using either decimal or hexadecimal notation.
Character:
€
HTML decimal:
€
HTML hexadecimal:
€
Rendered character:
€The hexadecimal form begins with &#x, while the decimal form begins with &#. Both end with a semicolon.
Unicode Code Points as JavaScript Escapes
JavaScript source code can represent Unicode characters using escape
notation. Basic Multilingual Plane values can use four-digit
\uXXXX escapes, while modern JavaScript also supports
code-point escapes using braces.
A:
\u0041
€:
\u20AC
😀:
\u{1F600}The braced form is particularly useful for supplementary-plane code points because the entire Unicode value can be expressed directly.
Unicode Code Point Example: Letter A
Character:
A
Unicode:
U+0041
Hexadecimal:
0041
Decimal:
65
HTML hex:
A
HTML decimal:
A
JavaScript:
\u0041A belongs to the ASCII range. Its Unicode code point and ASCII numeric value therefore correspond to the same number, 65 decimal.
Unicode Code Point Example: Euro Sign
Character:
€
Unicode:
U+20AC
Hexadecimal:
20AC
Decimal:
8364
HTML hex:
€
HTML decimal:
€
JavaScript:
\u20ACUnicode Code Point Example: Emoji
Many emoji use supplementary Unicode code points above U+FFFF. The grinning face character is a useful example.
Character:
😀
Unicode:
U+1F600
Hexadecimal:
1F600
Decimal:
128512
HTML:
😀
JavaScript:
\u{1F600}U+1F600 is one Unicode code point even though environments based on UTF-16 internally represent it using two surrogate code units.
BMP and Supplementary Unicode Code Points
The Basic Multilingual Plane, or BMP, contains code points from U+0000 through U+FFFF. Unicode also contains supplementary planes covering values from U+10000 through U+10FFFF.
| Range | Category | Example | Code Point |
|---|---|---|---|
| U+0000–U+FFFF | Basic Multilingual Plane | € | U+20AC |
| U+10000–U+10FFFF | Supplementary Planes | 😀 | U+1F600 |
Unicode Code Points vs UTF-8 Bytes
Unicode code points identify characters, while UTF-8 defines how those code points are encoded into bytes. The two representations should not be confused.
Character:
€
Unicode code point:
U+20AC
UTF-8 bytes:
E2 82 ACU+20AC is the character’s numeric Unicode identity. E2 82 AC is one specific encoded representation of that value.
Unicode Code Points vs UTF-16 Code Units
For most Basic Multilingual Plane characters, one Unicode code point corresponds to one UTF-16 code unit. Supplementary characters require two UTF-16 surrogate code units.
Character:
😀
Unicode code point:
U+1F600
UTF-16 code units:
D83D DE00
Code points:
1
UTF-16 units:
2The converter reports U+1F600 as the actual Unicode scalar value rather than treating the surrogate components as separate characters.
Unicode Scalar Values and Invalid Code Points
The Unicode codespace extends from U+0000 through U+10FFFF, but the surrogate range U+D800 through U+DFFF is reserved for UTF-16 and does not contain Unicode scalar values.
Valid:
U+0041
U+20AC
U+1F600
U+10FFFF
Invalid scalar values:
U+D800
U+DFFF
U+110000Decode mode validates input so invalid scalar values are rejected rather than converted into malformed text.
Why Convert Unicode Code Points?
Code point conversion is useful when identifying unusual characters, debugging text-processing problems, examining multilingual strings, working with programming languages or interpreting values from Unicode documentation.
It can also help investigate invisible characters, compare visually similar symbols, construct HTML character references, create JavaScript Unicode escapes and understand the relationship between text and character encodings.
Common technical uses
Developers frequently inspect Unicode code points when debugging APIs, databases, search systems, normalization problems, emoji handling, regular expressions, internationalized software and text imported from external data sources.
Common Unicode Code Point Mistakes
One common mistake is treating UTF-8 hexadecimal bytes as Unicode code points. For example, E2 82 AC is the UTF-8 byte sequence for €, while the character’s code point is U+20AC.
Another mistake is treating UTF-16 surrogate values such as D83D and DE00 as independent Unicode characters when they actually combine to represent the supplementary code point U+1F600.
A third mistake is assuming that one visible symbol always equals one code point. Some emoji, accented sequences and writing systems may use multiple Unicode code points that combine visually.
Unicode Code Point Converter Limitations and Notes
The converter works at the Unicode code-point level rather than the grapheme-cluster level. A visible character may therefore produce more than one result when it consists of combining marks, variation selectors or zero-width-joiner sequences.
The converter does not normalize Unicode input. If two visually similar strings use different underlying code-point sequences, their results remain different so the actual data can be inspected accurately.
Control characters and invisible formatting characters may not produce a visible glyph when decoded, although their code point values remain valid.