AI providers price their APIs in tokens. Nobody thinks in tokens. You think in words, paragraphs, pages, and blog posts. When your boss asks "how much will it cost to generate 10,000 product descriptions?" — you need a number in dollars, not a lecture about tokenization.
This guide converts every major AI model's pricing into cost per word of generated output. We're using current March 2026 pricing data, real token-to-word ratios, and practical examples so you can budget accurately for any text generation workload.
💡 Key Takeaway: One token ≈ 0.75 words for English text. That means 1,000 words ≈ 1,333 tokens. Output tokens are always more expensive than input tokens — often 3-8x more — so the cost of generating text is what dominates your bill.
The token-to-word conversion everyone gets wrong
The standard rule of thumb is that one token equals roughly 0.75 words in English. OpenAI's tokenizer (used by GPT models) averages about 1.3 tokens per word. Anthropic's Claude tokenizer is similar. Google's Gemini models use SentencePiece tokenization, which lands in the same range.
But this ratio isn't constant. Technical content with jargon, code snippets, or non-English text tokenizes less efficiently — sometimes hitting 1.5-2 tokens per word. Simple conversational English tokenizes closer to 1.2 tokens per word.
For this guide, we use 1.33 tokens per word (or 750 words per 1,000 tokens) as the standard conversion. This is the median for typical business and marketing content.
Here's what that means for common content lengths:
| Content type | Words | Tokens (approx.) |
|---|---|---|
| Tweet / short social post | 50 | 67 |
| Product description | 150 | 200 |
| Email newsletter | 500 | 667 |
| Blog post (like this one) | 2,000 | 2,667 |
| Long-form article | 5,000 | 6,667 |
| E-book chapter | 10,000 | 13,333 |
Cost per word: every major model compared
Here's what each model charges per word of generated output based on current pricing. We're using output pricing because that's what you pay for the text the model creates. Input costs (your prompts) are separate and typically much cheaper.
[stat] $0.000000056 The cost per word with GPT-5 nano — generating a full novel (80,000 words) for $0.004
Flagship models
These are the top-tier models from each provider. Best quality, highest cost.
| Model | Output $/M tokens | Cost per word | Cost per 1,000 words | Cost per 10,000 words |
|---|---|---|---|---|
| GPT-5.2 | $14.00 | $0.0000187 | $0.0187 | $0.187 |
| GPT-5.2 Pro | $168.00 | $0.0002240 | $0.2240 | $2.240 |
| Claude Opus 4.6 | $25.00 | $0.0000333 | $0.0333 | $0.333 |
| Gemini 3.1 Pro | $12.00 | $0.0000160 | $0.0160 | $0.160 |
| Grok 4 | $15.00 | $0.0000200 | $0.0200 | $0.200 |
| Mistral Large 3 | $1.50 | $0.0000020 | $0.0020 | $0.020 |
| Llama 4 Maverick | $0.85 | $0.0000011 | $0.0011 | $0.011 |
⚠️ Warning: GPT-5.2 Pro at $168/M output tokens is a reasoning model designed for complex multi-step problems. Using it for bulk content generation would cost over $2 per page. That's almost never the right choice for text generation workloads.
Efficient and budget models
For bulk content, customer support, and high-volume use cases, these models deliver usable quality at a fraction of the cost.
| Model | Output $/M tokens | Cost per word | Cost per 1,000 words | Cost per 10,000 words |
|---|---|---|---|---|
| GPT-5 mini | $2.00 | $0.0000027 | $0.0027 | $0.027 |
| GPT-5 nano | $0.40 | $0.0000005 | $0.0005 | $0.005 |
| Claude Haiku 4.5 | $5.00 | $0.0000067 | $0.0067 | $0.067 |
| Gemini 2.5 Flash | $2.50 | $0.0000033 | $0.0033 | $0.033 |
| Gemini 2.0 Flash-Lite | $0.30 | $0.0000004 | $0.0004 | $0.004 |
| DeepSeek V3.2 | $0.42 | $0.0000006 | $0.0006 | $0.006 |
| Mistral Small 3.2 | $0.18 | $0.0000002 | $0.0002 | $0.002 |
| Grok 4.1 Fast | $0.50 | $0.0000007 | $0.0007 | $0.007 |
The spread is enormous. Generating 10,000 words with Claude Opus 4.6 costs $0.33. The same output from Mistral Small 3.2 costs $0.002 — roughly 165x cheaper. The quality difference matters, but for many use cases, the budget models produce perfectly acceptable output.
Real-world cost calculations: what actual projects cost
Abstract per-word pricing only matters when you map it to real workloads. Here's what common AI text generation projects actually cost at scale.
Content marketing: 50 blog posts per month
A typical SEO-focused content operation producing 50 blog posts of 2,000 words each — that's 100,000 words per month. Each post also requires a prompt of roughly 500 words (system prompt + instructions + outline), totaling 25,000 prompt words or about 33,333 input tokens.
| Model | Input cost | Output cost | Total monthly |
|---|---|---|---|
| GPT-5.2 | $0.06 | $1.87 | $1.93 |
| Claude Opus 4.6 | $0.17 | $3.33 | $3.50 |
| Claude Sonnet 4.6 | $0.10 | $2.00 | $2.10 |
| Gemini 3.1 Pro | $0.07 | $1.60 | $1.67 |
| GPT-5 mini | $0.01 | $0.27 | $0.28 |
| DeepSeek V3.2 | $0.01 | $0.06 | $0.07 |
📊 Quick Math: Even with a premium flagship model like Claude Opus 4.6, 50 blog posts per month costs under $4 in raw API fees. The real cost is in prompt engineering, editing, and quality review — not the API.
E-commerce: 10,000 product descriptions
Generating 10,000 product descriptions at 150 words each equals 1.5 million words of output (2 million tokens). Prompts include product specs and style guidelines — roughly 200 words each, totaling 2 million input words (2.67 million input tokens).
| Model | Input cost | Output cost | Total |
|---|---|---|---|
| GPT-5.2 | $4.67 | $28.00 | $32.67 |
| Claude Sonnet 4.6 | $8.00 | $30.00 | $38.00 |
| GPT-5 mini | $0.67 | $4.00 | $4.67 |
| Gemini 2.5 Flash | $0.80 | $5.00 | $5.80 |
| DeepSeek V3.2 | $0.75 | $0.84 | $1.59 |
| Mistral Small 3.2 | $0.16 | $0.36 | $0.52 |
DeepSeek V3.2 and Mistral Small 3.2 stand out for bulk generation workloads. At $1.59 and $0.52 respectively for 10,000 product descriptions, the API cost is essentially a rounding error compared to the engineering time to build the pipeline.
Customer support: 50,000 responses per month
A support chatbot handling 50,000 conversations per month. Average context: 800 words in (customer message + history), 200 words out (response). That's 40 million input words and 10 million output words per month.
| Model | Input cost | Output cost | Total monthly |
|---|---|---|---|
| GPT-5 mini | $13.33 | $26.67 | $40.00 |
| Claude Haiku 4.5 | $53.33 | $66.67 | $120.00 |
| Gemini 2.0 Flash | $5.33 | $5.33 | $10.67 |
| Gemini 2.0 Flash-Lite | $4.00 | $4.00 | $8.00 |
| DeepSeek V3.2 | $14.93 | $5.60 | $20.53 |
| Mistral Small 3.2 | $3.20 | $2.40 | $5.60 |
💡 Key Takeaway: For high-volume customer support, model choice creates a 20x cost difference. Gemini 2.0 Flash-Lite and Mistral Small 3.2 both handle this workload for under $10/month. Even GPT-5 mini keeps it at $40. Claude Haiku 4.5 — while still "budget" — is noticeably more expensive at scale because its per-token pricing is higher than its competitors in the efficient tier.
Why output tokens cost more than input tokens
Every provider charges more for output (generated) tokens than input (prompt) tokens. The ratio varies:
| Provider | Model | Input $/M | Output $/M | Output multiplier |
|---|---|---|---|---|
| OpenAI | GPT-5.2 | $1.75 | $14.00 | 8x |
| Anthropic | Claude Opus 4.6 | $5.00 | $25.00 | 5x |
| Gemini 3.1 Pro | $2.00 | $12.00 | 6x | |
| Anthropic | Claude Sonnet 4.6 | $3.00 | $15.00 | 5x |
| OpenAI | GPT-5 mini | $0.25 | $2.00 | 8x |
| DeepSeek | V3.2 | $0.28 | $0.42 | 1.5x |
| Mistral | Large 3 | $0.50 | $1.50 | 3x |
The technical reason: generating output requires running the model's forward pass once per token, sampling from the probability distribution, and maintaining KV cache state. Input tokens can be processed in parallel batches. Output is inherently sequential and compute-intensive.
The practical implication: your prompt length matters less than your output length for cost. A 2,000-word prompt generating a 200-word response is far cheaper than a 200-word prompt generating 2,000 words — even though both move a similar number of total tokens.
DeepSeek stands out with only a 1.5x output multiplier. For workloads that generate long outputs relative to their inputs, this pricing structure saves substantially compared to OpenAI's 8x ratio.
The hidden multiplier: reasoning tokens
Reasoning models like o3, o4-mini, GPT-5.2 Pro, and DeepSeek R1 generate internal "thinking" tokens before producing visible output. These thinking tokens are billed as output tokens even though you never see them.
A reasoning model might generate 3,000 thinking tokens to produce 500 tokens of visible output. You're billed for all 3,500 output tokens. That means the effective cost per visible word can be 5-10x higher than the base output price suggests.
| Model | Output $/M | Typical thinking ratio | Effective cost per 1,000 visible words |
|---|---|---|---|
| o3 | $8.00 | 4:1 | $0.053 |
| o4-mini | $4.40 | 3:1 | $0.023 |
| GPT-5.2 Pro | $168.00 | 5:1 | $1.344 |
| DeepSeek R1 V3.2 | $0.42 | 4:1 | $0.003 |
⚠️ Warning: If you're comparing models for text generation, don't use reasoning models unless the task genuinely requires multi-step reasoning. A straightforward content generation task on o3 costs roughly 5x what the same task costs on GPT-5.2 — with no quality improvement for simple writing tasks.
For a deeper breakdown of reasoning model pricing, see our reasoning model pricing guide.
Optimizing cost per word: practical strategies
1. Match the model to the task complexity
The single biggest waste in AI spending is using a flagship model for tasks that a budget model handles equally well. Classification, summarization, simple Q&A, and template-based generation rarely benefit from Claude Opus or GPT-5.2.
Rule of thumb: Start with the cheapest model that produces acceptable quality. Only upgrade when you can demonstrate a measurable quality difference in your specific use case.
2. Control output length explicitly
Uncontrolled generation is expensive generation. If you need a 150-word product description, tell the model: "Write exactly 150 words." Without length constraints, models tend to be verbose — often generating 2-3x more text than needed.
Most APIs support a max_tokens parameter. Set it. A 300-token cap on a product description task prevents runaway generation and keeps costs predictable.
3. Use prompt caching for repeated contexts
If every request shares the same system prompt, style guide, or few-shot examples, prompt caching reduces the input cost of that shared prefix by 80-90%. On Anthropic, cached input costs $0.30/M versus $3.00/M for Claude Sonnet 4.6.
4. Batch your requests
OpenAI's Batch API offers a 50% discount on all models for non-time-sensitive workloads. If you're generating product descriptions, email templates, or any content that doesn't need real-time responses, batch processing cuts your bill in half automatically.
5. Route by task complexity
Build a simple classifier (even a regex or keyword-based one) that routes simple tasks to budget models and complex tasks to flagship models. A system that sends 80% of requests to GPT-5 nano and 20% to GPT-5.2 costs dramatically less than sending everything to GPT-5.2.
Use our cost calculator to model the savings for your specific traffic split.
✅ TL;DR: The cheapest path to high-quality AI text generation is a combination of model routing (cheap models for simple tasks, expensive models only when needed), output length control, prompt caching, and batch processing. Together, these strategies reduce costs by 70-90% compared to naively using a flagship model for everything.
Cost per word across languages
English tokenizes efficiently — roughly 1.33 tokens per word. Other languages don't. CJK languages (Chinese, Japanese, Korean) often tokenize at 2-3 tokens per character. Languages with complex morphology (Finnish, Turkish, Hungarian) average 1.8-2.5 tokens per word.
This means the same content costs significantly more to generate in non-English languages:
| Language | Tokens per word | Cost per 1,000 words (GPT-5.2) | Cost multiplier vs English |
|---|---|---|---|
| English | 1.33 | $0.0187 | 1.0x |
| Spanish | 1.45 | $0.0203 | 1.1x |
| German | 1.65 | $0.0231 | 1.2x |
| Arabic | 2.10 | $0.0294 | 1.6x |
| Chinese | 2.50 | $0.0350 | 1.9x |
| Japanese | 2.80 | $0.0392 | 2.1x |
📊 Quick Math: Generating 10,000 words of Japanese content on GPT-5.2 costs $0.39 versus $0.19 for the same content in English — roughly double. For large-scale multilingual operations, this multiplier compounds fast.
If your workload is multilingual, factor these ratios into your cost estimates. The savings from choosing a cheaper model are amplified in token-heavy languages.
How AI cost per word compares to human writers
Context matters. AI-generated text at $0.002-$0.02 per 1,000 words isn't competing on quality with a senior copywriter charging $0.50-$1.00 per word. But for many use cases — first drafts, data-driven content, product descriptions, internal documentation — the 1,000-50,000x cost difference makes AI the obvious choice for the first pass.
| Source | Cost per 1,000 words |
|---|---|
| Mistral Small 3.2 | $0.002 |
| DeepSeek V3.2 | $0.006 |
| GPT-5 mini | $0.027 |
| GPT-5.2 | $0.187 |
| Claude Opus 4.6 | $0.333 |
| Freelance writer (budget) | $50-$100 |
| Freelance writer (expert) | $200-$500 |
| In-house content team | $150-$300 |
Even the most expensive AI model — Claude Opus 4.6 at $0.33 per 1,000 words — is 150x cheaper than the cheapest human writer. The real cost equation isn't "AI vs human" — it's "AI draft + human editing vs human from scratch." Most teams find that AI-assisted workflows cut total content production costs by 60-80% while maintaining quality standards.
Frequently asked questions
How much does it cost to generate 1,000 words with ChatGPT?
Using the GPT-5.2 API, 1,000 words of generated text costs approximately $0.019. With GPT-5 mini, the same output costs $0.003. The ChatGPT subscription ($20/month) is separate from API pricing — if you're using the web interface, you pay the subscription fee, not per-word costs. API pricing only applies when calling the model programmatically.
What's the cheapest AI model for bulk text generation?
Mistral Small 3.2 at $0.18 per million output tokens is the cheapest option, costing just $0.002 per 1,000 words. Gemini 2.0 Flash-Lite ($0.004/1,000 words) and GPT-5 nano ($0.005/1,000 words) are close behind. For most bulk generation tasks — product descriptions, metadata, simple summaries — these models produce acceptable quality. Test with a sample batch before committing to a full production run.
How many tokens is 1,000 words?
Approximately 1,333 tokens in English. The exact count varies by content type: simple conversational text averages 1,200 tokens per 1,000 words, while technical content with code or specialized terminology can reach 1,500-1,800 tokens per 1,000 words. Use our token calculator to get precise estimates for your specific content.
Is AI text generation cheaper than hiring writers?
By raw cost, AI is 150-50,000x cheaper depending on the model. But raw cost isn't the full picture. AI-generated content typically requires human editing for accuracy, brand voice, and nuance. The real comparison is AI draft + human editing versus human from scratch. Most teams report 60-80% cost savings using AI-assisted workflows while maintaining their quality bar.
Why do output tokens cost more than input tokens?
Generating text (output) requires the model to run its forward pass sequentially — one token at a time — while maintaining KV cache memory. Input tokens can be processed in parallel batches, which is computationally cheaper. The output-to-input price ratio ranges from 1.5x (DeepSeek) to 8x (OpenAI GPT-5.2), reflecting this computational asymmetry.
Start calculating your real costs
Every project is different. The numbers in this guide give you ballpark estimates, but your actual costs depend on prompt length, output length, language, and model choice. Use our AI Cost Calculator to plug in your specific parameters and get exact cost projections across all major providers.
If you're evaluating models for a new project, start with our cheapest AI APIs guide for the budget options, or our complete pricing guide for a full provider comparison. For token basics, check out What Are AI Tokens? — it covers everything you need to understand the pricing unit that drives your bill.