Spell Checker
Type or paste your text, commonly misspelled words are flagged instantly with a suggested correction.
About the Spell Checker
Your text gets checked against a curated list of roughly 180 commonly misspelled English words, things like "definately", "seperate", and "recieve", each flagged with a suggested correction. It isn't a full dictionary, so it won't catch every typo, unusual word, proper noun, or grammar issue, and it only handles English, so pair it with a full spell-check tool or a human editor for anything that needs to be airtight.
A lookup table of known mistakes, not a real dictionary — which cuts both ways
A dictionary-based spell checker works by checking whether a word exists in its word list at all, flagging anything it doesn't recognize as potentially wrong; this tool works the opposite way, checking whether a word matches one of roughly 180 specific, pre-known misspellings and only flagging an exact match. That means it will never catch a typo it hasn't seen before, no matter how obviously wrong — a word like "recieve" is caught because it's literally a key in the lookup table, but a novel typo like "recieved" spelled a different wrong way won't be. The upside of this approach is that it can never produce a false positive on a word it simply doesn't recognize: technical jargon, proper nouns, made-up brand names, or uncommon-but-correct words all pass through silently, since nothing about them matches a known bad spelling. A dictionary-based checker, by contrast, would flag all of those as "unknown," correct or not.
Suggested corrections don't always match your original capitalization
The lookup itself is case-insensitive — the tool lowercases whatever word you typed before checking it against the table — but the flagged word shown in the preview keeps your original capitalization, while the suggested correction is always displayed exactly as it's stored in the lookup table, which is lowercase for nearly every entry. So typing "Recieve" at the start of a sentence gets correctly flagged, and the tooltip and issue list will suggest "receive" in lowercase, even though the grammatically correct fix at the start of a sentence would keep the capital R. Worth double-checking capitalization yourself on any flagged word that started a sentence or was a title.
Apostrophes are part of a "word" for tokenizing, which is why contractions get caught correctly
The text is split into tokens using /[A-Za-z']+|[^A-Za-z']+/g, which treats a run of letters and apostrophes as a single word-like chunk, separate from everything else (spaces, digits, other punctuation). Including the apostrophe in that character class is what lets a typo like "doesnt" get checked as one unit and correctly matched against the table's "doesnt" → "doesn't" entry, rather than being torn apart into fragments around where an apostrophe should have been.
The flagged preview is rebuilt from lossless tokens, so formatting survives untouched
Because the splitting pattern captures every character in the original text into one token or another, with nothing dropped, the tool can rebuild the exact original text by concatenating the tokens back together, replacing only the ones that matched a misspelling with a styled, underlined version. That's why the "Flagged Preview" box reproduces your spacing, line breaks, and punctuation exactly as typed, with visual flags added only around the specific words that triggered a match, rather than reformatting or normalizing anything else about your text.
The whole document is re-checked on every keystroke
Rather than checking only the word you just finished typing, the entire text box is retokenized and rebuilt as fresh preview and issue-list elements on every single input event. For typical paragraph-length text this is instantaneous, and it keeps the implementation straightforward — there's no incremental state to track between keystrokes, no need to figure out which specific word changed. On a genuinely long document, this brute-force approach does mean more work happens per keystroke than a more optimized incremental checker would do, though in practice it stays responsive for anything short of an unusually large amount of pasted text.
Frequently Asked Questions
Will this catch every typo in my text?
No. It only flags words that exactly match one of roughly 180 pre-known common misspellings in its lookup table, so any typo not already in that list, along with grammar issues, unusual words, and proper nouns, will pass through unflagged.
Can this tool flag a correctly spelled word by mistake?
No, essentially never. Since it only flags exact matches against a fixed list of known misspellings, a word it doesn't recognize — jargon, a brand name, an uncommon but correctly spelled word — is simply not flagged at all, unlike a dictionary-based checker that might flag any word it doesn't have in its word list.
Why does the suggested correction show lowercase when my typo was capitalized?
The matching is case-insensitive, but the suggested correction is always displayed exactly as it's stored in the lookup table, which is lowercase for nearly every entry. A capitalized typo like "Recieve" at the start of a sentence will still suggest lowercase "receive," so you may need to re-capitalize it yourself.
Does it check contractions like "doesn't" correctly?
Yes. The tokenizer treats a run of letters and apostrophes as a single word, so a typo like "doesnt" is checked and corrected as one unit rather than being split apart around the missing apostrophe.
Is my text sent to a server when I use this tool?
No. All checking happens locally in your browser against a list built into the page; nothing is uploaded anywhere.