{{ summaryTitle }}
{{ summaryValue }}

{{ summaryLine }}

{{ badge.label }}{{ badge.value }}
Choose a pinned mode when digits, backslashes, or percent bytes could be ambiguous.
Examples: ✓, U+2713, %E2%9C%93, \\2713, or \\u{1F469}\\u200D\\u{1F4BB}.
Custom leaves the current input unchanged.
None is neutral. NFC, NFD, NFKC, and NFKD expose representation changes.
Turn this on when the inspected value may leave a controlled system.
{{ restrictedFlagsEnabled ? 'On' : 'Off' }}
Turn this on when debugging pasted identifiers, source, or interface text.
{{ invisibleFlagsEnabled ? 'On' : 'Off' }}
  • {{ note }}

The chart renderer is unavailable. The exact counts remain in the reference and exported JSON.

TargetOutputUseCopy
{{ row.target }}{{ row.output }}{{ row.note }}
FormPreviewU+ChangeCopy
{{ row.form }}{{ row.preview }}{{ row.code_points }}{{ row.change }}
#PreviewNameU+TypeScriptCopy
{{ row.position }}{{ row.preview }}{{ row.name }}{{ row.u_plus }}{{ row.type }}{{ row.script }}
HTML Entity Lookup Look up an HTML entity or Unicode value, then compare named and numeric forms with context-safe escapes for copying into markup and code.
HTML Unescaper Decode escaped HTML text or small local files with multi-pass reference tracking plus strict review, Unicode normalization, and safety signals.
Uniform Resource Locator (URL) Decoder Decode percent-encoded URLs or text, inspect characters and query structure, and clean trackers or duplicate parameters without fetching the destination.
Uniform Resource Locator (URL) Encoder Encode URL components, complete links, form values, or paths with context-aware percent escapes, UTF-8 byte details, and local query checks.

A character that looks ordinary can have several valid machine representations. The visible letter é may be one code point or a sequence containing e followed by a combining accent. An emoji may join several people, objects, modifiers, or variation selectors into one visible symbol. A space-like mark may occupy no visible width at all.

Unicode assigns code points, written in forms such as U+2713, but code points are not bytes and do not always match what a reader counts as one character. UTF-8 encodes a scalar value as one to four bytes. UTF-16 uses one 16-bit code unit for values in the Basic Multilingual Plane and a surrogate pair for supplementary values. Text editors, programming languages, style sheets, HTML, and URLs then add their own escape syntax around those values.

Code point
A numbered Unicode value from U+0000 through U+10FFFF.
Unicode scalar value
A code point outside the surrogate range U+D800 through U+DFFF.
Grapheme cluster
A sequence that people usually perceive as one character, even when it contains several code points.
Normalization
A defined conversion between canonically or compatibly related code-point sequences.

These distinctions explain many “looks the same but does not match” bugs. Database keys can differ after a composed/decomposed change. An invisible format character can survive copying. A private-use character can display correctly only with the originating font or application agreement. A lone surrogate can exist in a UTF-16-oriented runtime yet cannot be encoded as well-formed UTF-8.

Normalization helps compare or standardize text, but it is not a security filter. NFC and NFD preserve canonical equivalence while choosing composed or decomposed forms. NFKC and NFKD also apply compatibility mappings, which can change distinctions that matter to identifiers, source code, or specialized notation.

How to Use This Tool:

Choose a pinned interpretation when digits, backslashes, or percent bytes could be read more than one way.

  1. Select Interpret input as. Auto detect is convenient for obvious values; use a specific code-point, JavaScript, CSS, or percent-UTF-8 mode when syntax is ambiguous.
  2. Enter one literal grapheme or an explicit sequence. Code-point notation accepts forms such as U+2713, 0x2713, decimal values, and numeric HTML references.
  3. Choose NFC, NFD, NFKC, or NFKD only when a normalization comparison is needed. None leaves the inspected sequence unchanged.
  4. Run Inspect character, then compare the U+ sequence, encoding units, normalization rows, and any review notes before copying a representation.

Interpreting Results:

The U+ sequence is the clearest portable identity for diagnostics. Use the literal preview only as a visual clue because fonts can hide missing glyphs, combining behavior, or format controls. Compare UTF-8 bytes when investigating files, network payloads, or percent encoding; compare UTF-16 units when debugging JavaScript strings or systems that expose surrogate pairs.

  • A normalization row marked Changes source means the code-point sequence changes, even if the rendered text looks the same.
  • Private use is valid only under an external agreement about meaning and rendering.
  • Control, Format, and Whitespace values may disappear in a visual comparison.
  • A property name from fallback data may be generic. Confirm unusual or correctness-critical values against the Unicode Character Database.

Technical Details:

Input is limited to 256 UTF-16 code units. Explicit and escaped forms can inspect from 1 to 32 code points in one run. Literal mode selects the first detected grapheme and reports when later graphemes were ignored, preventing an accidental paragraph paste from becoming one oversized audit.

Transformation Core:

Input formParsing ruleIntermediate result
Code-point tokensU+, hexadecimal, decimal, JavaScript code-point, or numeric HTML notationInteger code points from 0 through 0x10FFFF
JavaScript or JSON escapes\u{...} uses 1–6 hex digits, \u.... uses exactly 4, and \x.. uses exactly 2A decoded string
CSS escapesA backslash plus up to 6 hex digits; one following whitespace character terminates the escapeA decoded string
Percent-encoded UTF-8Every token must be a percent sign followed by two hex digits, and the byte sequence must decode as UTF-8Unicode scalar-value text
Literal textThe first practical grapheme segment is retainedOne cluster and any ignored remainder

Auto detection tests percent bytes first, then explicit code-point tokens, JavaScript escapes, CSS escapes, and finally literal text. Pinning a mode removes that guess. The local grapheme routine groups combining marks, variation selectors, emoji skin-tone modifiers, regional-indicator pairs, and zero-width-joiner chains; it is a practical inspector heuristic and does not cover every rule in Unicode Standard Annex #29.

Encoding Core:

UTF-8 encodes scalar values by numeric range. Surrogate code points are excluded because they are reserved for UTF-16 code-unit pairs rather than Unicode scalar values.

Code-point rangeUTF-8 bytesUTF-16 representation
U+0000–U+007F1One code unit
U+0080–U+07FF2One code unit
U+0800–U+FFFF, excluding surrogates3One code unit
U+10000–U+10FFFF4High and low surrogate pair

Copy targets are derived from the same resolved sequence: literal text, U+ and decimal values, JavaScript, JSON, CSS, HTML numeric references, UTF-8 bytes, percent-encoded UTF-8, UTF-16 units, and UTF-32 units. If a lone surrogate is present, UTF-8 and HTML scalar-value outputs are marked unavailable instead of substituting a replacement character.

Normalization Core:

FormCompositionEquivalence applied
NFCComposed where definedCanonical
NFDDecomposedCanonical
NFKCComposed where definedCanonical and compatibility
NFKDDecomposedCanonical and compatibility

Privacy and Accuracy Notes:

The entered text is parsed in the browser. Unicode name and property data is loaded after inspection begins, but the inspected value is not included in that request. If the reference data does not load within the short wait, a small built-in reference and browser property tests supply fallback labels.

  • Fallback coverage is intentionally limited, so an uncommon character may receive a generic name or approximate script/category label.
  • Font rendering can make different sequences look alike or make a valid character appear missing.
  • Invisible and internal-only warnings are optional review aids, not a complete spoofing or source-code security analysis.

Worked Examples:

Composed and decomposed acute accent

The precomposed U+00E9 and the sequence U+0065 U+0301 can render as the same letter. NFC composes the second form where possible; NFD decomposes the first. Comparing U+ sequences reveals the difference that a visual check can miss.

Joined emoji sequence

U+1F469 U+200D U+1F4BB contains a woman, a zero-width joiner, and a computer. It may render as one emoji grapheme while still occupying three code points, eleven UTF-8 bytes, and five UTF-16 code units.

References: