What Is a Unicode Code Point?

Unicode code points at a glance

A code point identifies a position in the Unicode codespace. It does not define a font, glyph shape, byte sequence or storage format by itself.

What exactly is a code point?

A code point is an abstract numeric value. Unicode assigns code points to letters, punctuation, symbols, control characters, combining marks and emoji. A code point is not the same as a glyph, byte or encoded sequence, and it is independent of the encoding used to store it.

Use the Unicode Character Inspector for pasted text, or the Unicode Character Lookup when searching by name, glyph or code point.

What does U+ mean?

U+ is the standard notation used to identify Unicode code points. The digits after U+ are hexadecimal, using 0–9 and A–F. Leading zeroes are commonly included for shorter values. U+0041 and hexadecimal 0x41 represent the same numeric value in different notation, but U+0041 is a code point, not a UTF-8 byte sequence.

U+0041 → decimal 65 → A
U+00E9 → decimal 233 → é
U+0416 → decimal 1046 → Ж
U+1F600 → decimal 128512 → 😀

The U+ prefix identifies Unicode code-point notation. Prefixes such as 0x, \u and &#x are used in other contexts.

Interactive code-point inspector

This embedded inspector handles characters and common code-point notation locally in your browser. It uses a small built-in property map for common examples and labels unknown values clearly.

Character vs glyph vs code point

Character

A character is an abstract text element, such as the letter A or an accent mark.

Code point

A code point is a number assigned within the Unicode codespace.

Glyph

A glyph is a visual shape drawn by a font or rendering system.

Character: A
Code point: U+0041
Glyph: the visual form selected by the current font

Different fonts can render the same code point differently. A single glyph may represent multiple code points, and a single code point may have different glyph forms depending on context. Some scripts use shaping and ligatures.

Code points vs bytes

Code points are abstract numbers. Bytes are storage units. Encodings map code points to bytes, so the same code point may have different byte representations in UTF-8, UTF-16 and UTF-32.

U+00E9 identifies the code point for é. C3 A9 is its UTF-8 byte sequence. For details, read Unicode vs UTF-8, UTF-8 vs UTF-16, or use the UTF-8 Encoder and Decoder.

Code points vs code units

A code unit is the smallest unit used by an encoding form. UTF-8 uses 8-bit code units, UTF-16 uses 16-bit code units and UTF-32 uses 32-bit code units. One code point may require multiple code units.

😀
Code point: U+1F600
UTF-8: 4 code units / bytes
UTF-16: 2 code units
UTF-32: 1 code unit

In UTF-16, supplementary code points require a surrogate pair. In UTF-8, many code points require multiple bytes. One UTF-32 code unit corresponds to one code point, not necessarily one visible grapheme. Read Code Points, Code Units and Grapheme Clusters or inspect sequences with the Unicode Sequence Analyzer.

The Unicode codespace

Unicode code points range from U+0000 to U+10FFFF. This range is the Unicode codespace and contains 1,114,112 possible code-point values. Not every value is assigned to a character. Some ranges are reserved, private-use or unassigned, and surrogate code points are reserved for UTF-16 and are not valid Unicode scalar values.

U+0000
   ↓
U+FFFF       Basic Multilingual Plane
   ↓
U+10000
   ↓
U+10FFFF     End of Unicode codespace

Unicode planes

The codespace is divided into 17 planes. Each plane contains 65,536 code points. Plane 0 is the Basic Multilingual Plane, and planes 1–16 are supplementary planes. Plane numbers range from 0 to 16, and not every plane is equally populated.

This table highlights important examples; planes not shown still exist within the 17-plane structure.

What is the Basic Multilingual Plane?

The Basic Multilingual Plane, or BMP, is Plane 0. It covers U+0000 to U+FFFF and contains many commonly used scripts, punctuation marks and symbols. BMP code points normally use one UTF-16 code unit, but some BMP values are combining marks, controls, reserved values or surrogates.

A → U+0041
é → U+00E9
Ж → U+0416
字 → U+5B57

😀 → U+1F600

😀 is outside the BMP. The BMP is large and important, but it does not contain all Unicode characters.

Unicode scalar values and surrogate code points

Unicode scalar values include code points from U+0000 to U+D7FF and U+E000 to U+10FFFF. The range U+D800 to U+DFFF is reserved for UTF-16 surrogates. Surrogate code points must not appear as standalone Unicode scalar values.

U+1F600 → UTF-16 code units D83D DE00

D83D is a high surrogate. DE00 is a low surrogate. Neither surrogate alone represents the emoji.

Assigned, reserved and unassigned code points

Assigned code points

Values assigned to characters, marks, controls or other defined elements.

Unassigned code points

Values currently without an assigned character.

Reserved code points

Values set aside for special purposes or future use.

Noncharacters

Code points permanently reserved for internal use and not intended for open interchange.

Private-use characters

Code points available for private agreements between systems, not globally standardized characters. Browse with Unicode Character Lookup or the Unicode Table.

Does one code point equal one character?

Not always. A user-perceived character is often called a grapheme cluster, and it may contain one code point or several.

Combining marks

é may be U+00E9 or U+0065 U+0301. The second representation uses two code points.

Emoji sequences

👨‍👩‍👧‍👦 may display as one family emoji but contain multiple emoji code points and zero-width joiners.

Flags, modifiers and shaping

Flags can be built from regional-indicator code points. Some emoji combine a base emoji with a skin-tone modifier. Several script code points may render together as one shaped cluster.

Use the Unicode Character Counter, Unicode Sequence Analyzer and grapheme-cluster guide when visible counts matter.

Combining characters and normalization

The word café can have different code-point sequences.

Precomposed:
U+0063 U+0061 U+0066 U+00E9

Decomposed:
U+0063 U+0061 U+0066 U+0065 U+0301

The strings may look identical, but their code-point sequences differ. Unicode normalization can convert canonically equivalent forms. NFC, NFD, NFKC and NFKD affect code-point sequences. Normalization is different from encoding.

Try the Unicode Normalizer, Unicode Normalization Checker or read Unicode Normalization Explained.

How code points are encoded

The code point remains the same while encoded values differ. UTF-8 and UTF-16 are variable-length. UTF-32 uses one 32-bit code unit per code point. Byte order matters when serializing UTF-16 and UTF-32. Convert with UTF-8 Encoder and Decoder, Text to Unicode Code Points and Unicode Code Points to Text.

Code points in HTML, JavaScript, Python and JSON

Escape syntax is not the same as encoded bytes. Some languages support code-point escapes above U+FFFF. JavaScript \uXXXX uses four hexadecimal digits and may require a surrogate pair unless \u{...} is used. JSON escapes operate inside JSON string syntax. Try Unicode Escape Converter, HTML Entity Encoder and Decoder, JSON Escape and Unescape or JavaScript Escape and Unescape.

Working with code points in JavaScript

JavaScript strings use UTF-16 code units. Bracket indexing works with code units, charCodeAt() returns a UTF-16 code unit, and codePointAt() can return a full code point. for...of iterates code points, but grapheme clusters still require Intl.Segmenter.

const text = "A😀";

console.log(text.length); // 3 UTF-16 code units
console.log([...text].length); // 2 code points

const character = "😀";
const codePoint = character.codePointAt(0);

console.log(`U+${codePoint.toString(16).toUpperCase()}`);

for (const character of "A😀") {
    const value = character.codePointAt(0);
    console.log(character, `U+${value.toString(16).toUpperCase()}`);
}

Working with code points in Python

Python strings are Unicode text. ord() converts one character to its integer code point, chr() converts a valid integer code point to a string, and unicodedata exposes Unicode properties. Python iteration is generally code-point-oriented, not grapheme-cluster-oriented.

text = "A😀"

for character in text:
    value = ord(character)
    print(character, f"U+{value:04X}")

character = chr(0x1F600)
print(character)

import unicodedata

print(unicodedata.name("😀"))

Working with code points in PHP

PHP strings are byte sequences, so Unicode-aware operations need suitable functions. Use mbstring for multibyte-safe string operations and intl for IntlChar. strlen() counts bytes, and direct byte indexing does not return full Unicode characters.

$text = "A😀";

foreach (mb_str_split($text, 1, "UTF-8") as $character) {
    $codepoint = IntlChar::ord($character);
    printf("%s U+%04X\n", $character, $codepoint);
}

$character = IntlChar::chr(0x1F600);

Common code-point mistakes

Confusing code points with bytes

é is U+00E9, but its UTF-8 bytes are C3 A9.

Confusing code points with UTF-16 code units

Supplementary characters use surrogate pairs in UTF-16.

Assuming one code point equals one visible character

Combining marks and emoji sequences can create one visible grapheme from multiple code points.

Counting UTF-8 bytes as characters

Non-ASCII characters may use multiple bytes.

Slicing UTF-16 strings by arbitrary indices

You can split surrogate pairs.

Treating isolated surrogates as valid characters

Surrogates are not Unicode scalar values.

Assuming every code point is assigned

Some values are unassigned or private-use.

Assuming every assigned code point has a visible glyph

Controls, separators, combining marks and missing font coverage may not display visibly.

Using code-point count as a user-facing character count

Use grapheme clusters for user-visible character limits.

Confusing escapes with stored encoding

\u00E9 is escape syntax; C3 A9 is UTF-8 bytes.

How to inspect a code point

1. Copy or enter the character.
2. Inspect its code point.
3. Check the Unicode name.
4. Review its script and category.
5. Check whether it is combining or invisible.
6. Inspect UTF-8 bytes and UTF-16 code units.
7. Check normalization.
8. Look for confusable characters.
9. Compare suspicious strings at the code-point level.

Start with the Unicode Character Inspector, Unicode Character Lookup, Unicode Sequence Analyzer, Invisible Character Detector and Confusable Character Detector.

Try these UnicodeNow tools

These tools expose code points, encodings, escapes, normalization and length counts for real input.

Frequently asked questions

References

• The Unicode Standard
• Unicode glossary
• Unicode Character Database
• Unicode code charts
• Unicode Standard Annex #15: Unicode Normalization Forms
• Unicode Standard Annex #29: Unicode Text Segmentation
• RFC 3629: UTF-8, a transformation format of ISO 10646
• MDN: String.prototype.codePointAt()
• Python documentation: ord()
• Python documentation: chr()
• Python documentation: unicodedata
• PHP manual: IntlChar