Remove control characters
Delete the invisible control characters hidden in a paste: Hello, a null byte, World, a bell and an exclamation mark become HelloWorld!, with 2 characters removed. Spaces, tabs and line breaks are kept. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Hello World!
- Text
- HelloWorld!
- Original
- Hello World!
- Length
- 11
- Removed
- 2
This remove-control-characters tool takes any non-empty text string and returns the same content with non-printing control characters deleted. Ordinary spaces, tabs, and newlines stay in place so paragraph structure and readable spacing survive the cleanup. The engine is fully deterministic: one fixed Unicode-range deletion pass, no network calls, no randomness, and no clock dependency. Letters, digits, punctuation, and printable Unicode symbols keep their relative order; only invisible C0 controls (except tab, LF, and CR), the DEL character, and C1 controls disappear.
What counts as a control character
Control characters are codes that do not print anything, yet they often break parsers, logs, databases and copy-and-paste workflows. This tool deletes the whole first block of those codes except the three you almost always want to keep, tab, line feed and carriage return, and it also deletes the delete character and the second block of control codes left behind by old encodings. Ordinary spaces are never removed, and letters, digits, punctuation and printable symbols keep their order. In the example, Hello, a null byte, World, a bell and an exclamation mark become HelloWorld!, eleven characters with two removed.
Where they come from and when to clean them
Invisible codes usually arrive with pastes from serial consoles, industrial control exports, old mainframe downloads or text that went through an outdated editor. The text looks fine on screen, yet a ticket system rejects it, a search index stumbles, or a database or message queue silently cuts the value at an embedded null byte. Old encoding bytes also break content feeds and make sorting look strange. Clean the text before you load, index or publish it. Keep in mind that this cleanup is narrow on purpose: it does not touch tabs or line breaks, accents or HTML, so use other cleanup steps when you also need those changes.
Control-character removal in this capacity means deleting code points that do not print and that often break parsers, logs, databases, and copy-paste workflows. The engine strips the C0 control block except the three whitespace controls you almost always want to keep: horizontal tab (U+0009), line feed (U+000A), and carriage return (U+000D). It also strips DEL (U+007F) and the entire C1 control block (U+0080 through U+009F).
Ordinary space (U+0020) is never removed. Hello followed by a null byte and World becomes HelloWorld; a two-line note with a bell character between words keeps its newline and loses only the bell. There is no option to also strip spaces, no mode that collapses runs of whitespace, and no silent coercion of null into an empty success.
Where scrubbing control characters fits in data hygiene, publishing, and software
Students meet control-character cleanup when a coding lab imports CSV or log samples that contain null bytes, form feeds, or escape sequences left over from terminal dumps. Teachers can pre-generate answer keys that show the expected clean form without trusting opaque office macros that rewrite line endings differently on each machine. Data engineers use the same contract to sanitize fields before loading warehouses, search indexes, or message queues that reject or silently truncate on embedded NUL.
Support and operations teams paste noisy multi-line ticket fragments from serial consoles, SCADA exports, or legacy mainframe downloads and need readable text without invisible codes that break ticket systems. Publishers and CMS editors scrub pasted content that looks fine on screen but carries C1 bytes from old encodings, preventing broken feeds and odd sorting. Pair it with remove-whitespace, remove-accents, or HTML sanitize tools when you are building a small lab of free, deterministic text helpers for forms, CMS prep, and data hygiene.
What you can do with it
Clean binary-tainted imports
Strip null bytes, bell, and other C0/C1 controls from CSV, logs, or exports copied out of binary or legacy systems while keeping readable spaces and line breaks.
Ticket and CMS paste hygiene
Remove invisible control codes from console dumps and old-editor pastes so tickets, search, and content systems accept the text cleanly.
FAQ
What does the remove-control-characters tool cost?
It is free in your browser on this page.
Which characters are removed?
C0 controls except tab, line feed, and carriage return; DEL (U+007F); and C1 controls (U+0080–U+009F). Spaces and printable text are kept.
Are spaces and newlines preserved?
Yes. Ordinary space, tab, LF, and CR are never deleted. Only non-printing control characters outside that set are removed.
What happens if the text field is empty?
You must provide a non-empty string; blank form fields do not become silent successes.
Is the result the same every time?
Yes. The transform is a pure, deterministic character deletion with no network, randomness, or clock dependency, so identical input always yields identical output.
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/str/remove-control-chars \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello\u0000World\u0007 — line two"}'const res = await fetch("https://api.kit.forhosting.com/str/remove-control-chars", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello\u0000World\u0007 — line two"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/remove-control-chars",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello\u0000World\u0007 — line two"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/remove-control-chars", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello\\u0000World\\u0007 — line two"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello\u0000World\u0007 — line two"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/remove-control-chars", 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\u0000World\u0007 — line two"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.remove_control_chars",
"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.
Limits
max_chars | 100000 |
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
Empty input is rejected with a clear invalid_input error so a blank form field cannot become a silent empty success. Use it free in the browser when you paste noisy exports from legacy systems, serial logs, or binary-tainted files, or call the API at $0.002 per successful request when you need reproducible scrubbing in CI, ETL pipelines, or teaching demos.
What control-character removal means and what the response contains
The response is intentionally small and stable: text holds the cleaned result you will copy or store, original echoes the exact input so you can audit what changed, length reports the character count of the result, removed counts how many control characters disappeared (original length minus result length), and method is the fixed tag remove_control_chars for logs and multi-tool pipelines. The engine either builds a complete cleaned string inside the supported length or rejects the request with invalid_input. Rejected cases include a missing text field, a null value, an empty string, objects and arrays that are not plain text, and any payload longer than the documented maximum character count.
How the text field is read and how the result stays reproducible
The value must be a non-empty string; finite numbers and bigints are stringified first so a bare product code typed as a number still processes cleanly after conversion to decimal digits. Conversion uses a single regular-expression replace that matches only the documented control ranges—no locale tables, no machine-learning model, and no date-dependent exceptions. The preferred field is text, but aliases input, string, value, content, and s are accepted so query strings, spreadsheets, and typed forms can reuse the same contract without renaming columns. Booleans, plain objects, and arrays are rejected with a clear message so a mistaken JSON body does not become the word true or an unhelpful object dump. Empty string is always invalid_input: the product promise is transform text, not invent a blank success from a missing field. Length is capped at one hundred thousand characters so a runaway paste cannot monopolize a Worker; longer payloads fail with an explicit limit message rather than a truncated silent cut. Pair the free browser run on this page with the priced API when you need the identical scrubbed string inside an automated pipeline without shipping your own control-strip helpers.
Where scrubbing control characters fits in data hygiene, publishing, and software
On this page the work runs entirely in your browser; through the API each successful conversion costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split—free interactive exploration and a priced, identical API—matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the string result.
Integration use cases
Deterministic pipeline fixtures
Generate reproducible control-free strings for unit tests, golden files, and CI assertions on ingest and sanitize logic.