Unicode strikethrough text
Type Hello and get H̶e̶l̶l̶o̶: a long stroke mark is placed after each of its 5 letters, so the crossed-out look travels as plain text into chats, bios and email. The reverse option strips it back off. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Hello
- Calculation mode
- Encode
- Result
- H̶e̶l̶l̶o̶
- Mapped count
- 5
- Length
- 10
- Style
- strikethrough
Unicode combining strikethrough lets you cross out words inside ordinary chat, email, and social posts without HTML, CSS, or a special font. This capability appends the combining long stroke overlay (U+0336) after every base character so the string still pastes as plain text yet renders with a horizontal line through each letter on modern systems. Encode mode turns readable prose into struck-through form for drafts, corrections, price cuts, and playful captions. Decode mode strips combining long and short stroke marks so moderation tools, search indexes, and storage pipelines can recover the underlying wording. Existing stroke overlays are not doubled on encode, so re-running the transform on already-struck text stays clean.
How Unicode combining strikethrough works on plain text
Unicode defines combining characters that attach visually to the preceding base character instead of taking their own column as independent letters. The combining long stroke overlay at code point U+0336 is the mark most plain-text strikethrough generators use: after each base scalar, the overlay draws a horizontal line through that glyph so the whole word looks crossed out in clients that implement combining marks correctly.
This is not a font effect, not a CSS text-decoration, and not an image—it is ordinary UTF-8 that survives copy and paste into chats, bios, documents, and form fields that accept general text. A correct converter walks the string by Unicode scalar value with codePointAt so emoji and other non-BMP characters are not split into lone surrogates.
Encode mode emits each non-stroke base character followed by U+0336; if the input already contains long or short stroke overlays, those marks are skipped rather than stacked again, which keeps round-trips and re-edits stable. Decode mode removes U+0336 and also accepts the short stroke overlay U+0335 used by some other tools, writing only the base characters back out. Because the style is pure Unicode, the result pastes into plain messages where HTML strike tags or rich-text editors are unavailable or stripped.
Where Unicode strikethrough text conversion earns its keep
Writers and community managers who want to show a crossed-out price, a retracted phrase, or a playful spoiler inside platforms that strip HTML often reach for combining strikethrough because it copies as plain text and still reads as struck type on phones and desktops. Support and moderation teams paste opaque fancy messages from tickets and need a reversible path so keyword filters and ban lists can recover the underlying spelling without manual cleanup.
Product teams building caption editors, coupon generators, or draft previews can offer one-click strike styling without shipping a canvas renderer or custom webfont. Educators and localization reviewers demonstrate how combining marks attach to base letters across scripts without requiring a design tool. If you need mathematical sans-serif, cursive script, circled bubble letters, bold italic, or image-based calligraphy, treat those as separate search intents and landings rather than overloading this combining strikethrough converter page.
What you can do with it
Crossed-out prices and captions in plain chat
Turn plain phrases into Unicode strikethrough for social captions, stream titles, and chat messages where HTML strike tags are stripped but combining marks still render.
Moderation and plain-text recovery
Decode struck-through usernames and body text back to plain strings for keyword filters, search indexes, and ticket search while keeping the original glyphs for audit.
FAQ
What is Unicode combining strikethrough?
It is plain text where each base character is followed by the combining long stroke overlay U+0336, so the glyph draws with a horizontal line through it—not HTML, CSS, or a special font file.
How do I cross out plain text with this tool?
Send a non-empty string in text with mode encode (or omit mode). Each base character receives U+0336; existing stroke marks are skipped so they are not doubled.
How do I remove strikethrough marks?
Send the struck string with mode decode. Combining long stroke (U+0336) and short stroke (U+0335) overlays are stripped; base characters remain in order.
Why do some apps not show the line through letters?
A few older or minimal clients render combining marks poorly. Most modern browsers, phones, and messaging apps display U+0336 correctly as a strikethrough overlay on the previous character.
Will converting the same text twice give a double line?
No. Letters that already carry a stroke mark are skipped, so running struck-through text through the tool again leaves it exactly as it was and repeated edits stay clean.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/enc/strikethrough-unicode \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello"}'const res = await fetch("https://api.kit.forhosting.com/enc/strikethrough-unicode", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/strikethrough-unicode",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/strikethrough-unicode", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/strikethrough-unicode", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "Hello"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.strikethrough_unicode",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
How Unicode combining strikethrough works on plain text
Length is capped at a documented maximum of scalar values so a runaway paste cannot exhaust a Worker isolate.
Input contract, response fields, and error behaviour
When mode is omitted, encode is the default so a single field still produces a useful struck-through string. Encode treats text as plain or mixed content and returns result with a combining long stroke after each base character. Decode treats text as struck-through or mixed content and returns plain text with stroke overlays removed. Classic checks include encoding Hello to five base characters each followed by U+0336, decoding that string back to Hello, and rejecting an empty text field. POST a JSON object with a required non-empty string field named text and an optional mode set to encode or decode. Aliases such as input, value, data, and s are accepted for text; op, operation, and direction alias mode. Both directions echo mode and the original text, report mapped_count for base characters that received a mark on encode or for stroke marks removed on decode, and length as the scalar count of the result. Fixed labels style, combining_mark, and script identify the strikethrough profile so clients can assert which transform they hit. When encode skips existing stroke marks, marks_skipped is included with that count; when no marks were skipped, that field is omitted rather than set to null. Missing text, empty strings, non-string objects for text, unsupported mode values, and strings longer than the documented maximum fail with invalid_input and a clear English message; validation failures do not consume prepaid balance. Successful API calls bill the published base of $0.002 per item.
Integration use cases
CI fixtures for combining-mark pipelines
Generate deterministic encode and decode goldens so editors and content pipelines never disagree on combining long stroke round-trips.
Technical questions
What does the unicode strikethrough text converter cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.