Writers, editors, and SEO teams love hard limits. 800 words. 1,500 words. 60 characters for a title tag. Ask ChatGPT for exactly 800 words though, and you will often get 735 or 914. Sometimes it will even tell you it wrote 800 words when it did not. If you have noticed this in your workflow, you are not alone. Power users have flagged the issue in OpenAI’s own community forum for years, and the short version is simple: the model is not built to count words precisely while it is generating them. 

Below is a clear, practical explanation you can share with your team, plus concrete ways to keep production on schedule without playing word-count whack-a-mole.

The core issue: models think in tokens, not words

Large language models do not see text the way we do. They process text as tokens, which are chunks of characters that may be whole words, pieces of words, or even punctuation and spaces. In English, a rough rule of thumb is 1 token is about 4 characters or about three quarters of a word. Those are averages, not guarantees, and they vary by language and phrasing. When you ask for exactly N words, the model is predicting token by token, not tallying a running word count. 

Because tokens do not map one-to-one to words, word-level constraints are slippery. Two prompts that look similar to you may tokenize very differently to the model. That makes precise word targets unreliable during generation.

Why Exact Word Counts Fail in Practice

Here are the main reasons your 800-word instruction comes back at 735 or 914:

No native counter

The model is a next-token predictor, not a spreadsheet. It does not keep an internal ledger of words as it writes. Community explanations from OpenAI’s forum make this point bluntly: you are asking a language predictor to behave like a calculator. 

Tokens vs words misalignment

A single token can be a whole word, half a word, or punctuation. Word boundaries do not line up cleanly with the units the model uses to write, so the model cannot reliably stop at a precise word boundary on command. 

‍Length controls are token-based

All the levers you can pull in the API or product are token-centric. Max output length, stop sequences, and other controls limit tokens, not words. You can nudge the model shorter or longer, but you cannot guarantee a word count the way you can guarantee a token limit. 

Self-reported counts can be wrong

If you ask the model to report a word count at the end, it often estimates or fabricates a number that “sounds right.” Users have repeatedly documented this behavior in the OpenAI forum. 

What your team should do instead

You can still run a tight production process. Shift the exactness to the places where software can truly be exact, and let the model do what it is best at.

1) Give ranges, not exact numbers

Prompt for a range, for example, “Write 750 to 850 words.” Ranges reduce retries and still achieve consistent layouts in CMS templates and design systems. If you must fix a hard ceiling for design, set it as a character limit in your CMS, not as a word limit in the prompt. The model will be more likely to land inside a narrow band when it is not asked to hit a single point. 

2) Control tokens upstream, measure words downstream

Use token budgeting to predict approximate length, then measure the true word count after generation. As a rule of thumb for English, 1,000 tokens is roughly 750 words. Plan your max tokens accordingly, then let your build system or CMS do exact word counting after the fact. 

3) Post-process to exact counts

Treat exact word count as a post-processing step. Generate the draft, tally words with your own counter, then automatically expand or trim. A simple loop works:

If words < target, ask the model to expand specific sections by a set number of sentences.

If words > target, ask the model to compress specific sections or remove redundancies.

This two-step approach is faster than chasing exact length in a single pass and avoids hallucinated self-reported counts. Forum users who try to force one-pass exactness often hit the same wall. 

‍4) Use section budgets, not a single total

Instead of one 1,200-word target, budget 150 to 250 words per subsection across six to eight sections. This makes expansions and trims surgical and keeps your SEO structure stable. It also reduces variance because each smaller generation is easier to keep “about right.”

5) Stop sequences and summaries for clean endings

Use stop sequences to keep the model from wandering into extra copy like FAQs or “Key Takeaways” when you did not ask for them. Then ask for a one-sentence summary at the end. Stop sequences are token-based, but in practice they cut off the long-tail risk that throws off your final count. 

6) Never trust the model’s own count

If you want a count inside the text for client review, inject the true number from your system. Do not ask the model to compute or restate it. Users have documented repeated miscounts when the model tries to tally words itself. 

A quick mental model for your team

What the model is great at: idea generation, structure, tone, relevance, and rewriting on command.

What your stack should own: exact lengths, deduplication, and compliance checks.

If you break the workflow this way, you stop fighting the model and start using it as the creative engine it is.

How we apply this in SEO and content production

For PBJ-style long-form posts, landing pages, and city pages, we keep the model focused on substance and let the system keep guardrails.

Brief with structure

We pass an outline with H2s and H3s, plus rough token targets per section based on the rule that 100 tokens is roughly one medium paragraph. 

Generate in sections

We generate each section in its own call or pass, which tightens variance and makes edits local.

Measure externally

Our build step counts words and characters exactly and stores the numbers in the draft’s front matter or CMS fields.

Auto-trim or expand

If a section is outside its window, we ask for a targeted trim or expansion. For example, “Compress the intro by about 60 to 80 words by removing repeated setup and keeping the thesis.”

Finalize with stop sequences

We end sections with a stop sequence to avoid spillover. This helps hold the final length steady. 

Common Questions We Hear

Does ChatGPT know how many words it has written?

No. ChatGPT generates text token by token and does not keep a live word counter. If you ask it how many words are in the output, it will often guess instead of calculate.

Why does ChatGPT sometimes claim it hit the target when it did not?

Because it is predicting what a good answer should look like. If you say "write 500 words," it may add a line like "this is 500 words" even when the count is off.

If I ask for 1,000 words, why do I sometimes get fewer or more?

The model may decide the draft feels complete before reaching your target, or it may hit the token ceiling before it finishes. Tokens, not words, drive the generation process.

Can I get ChatGPT to count words as it writes?

Not reliably. Instructions like "show a word count every 100 words" will usually produce inaccurate numbers. Use an external counter once the text is generated.

Is ChatGPT better at paragraphs or sentences instead of words?

Yes. Asking for "5 paragraphs" or "10 sentences" is usually more reliable because those are natural text structures the model recognizes. Exact word counts are much harder.

Do newer versions of ChatGPT solve this problem?

Newer models follow instructions more closely and may stay within a tighter range, but they still cannot guarantee exact word counts. The process is still token by token.

Why do people keep running into this issue?

Because editors, SEO teams, and clients think in exact numbers. ChatGPT does not. Without a post-processing step, you will always see some mismatch.

What is the best way to get an exact length with ChatGPT?

Use it to draft. Then run the text through a real word counter. If it is short, ask ChatGPT to expand specific sections. If it is long, ask it to compress or trim. This two-step loop is faster and more reliable than chasing exact word counts in one pass.

Can character limits be easier to enforce?

Yes. Characters are easier to measure exactly in downstream systems. If your design needs a hard cap, set it as a character limit in your CMS and trim accordingly.

Will ChatGPT ever be able to count words perfectly?

Not unless the architecture changes. As long as the model generates token by token, you should expect ranges and post-processing rather than precise one-shot counts.

‍