Invisible character detector

Paste text, press one button, and see every code point that renders as nothing — where it sits, what it is called, and what it might be carrying.

Last updated 8 October 2026

In one line

An invisible character detector shows you the code points that occupy no width on screen. Paste text below and this page names every one of them, says where each one sits, and decodes any message hidden inside a run of Unicode tag characters.

Check your text

The text is read in your browser. There is no upload, no account and no queue, so the answer arrives as soon as you press the button.

Hidden-character check

offline · local only

0 chars

Try a sample:

Tip: press ⌘↵ to run. Nothing leaves this device.

Paste some text above, or pick a sample under the box.

What counts as an invisible character

“Invisible character” is a description, not a Unicode category. It covers every code point that occupies no width, or that occupies width without showing a glyph of its own. This detector looks for the ranges below, which are the ones that turn up in real documents.

The ranges this detector classifies
Character	Code points	What it does
Zero-width characters	`U+200B`, `U+200C`, `U+200D`, `U+2060`	Take no space and draw nothing. The usual way to stamp a per-copy fingerprint on a document.
Byte-order mark	`U+FEFF`	A file signature that leaks into the middle of a string, where it is invisible and meaningless.
Unicode tag characters	`U+E0000`–`U+E007F`	A direct copy of printable ASCII in an invisible plane. Carries a whole hidden message, which this page decodes.
Variation selectors	`U+FE00`–`U+FE0F`, `U+E0100`–`U+E01EF`	Legitimate for emoji presentation; a documented way to smuggle bytes past a filter when used in a long run.
Direction overrides	`U+202A`–`U+202E`, `U+2066`–`U+2069`	Change the order text is drawn in, so what you read is not what the bytes say. The mechanism behind Trojan Source.
Look-alike letters	Cyrillic, Greek, fullwidth ranges	Render as Latin letters but are different code points, so a domain or a function name can read one way and resolve another.
Private-use and noncharacters	Plane 15 and 16, `U+FDD0`–`U+FDEF`	Have no agreed meaning at all, which makes them a free channel for anything.
Odd whitespace	Non-breaking space, ideographic space, thin space	Visible as a gap, but not the space your code, your search or your validation expects.

Why invisible characters cause real trouble

A string stops equalling itself. Paste a value with a zero-width character into a form and it will not match the same value typed by hand. The error message names nothing, because there is nothing to see.
A search stops matching. Full-text search, a database index and a grep all compare code points, not appearance. One invisible character in the middle of a word is enough to hide it.
A document identifies its reader. Encode an account number as a pattern of zero-width characters and every copy carries a name. This is the oldest use of the technique, and it is why a per-copy fingerprint is the first thing to look for.
Instructions hide inside content. A run of tag characters renders as nothing and reads as a sentence to a language model. Text that instructs a model to ignore its rules can sit in a document that looks empty at the end.
Code reads differently than it runs. A bidirectional override in source code makes a reviewer approve one order of operations while the compiler sees another.

The characters are not always hostile. Word processors, PDF exports, content management systems and copy-paste from a web page all introduce them by accident. What matters is that they are invisible, so a clean-looking result is not evidence that nothing happened.

How to read the result

The verdict line gives the highest severity found. A clean verdict means no code point in the text matched the ranges above. It does not mean the text is free of a watermark; statistical watermarks are invisible to every tool that runs outside the model provider.
The position strip shows where the hidden characters sit, as a share of the whole text. A single dense block in an otherwise ordinary paragraph is the shape a fingerprint makes.
The list names each code point, its category and its position. This is the part to read before deciding anything: U+200B in a copy-pasted invoice is ordinary, and the same character repeated every forty words is not.
The recovered payload appears only when the text carries tag characters or a variation-selector run. Tag-character decoding is exact. Variation selectors have no official payload, so that decoding is offered as a lead, not as proof.

If you want the clean version rather than the list, the invisible character remover runs the same check and hands you a copy with those code points taken out.

What this detector cannot tell you

Whether the text was written by a model. We inspect the bytes, not the style. There is no reliable answer to that question, and a tool that returns a confident percentage for every paragraph is returning a guess dressed as a measurement.
Whether a statistical watermark is present. Google’s SynthID and schemes like it are biased into the model’s sampling, so reading one needs the key that wrote it. The SynthID page sets out what Google’s own detector covers, and why it does not read text.
Who put the characters there, or why. A finding is a fact about the bytes. Intent is not in the bytes.
What was removed before you got the text. A chat window, a CMS and a copy-paste step all strip characters silently. A clean result describes this copy, not the original.

Where else this runs

The AI watermark detector homepage runs the same engine on text and adds a check for image provenance metadata — C2PA Content Credentials, EXIF, XMP and IPTC.
The invisible character remover is the same check, with a cleaned copy as the output instead of a list.
Google’s SynthID Detector answers the pixel-level question for images, video and audio. It is a different job, and the SynthID page explains where the boundary sits.