Skip to main content

Reference

How CleanPastedText Works

CleanPastedText editorial · Updated

Text workbench

Try it on your text

Cleaning mode

Removes hidden characters and standardizes AI-style punctuation.

Try a real example

Each sample contains a problem you cannot see.

Original

Pasted text

0 chars · 0 words

Cleaned

Ready to copy

0 changes

Text stays in this browser

Same words · No AI rewriting · No content logging

The cleaning pipeline, step by step

CleanPastedText is not an AI and does not guess. It runs your text through a fixed sequence of deterministic character rules — the same input always produces the same output, and every rule is documented here. This is the exact pipeline, in the order it runs:

  1. Detection on the untouched text. Before anything is transformed, every code point is checked against a character knowledge base. Each hit is recorded with its Unicode name, code point, and count — the census that becomes the "What changed" report. Characters whose toggle is switched off are still detected and reported as "kept," so nothing is ever invisible to you.
  2. Per-character stripping, emoji-safe. In the same pass, AI-artifact spaces (U+2000–U+200A, U+202F, U+205F, U+3000) are replaced with regular spaces; zero-width and invisible characters (U+200B, U+200C, U+200D, U+2060, U+FEFF, soft hyphen U+00AD, U+034F, Hangul fillers) are removed; bidirectional controls (U+200E, U+200F, U+061C, U+202A–U+202E, U+2066–U+2069) are removed; Unicode tag characters (U+E0000–U+E007F) and variation selectors (U+FE00–U+FE0F, U+E0100–U+E01EF) are removed outside emoji; stray control characters are removed, with line and paragraph separators (U+2028, U+2029) converted to real newlines and no-break spaces (U+00A0) to regular spaces.
  3. Unicode normalization (NFKC). The text is folded to Unicode's compatibility form: fullwidth letters become ASCII, the fi ligature becomes two letters, superscript digits become plain digits. Normalization is "shielded" so it never overrides a switch you turned off — with Keep Typography, for example, the ellipsis character survives even though NFKC would fold it to three periods.
  4. Whitespace cleanup. Windows and old-Mac line endings (CRLF, CR) are unified to LF, trailing spaces are trimmed from every line, and runs of three or more blank lines collapse to two.
  5. Typography normalization (optional). Curly quotes (U+2018, U+2019, U+201C, U+201D) and guillemets become straight quotes, en and em dashes (U+2013, U+2014) become hyphens, and the ellipsis (U+2026) becomes three periods. On in AI Clean, Safe Clean, and Plain ASCII; off in Keep Typography.
  6. Optional extras. A Strip Markdown toggle removes chat-residue formatting — heading markers, bold and italic asterisks, link syntax (keeping the link text), code fences, and blockquote markers, while list bullets are left alone. The Plain ASCII preset goes furthest: it transliterates accented letters to their base form, then deletes every remaining non-ASCII code point, emoji included. It is deliberately destructive and labeled as such.

The presets — AI Clean (the default), Safe Clean, Keep Typography, Plain ASCII — are just named combinations of these switches. The Advanced Controls panel shows every switch and lets you toggle each pass individually. Every page on this site runs this same engine, including the AI text cleaner for ChatGPT, Claude, and Gemini output — only the wording around the tool changes.

Why detection comes first

Because normalization destroys evidence. NFKC folds the narrow no-break space (U+202F) — the character famously found in ChatGPT output in April 2025 — into a plain space, so a tool that normalizes first can never tell you it was there. CleanPastedText scans the untouched input before any transformation, which is why its report can say precisely: "Narrow no-break space, U+202F, 14 found, replaced" instead of a vague total. Every row in the report carries the character's Unicode name, its code point, a count, and the action taken — removed, replaced, or kept. Detected tag characters are even decoded to show which hidden ASCII letter each one carried. That per-character census is what the ChatGPT watermark remover reports on: the same rules, aimed at the specific characters that turn up in ChatGPT output.

Transparency cuts both ways: if nothing suspicious is found, the report says so explicitly rather than staying silent. To check text without cleaning it, use the AI watermark checker; for what each detected character actually is, see the complete invisible-characters reference.

What we never do

  • No server upload. Cleaning runs entirely in your browser as client-side JavaScript. This is verifiable, not a promise: load the page, go offline, and keep cleaning. Analytics record page paths and coarse events (preset name, a size bucket like "1k-10k") — never your text.
  • No rewriting of visible words. There is no AI in the pipeline and no paraphrasing. Humanizer tools rewrite your sentences on their servers; CleanPastedText changes zero visible words unless you explicitly enable typography or Markdown passes, which only touch punctuation variants and formatting markers.
  • No silent changes. Every pass is documented on this page, and every detected character appears in the report — including the ones deliberately left alone, which are labeled "kept."
  • No signup, no paywall, no stored history. The text you clean exists only in your browser's memory and is gone when you clear it.

Why we preserve emoji

Zero width joiners and variation selectors are stripped only outside emoji sequences. The same U+200D that is baggage in ordinary prose is load-bearing inside a family emoji, and U+FE0F is what makes a heart render in emoji style — so before removing one of these characters, the engine looks backward past skin-tone modifiers and selectors to check whether it sits on a real emoji base. If it does, it is kept and reported as "kept — part of an emoji sequence." Family and profession emoji keep their joiners, hearts keep their emoji-style selector, keycaps and flag tag sequences survive — while identical characters hiding inside ordinary text are stripped.

One honest caveat: the zero width non-joiner (U+200C) inside Persian or Indic-script words is legitimate but is not an emoji, so the default presets do remove it. For text in those scripts, open Advanced Controls and switch off "Joiners (ZWNJ/ZWJ)" — that leaves every other cleaning rule active and only stops U+200C and U+200D from being stripped outside emoji. See the zero-width non-joiner reference for exactly what that character does and why. The report's "kept" labels let you verify exactly what survived. Plain ASCII is the only preset that removes emoji entirely.

Limits, honestly

  • Statistical watermarks are out of reach — for every character tool. SynthID-Text (Nature, October 2024) and the watermark Claude models carry as of August 2026 live in word choice, not characters. Cleaning cannot remove them, and we say so everywhere it is relevant. Read what a Unicode text watermark is for the full two-layer picture.
  • This is not a detector-evasion tool. AI detectors analyze wording statistics; Originality.ai's own tests found invisible characters leave AI-detection scores essentially unchanged. Cleaning removes copy-paste artifacts and trackable characters, not statistical signals.
  • Defaults favor clean prose over rare legitimate uses. Persian and Indic text that depends on U+200C, or genuinely mixed-direction text that depends on BiDi control characters, needs those passes switched off — the toggles exist, and the report shows what was kept versus removed so you can check the result.
  • Plain ASCII destroys non-ASCII text by design. It transliterates what it can (accented letters to their base form) and deletes the rest, including all emoji and non-Latin scripts. It is the right tool for legacy systems that reject Unicode, and the wrong tool for anything multilingual — which is why it is a separate, clearly labeled preset rather than the default.

Common questions

Frequently asked questions

Is CleanPastedText safe for confidential text?

Yes. The cleaner is client-side JavaScript: your text is processed in your browser's memory and never uploaded, logged, or stored on a server. You can verify this yourself — load the page, disconnect from the internet, and it keeps working. Analytics record only page paths and coarse events (like which preset was used and a size bucket such as '1k-10k characters'), never the content.

Does CleanPastedText change my words?

No. Every pass is a deterministic character rule — detect this code point, remove that one, convert this space. There is no AI, no paraphrasing, and no rewriting: the visible wording, word order, and meaning are untouched. The only visible changes are the ones you opt into, like straightening curly quotes in the typography pass or removing heading markers with Strip Markdown.

What does the AI Clean preset remove?

AI Clean, the default preset, removes zero-width characters (U+200B, U+200C, U+200D, U+2060, U+FEFF), soft hyphens, bidirectional controls, Unicode tag characters (U+E0000–U+E007F), variation selectors outside emoji, and stray control characters; converts special spaces like U+202F and U+00A0 to regular spaces; unifies line endings; and normalizes curly quotes, em dashes, and ellipses. Emoji sequences are preserved.

What does NFKC normalization do?

NFKC (Normalization Form KC) is the Unicode standard's compatibility normalization: it folds visually equivalent characters into one canonical form — fullwidth letters become ASCII letters, the fi ligature becomes the letters f and i, superscript digits become plain digits. CleanPastedText runs it after detection, so special spaces like U+202F are counted and named in the report first instead of being silently folded away.

Why does my cleaned text look identical to the input?

Because what was removed was invisible. Zero-width characters and format controls have no glyph, and special spaces look exactly like normal spaces. Check the 'What changed' report: it lists every detected character by Unicode name and code point, with a count and whether it was removed, replaced, or kept. If nothing was found, the report says that explicitly.

Can CleanPastedText make AI text undetectable to AI detectors?

No, and we say so plainly. AI detectors analyze word choice and sentence statistics, which cleaning never touches — Originality.ai's own testing found that adding or removing invisible characters left AI-detection scores essentially unchanged. Cleaning also cannot remove statistical watermarks like SynthID-Text. What it does is remove character-level artifacts and trackable hidden Unicode: hygiene and privacy, not disguise.

Continue reading

Related guides & tools