Remove common stopwords from text online
Stopwords are frequent structural words such as articles, conjunctions, pronouns, and short prepositions.
Run — free
They are useful in ordinary writing but often add noise when you are preparing search terms, reviewing themes, or building a lightweight text-processing workflow. This tool selects a curated list from the language code you provide, tokenizes the text consistently, removes matching stopwords without changing the spelling of retained words, and returns both the cleaned text and useful counts for checking the result.
Choose the language that matches the text
Stopwords are language-specific, so the language code is part of the operation rather than a cosmetic setting. English uses words such as “the,” “is,” and “and” very frequently, while Spanish, French, German, Italian, and Portuguese have different articles, pronouns, contractions, and prepositions. Supply one of the supported two-letter codes: en, es, fr, de, it, or pt. The capability then uses only the corresponding curated list. It does not guess a language because short text can be ambiguous and a mistaken guess could silently remove meaningful terms. An unsupported code produces an explicit input error instead of falling back to English. For mixed-language material, separate the passages first and process each one with its actual code. That approach makes the result explainable and repeatable. It also prevents a common word in one language from being treated as disposable merely because it resembles a stopword in another. Keep the original text available whenever the cleaned output will inform editorial or analytical decisions.
Understand how words are selected and returned
The algorithm normalizes the input to a stable Unicode form and extracts sequences of letters or numbers, including words with an internal straight or curly apostrophe. Stopword comparison is case-insensitive, but retained tokens preserve their original spelling and capitalization. Punctuation is not included in the cleaned text because the intended output is a sequence of significant words, not a rewritten sentence. The response includes an ordered words array, the same retained words joined into a convenient text string, and counts for input words, removed words, and remaining words. Those counts make it easy to verify a batch process or measure how aggressively a stopword list affected a passage. The method is deliberately deterministic: identical input produces identical output, with no model, language detector, network request, randomness, or hidden context. A stopword list is a practical convention rather than a universal linguistic law, so review retained and removed terms when domain vocabulary matters. For example, a short common word may carry special meaning in a title, product name, quotation, or legal phrase.
Use cleaned words in practical workflows
Cleaned word sequences are useful as an early transformation, especially when a later step should emphasize subject matter rather than grammatical structure. You can feed the words into a frequency counter, compare vocabulary across documents, prepare candidate tags, inspect recurring themes in survey answers, or reduce noise in a simple search index. The output is not intended to replace stemming, lemmatization, named-entity recognition, sentiment analysis, or a full natural-language pipeline. It does not merge related word forms, decide what a word means in context, or reconstruct grammatical prose after filtering. Treat the result as a transparent feature set whose order still follows the source. For automation, validate the counts and store the language code alongside the result so the transformation can be reproduced later. API processing begins at $0.002 per item, while the browser path uses the same pure logic. Avoid presenting the joined text as a quotation because punctuation and structural words have intentionally been removed. If fidelity to a source sentence matters, use the original passage and highlight significant terms instead of replacing it with the filtered sequence.
What you can do with it
Prepare keyword candidates
Remove grammatical filler before reviewing the terms that best describe an article, note, or product description.
Compare document vocabulary
Create consistent significant-word lists before counting repeated vocabulary across several texts in the same language.
Clean survey responses
Reduce common structural words so recurring topics in short free-text answers are easier to inspect.
FAQ
Which languages are supported?
English (en), Spanish (es), French (fr), German (de), Italian (it), and Portuguese (pt). Any other code returns an input error.
Does the tool detect the language automatically?
No. You provide the language code explicitly so the operation remains predictable and does not silently choose the wrong stopword list.
Is capitalization preserved?
Yes. Matching is case-insensitive, but every retained word keeps the spelling and capitalization found in the source text.
What happens to punctuation?
Punctuation is excluded during tokenization. The result is an ordered list of significant word tokens plus a space-joined text value.
Does this perform stemming or lemmatization?
No. It removes listed stopwords only; it does not combine word forms, infer roots, or analyze grammatical roles.
How much does API processing cost?
API processing starts at $0.002 per item. The capability also has a browser execution path using the same deterministic logic.
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/text/remove-stopwords \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"The quick brown fox jumps over the lazy dog and runs into the forest.","language":"en"}'const res = await fetch("https://api.kit.forhosting.com/text/remove-stopwords", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "The quick brown fox jumps over the lazy dog and runs into the forest.",
"language": "en"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/remove-stopwords",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "The quick brown fox jumps over the lazy dog and runs into the forest.",
"language": "en"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/remove-stopwords", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"The quick brown fox jumps over the lazy dog and runs into the forest.","language":"en"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"The quick brown fox jumps over the lazy dog and runs into the forest.","language":"en"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/remove-stopwords", 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": "The quick brown fox jumps over the lazy dog and runs into the forest.",
"language": "en"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.remove_stopwords",
"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_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. |