A safe char code lookup is a local Unicode inspection workflow that turns text into explicit U+ scalar-value labels and rebuilds text only from validated U+XXXX or \u{...} tokens. The Unicode Encoder / Decoder performs both directions in your browser, so pasted text can be examined without sending it to a remote lookup service. It is built for a precise task: reveal which abstract Unicode values a string contains, including spaces, control characters, default-ignorable characters, and each part of a joined emoji sequence. Encoding emits uppercase U+ labels with a four-digit minimum, while supplementary characters retain their full value instead of being split into UTF-16 surrogate halves. Decoding accepts prefixed tokens separated by spaces, commas, or line breaks, and rejects missing prefixes, invalid hexadecimal, surrogate values, and numbers outside the scalar range before constructing output. That makes the workflow suitable for checking copied strings, diagnosing exact-comparison failures, and reading code-point notation in logs or source code. It does not normalize text, identify character names or scripts, or guarantee that a sequence is a recommended emoji or complete grapheme cluster. “Safe” here refers to local processing and explicit validation, not to judging whether the text itself is trustworthy.
What makes the lookup safe and exact
A safe character-code workflow should address both data handling and technical correctness. The conversion runs locally in the browser, while decode mode validates every token before it creates the output text. This avoids a common failure pattern in which malformed input is quietly replaced with another character and the resulting string appears plausible even though it is wrong.
| Concern | Tool behavior | Practical effect |
|---|---|---|
| Text handling | Conversion runs locally in the browser | The pasted string does not need to be sent to a remote conversion service |
| Encoding accuracy | Text is iterated by Unicode scalar value | A supplementary character remains one value rather than two UTF-16 surrogate halves |
| Decode accuracy | Every token passes validation before output is constructed | Invalid hexadecimal, missing prefixes, surrogates, and out-of-range numbers are rejected |
| Diagnostic visibility | Control and default-ignorable code points are included | Hidden line breaks and zero-width characters become visible in the U+ sequence |
The implementation is checked with eight standards-backed fixtures covering ASCII, Latin accents, CJK, supplementary emoji, mixed basic and supplementary text, a musical symbol, a newline, and a joined emoji sequence. Separate checks reject surrogate and out-of-range values, avoiding a round trip that appears consistent while using the wrong surrogate convention.
Convert text into explicit code points
- Choose text-to-code-points mode. This is the direction that starts with the exact string you want to inspect and produces a sequence of Unicode code-point labels.
- Paste the exact Unicode string into the input area. Include invisible content such as spaces, tabs, line breaks, zero-width characters, and any joiners rather than cleaning or normalizing it first.
- Run the conversion. The tool walks the text by Unicode scalar value and formats each value as an uppercase U+ label with at least four hexadecimal digits.
- Inspect the labels in order. A basic character receives the padded form A as U+0041, while the supplementary character 😀 remains one scalar value shown as U+1F600.
- Copy the U+ sequence when you need to record, compare, or share the diagnostic representation. Keep the token boundaries intact if you later enter the values in decode mode.
Copying the original value is important during troubleshooting because visually similar text can contain different sequences. A newline is exposed as U+000A, and a zero-width joiner appears as U+200D rather than disappearing from the result. These details can explain unexpected cursor movement, an invisible difference between two strings, or a failure in an exact comparison. The representation is deliberately diagnostic: it tells you which scalar values are present without changing their order or applying Unicode normalization.
Decode code-point notation without silent replacement
- Switch to decoding mode so the input is interpreted as code-point tokens rather than ordinary text.
- Enter tokens that begin with U+ or use JavaScript-style backslash-u notation. Brace notation can represent supplementary values, such as U+1F600 or \u{1F600}.
- Separate tokens with spaces, commas, or line breaks. These separators preserve the boundary between adjacent values, which is important when several hexadecimal labels appear together.
- Start the conversion and inspect the text only after every token has passed validation. The output text is constructed only when the complete input is valid.
Valid Unicode scalar values extend from U+0000 through U+10FFFF, except the range U+D800 through U+DFFF. That excluded interval contains UTF-16 surrogate code units used in pairs; it does not identify standalone Unicode characters. The decoder therefore rejects surrogate values, out-of-range numbers, missing prefixes, and non-hexadecimal tokens instead of silently replacing them. Hexadecimal digits are case-insensitive.
| Accepted notation | Example | What it represents |
|---|---|---|
| U+ with hexadecimal digits | U+0041 | A basic Unicode scalar value |
| U+ with a full supplementary value | U+1F600 | The complete 😀 scalar value |
| Brace notation | \u{0041} | The same scalar value in JavaScript-style notation |
| Brace notation for supplementary values | \u{1F600} | The complete 😀 scalar value without surrogate halves |
Internally, the tool calls the platform’s ECMAScript String.fromCodePoint only after validating the scalar range and excluding surrogates. That order prevents an invalid code unit from being turned into text through a permissive replacement path.
Separate scalar values from visible symbols
A Unicode code point is not always the same thing as a character a person perceives. The emoji 👩💻 contains three scalar values: U+1F469 for the woman, U+200D for the zero-width joiner, and U+1F4BB for the laptop. The tool exposes that sequence, but it does not claim to segment grapheme clusters or decide whether a sequence forms a recommended emoji. Many flags, family emoji, accented forms, and writing systems also combine several code points into one visible presentation.
Normalization is intentionally not performed. A precomposed é can appear as U+00E9, while an equivalent-looking decomposed form can appear as U+0065 U+0301. Both sequences are valid, and they may render alike, yet they remain different when the tool reports their scalar values. Keeping that distinction can help diagnose problems involving search terms, identifiers, filenames, and exact string comparisons.
For a conceptual explanation of the difference between values and visible text, see Char Code Lookup Explained: What Code Points Reveal. For direct inspection, the encoder remains the practical choice because it preserves control characters and default-ignorable code points instead of hiding them during an apparently clean display.
Choose the representation required by the destination
A U+ sequence describes abstract Unicode scalar values. It is not automatically a byte encoding, HTML entity, URL escape, JSON escape, or universal programming-language escape. Those formats have different syntaxes and rules, so use the representation required by the system that will consume the text.
| Representation | Example | Correct use |
|---|---|---|
| U+ code-point label | U+00E9 | Inspecting the Unicode scalar value for é |
| JavaScript-style notation | \u{00E9} | Reading or entering scalar notation accepted by the decoder |
| UTF-8 bytes | C3 A9 | Protocols and file formats that require byte-level encoding |
| HTML entity | é | HTML markup that specifically requires entity syntax |
| JSON escape | \u00E9 | A JSON string’s required escape form |
| URL encoding | a%20b | Percent-encoding within a URL or query value |
For byte-level work, use the related UTF-8 Encoder / Decoder rather than interpreting U+ labels as bytes. The U+ output remains the diagnostic representation for character identity. It is not encryption, and it is not intended to replace every programming language’s escaping mechanism.
Know the boundaries before relying on the result
The input limit is 100,000 code points per conversion. Longer strings must be divided into smaller chunks, with the chunk boundaries recorded so the scalar sequence can be reconstructed accurately. The limit is expressed in code points rather than visible symbols, which means a string containing joined emoji can reach the limit sooner than its appearance suggests.
The tool does not look up character names, scripts, confusable status, or language meaning. It also does not validate recommended emoji sequences or orthographic clusters. Those properties require separate Unicode information. Use this workflow when the concrete question is which abstract scalar values a string contains, then consult the relevant standard or property source if you also need names, script classification, or grapheme analysis.
Related reading: UTF8 Decode Example: From Bytes to Unicode Text.