Detect nearby word repetition in your writing
In the sample sentence, “final” appears at word 2 and again at word 10, exactly 8 positions apart, so a window of 8 flags it. Every finding shows both positions and the distance, ready to review. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Window size
- 8
- Word count
- 14
- Repetition count
- 1
- Flagged words
- final
Nearby word repetition can make otherwise sound writing feel accidental, monotonous, or under-edited. This check reads your text, ignores common English stopwords, and identifies meaningful words that appear again within the number of word positions you choose. Every finding includes both positions and the distance between them, giving you enough context to review the phrase without pretending that every repetition is a mistake. It is deterministic, fast, and useful for drafts ranging from short emails to longer articles.
Choose a window that matches the kind of draft
The window size defines how close two occurrences must be before the later one is flagged. Distance is counted across every word in the text, including common words that are not themselves checked as candidates. A smaller window is useful when you want to catch obvious echoes inside a sentence, such as using “report” twice within a short clause.
A larger window can reveal repeated vocabulary across neighboring sentences or a compact paragraph. There is no universally correct setting because repetition has different effects in a slogan, an email, a technical explanation, and a chapter. Start with a modest window, read each result in context, and increase it only when you want a broader stylistic sweep.
The minimum is two words; a value below two is rejected instead of being silently corrected. That explicit error protects automated editing workflows from producing misleading results when a configuration is invalid. The checker reports word positions using one-based numbering, making the findings straightforward to compare with tokenized text or another editing stage.
Understand what is counted and what is ignored
Words are matched without regard to capitalization, so “Draft” and “draft” count as the same word. Unicode letters and numbers are recognized, and apostrophes inside words are retained, which keeps common contractions together instead of splitting them into misleading fragments. A concise set of frequent English stopwords is excluded from candidacy.
Articles, conjunctions, pronouns, and similar structural words often repeat naturally, so flagging every nearby “the” or “and” would bury useful findings in noise. Those stopwords still occupy positions and therefore still affect the measured distance between meaningful words. For each qualifying recurrence, the result names the normalized word, its earlier position, its current position, and the distance.
If a word occurs several times, each later occurrence is compared with the nearest earlier occurrence. This focuses the report on the closest echo, which is usually the most relevant one during self-editing. Punctuation does not count as a word, and differences in surrounding punctuation do not prevent otherwise identical words from matching.
Use findings as editorial prompts, not automatic corrections
A repeated word is not automatically bad writing. Deliberate repetition can establish rhythm, preserve a technical term, reinforce a contrast, or avoid an ambiguous synonym. Treat every flag as a prompt to inspect the passage rather than an instruction to replace a word mechanically.
When a repetition sounds accidental, you might remove one occurrence, combine two sentences, use a precise alternative, or restructure the passage so the repeated term carries intentional emphasis. When it is necessary, leave it in place. The total word count and selected window are returned as useful audit context.
Because the algorithm uses no network, random values, or current time, identical input always produces identical output. You can run it during drafting, before publication, or as one check among several quality rules.
What you can do with it
Polish an article draft
Find accidental echoes across adjacent sentences before an editor or reader encounters them.
Review professional email
Catch distracting repeated nouns and verbs in a short message where every phrase is noticeable.
Add a writing-quality gate
Return structured repetition findings in a deterministic content review or publishing workflow.
FAQ
What does the window size mean?
It is the maximum distance in word positions between an occurrence and the nearest earlier occurrence of the same non-stopword.
Are capitalized forms treated as different words?
No. Matching is case-insensitive, so a word at the start of a sentence matches the same lowercase word later.
Why are stopwords excluded?
Common structural words repeat naturally. Excluding them keeps the report focused on repetitions that are more likely to deserve editorial attention.
Does a flag mean I must change the text?
No. Technical terms, rhetorical emphasis, and intentional rhythm can all justify repetition. Review each result in context.
If a word appears three times, which repetitions are reported?
Each later occurrence is compared with the nearest earlier one, and it is reported when that gap fits inside your window. This keeps the report focused on the closest echo, usually the one that matters most when you edit.
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/write/word-repetition-nearby-check \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"The final report explains the findings, while a short final note summarizes them.","window_size":8}'const res = await fetch("https://api.kit.forhosting.com/write/word-repetition-nearby-check", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "The final report explains the findings, while a short final note summarizes them.",
"window_size": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/write/word-repetition-nearby-check",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "The final report explains the findings, while a short final note summarizes them.",
"window_size": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/write/word-repetition-nearby-check", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"The final report explains the findings, while a short final note summarizes them.","window_size":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"The final report explains the findings, while a short final note summarizes them.","window_size":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/write/word-repetition-nearby-check", 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 final report explains the findings, while a short final note summarizes them.",
"window_size": 8
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "write.word_repetition_nearby_check",
"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. |
Technical notes
Use findings as editorial prompts, not automatic corrections
The structured output supports both manual review and automated pipelines: flagged_words provides a compact unique list, while repetitions preserves every qualifying occurrence with exact positions. API requests cost $0.002, while the same deterministic logic can also support an immediate browser-based editing experience.
Technical questions
What happens when the window size is below two?
The request returns an invalid_input error explaining that window_size must be at least two.
How much does an API request cost?
Each API request costs $0.002.