A Unicode code point converter translates text into explicit U+ hexadecimal labels and rebuilds text from validated U+XXXX or \u{...} tokens.
For exact character inspection, use the Unicode Encoder / Decoder. It converts text to Unicode scalar-value labels and converts validated labels back to text, with the conversion running locally in your browser.
This tool answers a specific question: which abstract Unicode values does this string contain? It is useful for debugging copied strings, investigating invisible differences, reading code point notation in logs, and understanding why one visible symbol may contain several code points.

What a code point converter shows
A Unicode code point is an abstract value identified by a hexadecimal number. In U+ notation, the letter A becomes U+0041, while é is identified as U+00E9. The converter emits uppercase hexadecimal with a minimum of four digits.
Supplementary-plane characters retain their complete value. For example, 😀 is represented as U+1F600 rather than being split into two UTF-16 surrogate halves. This scalar-value behavior makes the output more useful for Unicode inspection than a sequence of JavaScript UTF-16 code units.
| Notation or representation | What it represents | Supported behavior |
|---|---|---|
| U+0041 | A Unicode scalar-value label | Produced in encode mode and accepted in decode mode |
| \u{1F600} | JavaScript-style scalar notation | Accepted in decode mode |
| U+200D | The zero-width joiner scalar value | Included explicitly when present in text |
| UTF-8 bytes | An encoded byte sequence | Not produced by this code point converter |
The distinction matters because a code point is not automatically the same thing as a user-perceived character. The converter shows the scalar sequence faithfully, but it does not claim to divide that sequence into grapheme clusters.
Convert text into U+ code points
Use this workflow when you need to inspect the exact Unicode values in a pasted string.
- Open the Unicode Encoder / Decoder and choose text-to-code-points mode.
- Paste the exact Unicode string into the input field. Do not remove spaces, line breaks, tabs, combining marks, or apparently invisible characters if those differences matter to your investigation.
- Run the conversion and inspect the resulting U+ labels. Each label identifies one Unicode scalar value.
- Check supplementary characters carefully. They remain a single value, such as U+1F600, instead of being exposed as separate surrogate code units.
- Copy the U+ sequence for documentation, comparison, or a round-trip check in decode mode.
Pasting the exact input is particularly important when diagnosing a failed comparison. A newline becomes U+000A, while a zero-width joiner appears as U+200D. Control characters and default-ignorable code points are included, so the converter can reveal differences that are difficult to see in rendered text.
Rebuild text from code point tokens
Decode mode is the reverse workflow. Enter tokens that begin with U+, or JavaScript-style \u{...} notation. Separate tokens with spaces, commas, or line breaks. Hexadecimal digits are case-insensitive, so U+00e9 and U+00E9 identify the same value.
For example, U+0041 reconstructs the letter A, while \u{1F600} reconstructs 😀. Keep the required prefixes and token boundaries when moving values between systems. Adjacent values can otherwise be mistaken for one longer hexadecimal number.
Every token is checked before the output text is constructed. The converter rejects missing prefixes, non-hexadecimal tokens, surrogate values, and numbers outside the Unicode scalar range instead of silently replacing an invalid entry. That validation is important because a broken token should not disappear from the reconstructed result.
For background on JavaScript code-point construction, the ECMAScript String.fromCodePoint specification documents the relevant scalar-value boundary. The converter validates the complete input before calling its code-point constructor.
Read a full scalar sequence
Some visible emoji are built from several Unicode scalar values. The emoji 👩💻 contains U+1F469, U+200D, and U+1F4BB: woman, zero-width joiner, and laptop. The U+200D sequence between the two pictographs joins them into one displayed symbol.
Flags, family emoji, accented forms, and many writing systems can also use multi-code-point sequences. A modifier, variation selector, combining mark, or joiner may be part of what a person sees as one character while remaining a separate scalar value in the output.
That is why “show each character” can be ambiguous. A code point converter exposes each scalar value, but it does not perform full grapheme segmentation or decide whether a sequence forms a recommended emoji or orthographic cluster. Its result is deliberately a precise scalar sequence.
Apply the scalar-value validation rules
Valid Unicode scalar values extend from U+0000 through U+10FFFF, except for the surrogate interval U+D800 through U+DFFF. Surrogate code units are reserved for UTF-16 pairs and do not identify standalone Unicode characters.
| Input value or format | Unicode rule | Decode result |
|---|---|---|
| U+0000 through U+D7FF | Within the scalar-value range | Accepted after validation |
| U+E000 through U+10FFFF | Within the scalar-value range | Accepted after validation |
| U+D800 through U+DFFF | Reserved surrogate interval | Rejected |
| Greater than U+10FFFF | Outside the Unicode maximum | Rejected |
| Missing U+ or \u{...} prefix | Required notation is absent | Rejected |
| Non-hexadecimal characters | Value is not a hexadecimal code point | Rejected |
These rules prevent a surrogate-based convention from round-tripping as though it represented valid standalone characters. They also make failures explicit, which is more useful when you are checking documentation, copied identifiers, or a sequence recorded in a bug report.
Keep code points separate from UTF-8 bytes
Unicode code points and UTF-8 bytes describe different layers. U+00E9 identifies the Unicode value é, while its UTF-8 representation uses the bytes C3 A9. The first is an abstract character value; the second is an encoded form used by files, protocols, and byte-oriented software.
When a protocol or file format requires byte-level output, use the UTF-8 Encoder / Decoder instead. The code point converter does not silently substitute UTF-8 bytes for Unicode labels, which keeps the meaning of each result clear.
The same separation applies to other syntaxes. HTML entities, JSON escapes, URL encoding, and JavaScript-style escapes each have their own rules. The output from this tool is a diagnostic code point representation, not encryption and not a universal escaping format for every programming language.
Preserve normalization differences
The converter does not perform Unicode normalization. A precomposed é can be encoded as U+00E9, while an equivalent-looking decomposed form can be encoded as U+0065 followed by U+0301. Both are valid, and they may render similarly, but they remain different scalar sequences.
That exactness helps diagnose problems involving search indexes, identifiers, filenames, copied commands, and string comparisons. Normalizing first could conceal the distinction you are trying to investigate. The converter instead exposes the sequence that was actually supplied.
Invisible values can be equally important. Revealing U+000A for a newline or U+200D for a zero-width joiner can explain unexpected cursor movement, an apparently blank difference, or text that fails an exact comparison even when it looks correct on screen.
Know the conversion limits
Input is limited to 100,000 code points so that rendering and copying remain responsive. The tool includes control characters and default-ignorable values, but it does not look up character names, scripts, confusable status, or language meaning. Those are separate Unicode properties beyond reversible scalar conversion.
It also does not validate whether a sequence is a recommended emoji or orthographic cluster. Use a dedicated Unicode data or segmentation resource when you need those additional properties. For this task, the supported workflow is to inspect or reconstruct the scalar sequence and keep the representation appropriate for the consuming system.
Use code point results with purpose
- Compare two strings that look identical but may contain different combining marks or invisible characters.
- Inspect a joined emoji or another visible symbol that is composed of multiple scalar values.
- Turn documented U+ or \u{...} values back into readable text for verification.
- Confirm the exact scalar sequence in logs, bug reports, search terms, or copied identifiers.
Choose code point notation when character identity is the question. Choose a byte encoder when a protocol or file requires UTF-8, and choose HTML, JSON, or URL tooling when the destination expects those specific syntaxes.