Text Runs locally Ready to use Built-in examples No tracking

Markdown Word Counter

Count characters, words, headings, links, images, code blocks and estimate reading time for Markdown documents.

Word limits are usually a hard requirement and the rules differ: some platforms count body words, some count characters including punctuation and spaces, and prose submissions often specify characters rather than words. Paste the Markdown and the formatting markers — hashes, asterisks, link brackets — are stripped first, so what gets counted is the actual prose; headings, links, images, code blocks, list items and quoted lines are tallied separately.

Words and characters measure different things: a word count treats each run of letters as one word, while a character count gives every letter, mark and space a value of one, and many platform limits are expressed in characters. Reading time is estimated at roughly 300 words a minute and is a guide only — difficulty moves it more than length does.

—
  • —
  • —
  • —
  • —
  • —
  • —
  • —
  • —
  • —
  • —
  • —
  • —
  • —

How to use

  1. Paste the Markdown document.
  2. Read the total characters and the body word count, with formatting stripped.
  3. Check the structure counts — headings, links, images, code blocks, list items, quote lines, table rows.
  4. Compare the reading-time estimate, remembering a limit may be expressed in characters rather than words.

How it works

How body word count is computed

Paste the Markdown source for live statistics; the body count strips formatting markers — #, **, []() and the like — counting only Chinese characters and English words.

How reading time is estimated

Reading time assumes a mixed 300 words per minute, rounded up to at least 1 minute.

How code blocks are handled

Code-block content is excluded from the body count, but the tool tallies the number of fenced blocks and inline code spans separately.

Code example

JavaScript Stripping the formatting before counting 

// Rough approach: drop the common Markdown markers, then count CJK by character and Latin by word
const stripMd = (s) => s
  .replace(/```[\s\S]*?```/g, '')          // fenced code blocks
  .replace(/`[^`]*`/g, '')                      // inline code
  .replace(/!?\[[^\]]*\]\([^)]*\)/g, '')      // links and images
  .replace(/^\s{0,3}#{1,6}\s+/gm, '')            // heading markers
  .replace(/[*_~>|-]/g, '');                       // emphasis and list symbols

const count = (s) => {
  const t = stripMd(s);
  const cn = (t.match(/[\u4e00-\u9fa5]/g) || []).length;
  const en = (t.match(/[A-Za-z]+/g) || []).length;
  return cn + en;
};

count('# Title\n\nBody **bold** text');

Shell Checking many drafts in a batch 

# Count CJK characters and English words for every md file in a directory
for f in posts/*.md; do
  cn=$(grep -o '[\u4e00-\u9fa5]' "$f" | wc -l | tr -d ' ')
  en=$(grep -oE '[A-Za-z]+' "$f" | wc -l | tr -d ' ')
  printf "%-30s CJK %5s  words %5s\n" "$(basename "$f")" "$cn" "$en"
done

FAQ

Why does the count differ from Word's?

Word counts all characters (formatting included); this tool counts the body after stripping Markdown markers (Chinese characters + English words). Submission limits usually mean body text, closer to how platforms review.

How are tables and code blocks counted?

Table rows' | separators don't count toward the body, though table rows are tallied separately; fenced code blocks (```) are excluded from the body count and inline code is only counted, not read in.

Which Markdown syntax is recognized?

# headings, [text](links), ![]() images, **bold**, *italic*, ~~strikethrough~~, > quotes, - lists, | tables, ``` code blocks and `inline code`.

How do I get an accurate Markdown body count?

Strip the syntax first: remove #, *, backticks, []() markers, code blocks and URLs, then count Chinese characters and English words — that's the "net body count". Freelance rates and platform originality thresholds are better measured this way.

How long should a WeChat-official-account-style article be?

Common experience puts it at 1,200–2,500 characters: shorter lacks substance, longer hurts completion rates. Around 1,500 characters reads in about 5 minutes at 300 characters per minute — a good commute length. Let your audience and positioning decide.

Why are code blocks and links usually excluded?

They aren't narrative prose. Rates, originality thresholds and reading-time estimates all concern body content, while code blocks and long URLs inflate counts dramatically. This tool lists code blocks, links and images separately so you can audit them.

How is reading time estimated?

At 300 "reading units" (Chinese characters + English words) per minute — a common silent-reading figure; reading aloud runs slower at 180–200 per minute. Articles heavy on code or tables take longer in practice.