Text
Word & Character Counter, Case Converter
Count words and characters, convert text case, and find and replace text — all in your browser.
Runs entirely in your browser — nothing you paste is uploaded or stored.
What is word counter?
A word counter measures the size and shape of a piece of text — words, characters, sentences, paragraphs, and how long it will take to read or speak aloud — so you can check a draft against a limit before you submit it. This tool goes further than a plain count: it also converts the text between nine common casing styles (from UPPERCASE and Title Case to identifier styles like camelCase and snake_case), and includes a find-and-replace panel that highlights every match live as you type. A separate "Sentence case (beta)" button combines a small NLP library's built-in name/place/organization list with a small on-device AI model to guess which words are proper nouns, so it can capitalize sentence starts without lowercasing "Paris" or "Google" along with everything else; it underlines any word neither signal was confident about, and clicking an underlined word toggles its capitalization, so you can fix a wrong guess in one click instead of retyping it. Everything runs locally in your browser via WebAssembly — the text you paste or drop in is never uploaded anywhere.
When to use it
- Checking a tweet, meta description, or form field against a hard character limit before submitting it.
- Estimating how long a blog post, script, or presentation will take to read or speak aloud.
- Converting a phrase into camelCase or snake_case for a variable name, or into kebab-case for a URL slug.
- Cleaning up pasted text by finding and replacing a repeated typo, placeholder, or inconsistent term across a whole document.
- Spotting overused words in a draft using the most-frequent-words list before a final edit pass.
How to use this tool
- Paste or type your text into the box, or drag a .txt file onto it — stats update live as you go.
- Read the stats row for word, character, sentence, paragraph and line counts, plus estimated reading and speaking time.
- Click a case button to convert the text in place — prose-style cases (UPPERCASE, lowercase, Title Case) keep your original spacing, while identifier-style cases (camelCase, snake_case, and the rest) rebuild the text as a single token per word, the way those formats work everywhere else.
- Click "Sentence case (beta)" for a smarter, AI-assisted conversion that tries to keep proper nouns capitalized — review any word it underlines, since automatic proper-noun detection is a best-effort guess, not a guarantee; click an underlined word to toggle it between capitalized and lowercase.
- Tick "Find & replace" to search the text — matches highlight live below the box — then fill in a replacement and click "Replace all".
- Click "Copy report" to copy a plain-text summary of every stat, ready to paste into an email or ticket.
Example
Running the counter on a short two-paragraph sample.
Input
The quick brown fox jumps over the lazy dog. Pack my box with five dozen liquid jugs!
Word Counter runs entirely in your browser — nothing you type is ever uploaded. Try the case buttons below, or search for a word to see it highlighted.Output
44 words · 238 characters (193 without spaces) · 4 sentences · 2 paragraphs
Reading time: ~14s · Speaking time: ~18sThe two pangram-style sentences pack in most of the alphabet, which is why the syllable and average-word-length stats look a little higher than typical prose.
Prose casing vs. identifier casing
The nine case options split into two groups that behave differently, and it’s worth knowing
which is which before you click one. UPPERCASE, lowercase, and Title Case are “prose” cases —
they change the letters and leave everything else, including your line breaks, alone. The
other six — camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, and dot.case — are
“identifier” cases borrowed from programming and URL conventions, where a name is always a
single unbroken token. Converting to one of these treats each word in your text as a
component of that token and joins them with the target style’s separator (or no separator at
all, for camelCase and PascalCase). Converting an already-cased identifier — helloWorldExample
back to snake_case, for instance — works too: the tool recognises the existing camelCase
boundaries and re-splits on them before rejoining.
How Sentence case works
Prose casing (UPPERCASE, lowercase, Title Case) is a pure mechanical transform — every
letter’s target case follows directly from the rule, no judgment required. Real sentence
case isn’t: deciding whether to keep a word capitalized means deciding whether it’s a name,
a place, or a brand, and no dictionary-free rule can make that call correctly. Sentence case
(beta) combines two independent signals to make that judgment automatically, loaded only if
you click the button:
compromise (MIT licensed), a small
natural-language-processing library whose built-in name/place/organization list works even
on text that’s already all-caps or all-lowercase; and a small transformer-based AI model
(an Apache-2.0-licensed, on-device port of dslim/distilbert-NER) that adds genuine
contextual understanding for names outside that list, run through WebAssembly the same way
this site’s Background Remover and Face & Plate Blur run their own models — nothing is ever
uploaded. It’s still a best-effort guess rather than a guarantee; see the FAQ below for
exactly where it can go wrong and how the tool flags its own uncertainty.
Why a browser-only tool
Word counts are often run on drafts that aren’t finished yet — a document under legal review, a private message, an unpublished manuscript. Running entirely client-side means there’s no version of this tool that could log or retain that text, by accident or otherwise, because it never leaves your machine.
Frequently asked questions
Why does converting to camelCase or snake_case strip out my spacing, but Title Case doesn't?
Prose-style cases — UPPERCASE, lowercase, and Title Case — transform each word in place and leave your original spacing, line breaks, and punctuation exactly where they were. Identifier-style cases — camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, and dot.case — have no concept of whitespace at all in the contexts they're actually used (variable names, file names, CSS classes), so converting to one of them rebuilds the text as a single run of joined words, the same way it would look in real code.
How accurate is the reading time estimate?
It's based on 200 words per minute, a commonly cited average for adult silent reading of straightforward text. Actual reading speed varies a lot by reader, familiarity with the subject, and text complexity, so treat it as a rough guide rather than a guarantee — useful for comparing two drafts, less useful as a precise promise to a reader.
How is the syllable count calculated?
By counting groups of consecutive vowels in each word and applying a couple of standard adjustments, such as dropping a silent trailing "e". It's a heuristic, not a dictionary lookup, so it will occasionally be off by one on irregular words — but it's accurate enough for the readability estimates most people use it for.
Is my text uploaded anywhere when I use this tool?
No. Every count, case conversion, and find-and-replace runs in your browser's own JavaScript engine. Nothing you type, paste, or drop as a file is ever sent to a server — you can confirm this yourself by opening your browser's DevTools Network tab while using the tool.
Does find and replace support regular expressions?
No — it's a literal, exact-text search with an optional case-sensitivity toggle, which covers the common case of fixing a repeated typo or swapping one term for another. If you need pattern-based matching with capture groups, the Regex Tester on this site is the dedicated tool for that.
How does Sentence case handle names, places, and other proper nouns?
It combines two signals. A small natural-language-processing library carries a built-in list of known names, places, and organizations — it recognizes those regardless of how your text was originally capitalized, but anything outside that list is just a capitalization guess. A small AI model then adds real contextual judgment on top, which can occasionally catch an uncommon name even when it wasn't capitalized in your original text, by reading the surrounding sentence — though it works best when your text is already reasonably capitalized. Either signal being confident is enough to capitalize a word with no flag; if neither is confident, it's still capitalized as a guess but underlined for review. This is fundamentally best-effort, not a lookup you can fully trust — an uncommon name, a brand neither signal recognizes, or an ordinary word that happens to be capitalized (like "Fox" mid-sentence) can still be misjudged. Click an underlined word to flip it to lowercase (or click again to restore the guess) instead of retyping it.
Find these tools useful? A coffee helps keep them free and ad-light.
Buy me a coffee