ForHosting KIT · Text & AI

Remove punctuation from text online

Strip punctuation from text with a predictable Unicode-aware filter that keeps letters, digits, spaces, tabs, and line breaks.

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Paste a sentence, paragraph, list, or multilingual passage and receive clean text without commas, quotation marks, brackets, dashes, or other non-text marks. The operation is deterministic, requires no network access, and preserves the original whitespace rather than collapsing or reformatting it. This makes the result suitable for repeatable preprocessing, indexing, comparison, and simple text analysis workflows.

Remove punctuation without changing the words

Punctuation is useful to readers, but it can get in the way when a workflow needs a simplified stream of words and numbers. This tool examines the supplied text character by character and retains Unicode letters, Unicode numbers, and whitespace. Commas, periods, apostrophes, quotation marks, brackets, dashes, slashes, and similar marks are removed wherever they occur. The remaining letters and digits stay in their original order, and whitespace is left untouched. That means existing spaces, tabs, and line breaks remain available to downstream processing instead of being silently normalized. The behavior is intentionally direct: it does not rewrite sentences, guess missing separators, change capitalization, transliterate scripts, or replace punctuation with new spaces. If two words are joined only by punctuation, removing that mark can join the words in the result. When separation matters, prepare the source accordingly or follow this operation with a whitespace-aware tokenization step designed for your specific data. Because the same rule is applied on every run, identical input always produces identical output.

Unicode-aware filtering for multilingual text

Text is broader than the English alphabet, so an ASCII-only expression would discard valid names, accented characters, and entire writing systems. The filter uses Unicode character properties to recognize letters and numbers across supported scripts. Latin letters with diacritics, Greek, Cyrillic, Arabic letters, CJK ideographs, and Unicode numeric characters can remain, while punctuation around them is removed. Whitespace is also recognized as a Unicode category, which preserves ordinary spaces as well as tabs and line breaks. Symbols that are neither letters, numbers, nor whitespace are removed too, matching the capability contract that the result contains only those retained categories. This includes decorative marks and emoji rather than treating them as letters. The tool does not perform Unicode normalization, so canonically equivalent sequences are not rewritten into a common representation. It also does not lowercase, stem, sort, deduplicate, or otherwise interpret the text. Those constraints make the result transparent: the capability filters characters and nothing more. Use a separate normalization or linguistic tool when your workflow needs equivalence rules beyond punctuation removal.

Use the result in repeatable text workflows

Punctuation-free text is useful as an intermediate representation for search indexing, lightweight word counting, identifier preparation, classroom exercises, dataset cleanup, and comparisons where punctuation differences should not matter. Send the source in the required text field and read the filtered value from the returned text field. The API price is $0.002 per request, while the browser experience can run the same deterministic logic locally. Empty input is rejected because it provides no text to process; a clear invalid-input response makes accidental omissions visible instead of returning a misleading success. Whitespace-only input is accepted and preserved because whitespace is explicitly part of the retained character set. Before using the output as a permanent identifier or security-sensitive canonical form, define additional rules for case, normalization, script handling, and collisions. Removing punctuation alone can make distinct originals produce the same result, and it may join fragments that punctuation previously separated. For ordinary preprocessing, keep the original alongside the filtered version so the source remains available for display, auditing, or later processing with different rules.

What you can do with it

Prepare text for simple word analysis

Remove punctuation before counting or comparing words while retaining the source spacing and line structure.

Clean imported labels

Filter punctuation and decorative symbols from copied labels while keeping multilingual letters and digits.

Compare punctuation-insensitive passages

Create a deterministic intermediate form when punctuation differences should not affect a later comparison.

FAQ

What does it cost?

The API costs $0.002 per request. The browser version runs the same deterministic filtering logic locally.

Which characters are preserved?

Unicode letters, Unicode numbers, and whitespace are preserved in their original order.

Does it preserve line breaks and tabs?

Yes. Whitespace is retained, including spaces, tabs, and line breaks.

Does it support accented and non-Latin letters?

Yes. It uses Unicode character properties rather than limiting letters and numbers to ASCII.

Will punctuation be replaced with spaces?

No. Disallowed characters are removed, so text separated only by punctuation may become joined.

What happens when the text is empty?

Missing text, an empty string, or a non-string value returns an invalid-input error.

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

POSThttps://api.kit.forhosting.com/text/remove-punctuation

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/text/remove-punctuation \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello, world! Room #42 is ready."}'

const res = await fetch("https://api.kit.forhosting.com/text/remove-punctuation", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "text": "Hello, world! Room #42 is ready."
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/text/remove-punctuation",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "text": "Hello, world! Room #42 is ready."
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/remove-punctuation", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"text":"Hello, world! Room #42 is ready."}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"Hello, world! Room #42 is ready."}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/remove-punctuation", 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, world! Room #42 is ready."
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "text.remove_punctuation",
  "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

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

max_tokens 20000

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.

Read the full KIT documentation →