Word & Character Counter

What Is a Word Counter?

A word counter measures the length of a piece of text: how many words, characters, sentences, paragraphs, and lines it contains. This one also estimates how long the text takes to read and to say out loud, and it lists the words you repeat most. The numbers update on every keystroke, so you can trim a draft and watch them fall as you edit. All of the counting runs in JavaScript in your browser, and the text you paste is never uploaded.

Developers need one more often than you’d expect: checking a meta description before a deploy, keeping a commit subject under 50 characters, fitting App Store copy into a 30-character field, or sizing a conference talk before building the slides.

How to Use the Word Counter

1. Paste or type your text into the input box. There’s no button to press, because every statistic updates as you type.
2. Read the results in the output panel: characters (with and without spaces), words, sentences, paragraphs, lines, reading time, speaking time, and your top 10 keywords.
3. Copy the report with the Copy button or Ctrl+Shift+C. It’s plain text, so it pastes cleanly into a ticket or a chat.
4. Clear the input with the Clear button or Ctrl+L.

Your last input is saved in your browser’s local storage, so it’s still there if you close the tab by accident.

How Each Count Is Calculated

Word counters disagree with each other mostly because they define “word” and “sentence” differently. These are the exact rules this tool follows:

Why Your Count Differs From Other Tools

Two word counters rarely agree to the last word. When they don’t, the difference almost always comes from one of these:

• Dashes and slashes. and/or, e-mail, and word—word (an em dash with no spaces around it) count as one word here, because there’s no whitespace inside them. Some editors split on dashes and slashes, which adds a word for each.
• Standalone symbols. An &, a dash surrounded by spaces, a bullet •, or a Markdown marker like ## or - is a whitespace-separated token, so it counts as a word. If you need a count of the prose alone, paste the rendered text rather than the Markdown or HTML source.
• Abbreviations. Dr. Smith and e.g. this each add an extra sentence, because a period followed by a space looks exactly like the end of a sentence. Decimals such as 3.14 are safe, since no space follows the period.
• Hidden characters. A zero-width space (U+200B), which sometimes comes along when you copy from web pages and chat apps, is invisible but isn’t whitespace. Two words joined by one count as a single word, and it adds a character to both character counts. Non-breaking spaces (U+00A0) are treated as normal spaces.
• Languages without spaces. Chinese, Japanese, and Thai don’t put spaces between words, so a whole sentence counts as one “word”. Use the character count instead, which is how length is measured in those languages anyway.

Characters, Emoji, and Unicode

The character count is the length of the text as JavaScript measures it (text.length), in UTF-16 code units. For most text that equals the number of characters you see: Latin letters, accented letters such as é, Cyrillic, Greek, and common Chinese characters count as 1 each. The exceptions are:

Counting this way is deliberate. It’s the number .length returns, so it matches what a web form’s client-side validation and most JavaScript code will see. Other systems count differently:

• X (Twitter) gives every emoji a weight of 2 no matter how many code points it contains, and counts Chinese, Japanese, and Korean characters as 2 as well. The 280 limit for standard accounts applies to that weighted total.
• SMS uses the 7-bit GSM alphabet when it can: 160 characters per message, or 153 per segment once a message is split. A single emoji or curly quote (’) switches the whole message to UCS-2, which drops the limit to 70 (67 per segment), and each emoji then takes 2 of those slots.
• Python’s len() counts code points, so len("👍🏽") is 2, not 4.
• Databases usually limit text columns in characters, meaning code points: VARCHAR(255) in PostgreSQL, or in MySQL with utf8mb4. Byte limits are a separate question. In UTF-8 an emoji takes 4 bytes.

Reading Time and Speaking Time

Reading time divides the word count by 200 words per minute. That’s deliberately conservative. A 2019 meta-analysis by Marc Brysbaert put average adult silent reading at about 238 words per minute for non-fiction and 260 for fiction, and Medium bases its read-time label on roughly 265. Technical documentation, text full of code samples, and anything read in a second language all go slower, so 200 is the safer figure for developer content. Expect our estimate for a blog post to run about a third longer than Medium’s.

Speaking time divides by 130 words per minute, a measured presentation pace that leaves room for pauses and slide changes. Conversational speech and podcasts often run at 150–160 words per minute, and nervous speakers go faster than they planned. Use these figures when you plan a talk:

Leave part of a conference slot for questions, and budget extra for live demos, which almost always take longer than their script.

Common Length Limits

Platforms change their limits from time to time, so check the platform’s own documentation before you rely on an exact number.

Keyword Density

The Top Keywords list shows the 10 words you use most, each as a percentage of the total word count. It’s case-insensitive, works in any alphabet, ignores punctuation, and skips words shorter than three letters. It doesn’t filter out common words, so “the”, “and”, and “for” usually top the list in English prose. Look past them.

The list is most useful for catching repetition. If one word makes up 3–4% of a short paragraph, readers will notice it before you do. It isn’t an SEO target. Search engines don’t reward any particular keyword density, and repeating a phrase to hit a number is keyword stuffing, which Google’s spam policies explicitly name.

Words vs. Tokens

AI models set their context limits and prices in tokens, not words. In English one word averages about 1.3 tokens, so 1,000 words is roughly 1,300 tokens. Source code, JSON, and most non-English languages use noticeably more tokens per word. When you need the exact number for a prompt or a context window, paste the same text into the AI Token Counter.

Counting Words in Code

When you need the same counts in a script or a CI check, these one-liners split words on whitespace just like this tool:

A few gotchas:

• wc -l counts newline characters, so a file without a final newline reports one line fewer than your editor shows. wc -c counts bytes, not characters. Use wc -m for characters in a UTF-8 locale.
• In JavaScript, "".split(/\s+/) returns [""], a one-item array. Trim and filter out empty strings, or an empty input reports 1 word.
• For languages without spaces, JavaScript’s Intl.Segmenter does real word segmentation: [...new Intl.Segmenter('ja', { granularity: 'word' }).segment(s)].filter(x => x.isWordLike).length. With granularity: 'grapheme' it counts user-perceived characters instead, so 👍🏽 is 1.

Your Text Stays in Your Browser

Drafts, cover letters, and unreleased docs are exactly the kind of text you shouldn’t paste into a random website. This counter runs entirely in your browser, and nothing you type is sent to a server. Your last input is kept in local storage on this device only, and Clear deletes it.

To keep working with the same text, change its capitalization with the Case Converter, strip repeated lines with Remove Duplicate Lines, compare two drafts in the Diff Checker, or generate filler of a set length with the Lorem Ipsum Generator.