A token in AI is the basic unit of data that an AI model uses to process text, images, audio, and video, often representing a whole word, part of a word, a single character, or punctuation. Understanding AI tokens matters because providers measure both your usage bill and a model’s working-memory limits in tokens rather than words.
What is a token in AI?
A token in AI is a chunk of data that a model reads as input or generates as output instead of working with raw words or letters one by one. In text, a token can be a single character like z, a short common word like cat, part of a longer word, or a punctuation mark.
Splitting text into those chunks is called tokenization, and the complete list of tokens a given model recognizes is its vocabulary. Every model family uses its own tokenizer and encoding, which means the exact same paragraph can turn into a different number of tokens depending on which model you send it to.
Capitalization and spacing change how a tokenizer slices text. As OpenAI notes in its documentation, "red", "Red", and " red" (with a leading space) can each map to a completely different token. Because spaces are usually grouped with the word that follows them, a sentence does not simply split along word boundaries, and a token count is never identical to a word count.
How many tokens is a word?
In English, one token is roughly three-quarters of a word, or about four characters, according to OpenAI’s and Google’s rules of thumb. Put the other way around, 100 tokens equals about 75 English words on OpenAI’s estimate, or 60 to 80 English words on Google’s estimate.
| Source | Characters per token (English) | Words per 100 tokens (English) |
|---|---|---|
| OpenAI rule of thumb | ~4 characters | ~75 words (1 token ≈ 3/4 word) |
| Google Gemini rule of thumb | ~4 characters | ~60–80 words |
Those rules of thumb are useful for back-of-the-envelope math, but they are only rough averages for English. Token counts shift noticeably when you change the language or when a provider updates its tokenizer.
To see how much language and encoding matter in practice, I ran a test on November 1, 2026 using Articles 1 through 30 of the Universal Declaration of Human Rights from the official United Nations website in English, Spanish, French, and Simplified Chinese. I stripped the article headings and counted tokens with OpenAI’s open-source tiktoken library (version 0.14.0) using the o200k_base encoding, which tiktoken maps to GPT-4o and GPT-5. Because tiktoken 0.14.0 does not publish a mapping for GPT-6 models, and Claude and Gemini use their own tokenizers, treat these numbers as an illustration of how tokenization behaves rather than exact counts for GPT-6, Claude 5.5, or Gemini 4.
| Language | Characters | Words | Tokens (o200k_base) |
Tokens vs. English |
|---|---|---|---|---|
| English | 8,272 | 1,360 | 1,518 | — |
| Spanish | 9,360 | 1,519 | 1,931 | +27% |
| French | 9,406 | 1,565 | 2,094 | +38% |
| Chinese (Simplified) | 2,269 | n/a (no spaces) | 1,778 | +17% |
Even on a single short paragraph, the gap shows up right away. Article 1 alone (“All human beings are born free and equal in dignity and rights. They are endowed with reason and conscience and should act towards one another in a spirit of brotherhood.”) is 170 characters and 30 words in English, which came out to 33 tokens. The same article took 38 tokens in Spanish, 41 tokens in French, and 35 tokens for 43 characters in Simplified Chinese.
Across all 30 articles, English ran leaner than the standard rule of thumb: about 1.1 tokens per word (roughly 0.9 words per token) and 5.4 characters per token. Expressing the exact same legal text in Chinese, Spanish, or French cost 17% to 38% more tokens than English. If your team works outside English, your prompts and documents will use more of your budget and context limit for the same meaning.
Tokenizer upgrades also change the math. When I ran the exact same four texts through OpenAI’s older cl100k_base encoding (from the GPT-4 and GPT-3.5 era), English took 1,520 tokens, Spanish took 2,309, French took 2,469, and Chinese took 2,673. Moving from the older encoding to o200k_base barely touched English (1,520 vs. 1,518), but it cut Spanish token counts by about 16% and Chinese by about a third.
Newer tokenizers do not always mean fewer tokens, though. Anthropic notes in its documentation that the tokenizer introduced with Claude Opus 4.7 and used by Claude 5.5 models produces approximately 30% more tokens for the same input text than earlier Claude models, depending on the content. Whenever you switch model families or upgrade across generations, recount your prompts against the exact model you plan to use.
Input, output, cached, and reasoning tokens: what you actually pay for
AI API bills split token usage into four main categories: input tokens, output tokens, cached input tokens, and reasoning (or thinking) tokens. Understanding how each one works is the key to reading an API invoice.
- Input tokens (prompt tokens): Everything you send to the model in a request. That includes your visible question or document, plus system instructions, conversation history, tool definitions, schemas, images, and attached files.
- Output tokens (completion tokens): The text the model generates in response.
- Cached input tokens: Input tokens reused across requests through prompt caching, such as a long system prompt or reference document you send repeatedly. Cached input is 90% to 95% cheaper than fresh input on current frontier models.
- Reasoning tokens (thinking tokens): Internal tokens a model generates while working through a problem before writing its final response. Reasoning tokens are not visible as answer text, but OpenAI, Anthropic, and Google all count them toward output usage and bill them at the output token rate.
Here is what standard-tier API tokens cost across the major model families from the fall 2026 model releases, in US dollars per 1 million tokens as of November 1, 2026:
| Model | Input (per 1M tokens) | Cached input (per 1M tokens) | Output (per 1M tokens) |
|---|---|---|---|
| GPT-6 Astra | $10.00 | $1.00 | $50.00 |
| GPT-6.1 Sol | $2.00 | $0.10 | $10.00 |
| GPT-6 Luna | $0.10 | $0.01 | $0.50 |
| Claude Opus 5.5 | $4.00 | $0.20 | $20.00 |
| Claude Sonnet 5.5 | $2.00 | $0.10 | $10.00 |
| Claude Haiku 5.5 (prompts ≤100K tokens) | $0.10 | $0.01 | $0.50 |
| Gemini 4 Argon (through Nov 30, 2026) | $2.00 | $0.10 | $10.00 |
| Gemini 4 Argon (from Dec 1, 2026) | $4.00 | $0.20 | $20.00 |
Notice the spread between tiers: GPT-6 Luna and Claude Haiku 5.5 cost one-hundredth as much per token as GPT-6 Astra. Also watch for scheduled rate changes—Google’s Gemini 4 Argon carries an introductory rate through November 30, 2026 before doubling on December 1, and it is not included on the Gemini API free tier (though Google’s Gemini 3.8 Flash does offer a free tier). For a deeper look at batch discounts, long-context tiers, and provider rules, see our full AI API pricing comparison.
Why do output tokens cost more than input tokens?
Output tokens cost five times as much as input tokens on every model in the table above, as of November 2026. Vendors don’t publish why, but the usual technical explanation from engineers who work on inference is that reading a prompt happens in one parallel pass while writing happens one token at a time.
As developers Peter Chng and Bruno Magalhaes explain in their technical breakdowns of LLM inference, running a request happens in two distinct phases:
- Prefill (reading input): When you send a prompt, the model already has all of your input tokens at once. The GPU can process those tokens in parallel in a single pass, making efficient use of its computing power.
- Decode (writing output): When the model generates an answer, it has to produce one token at a time, because each new token depends on every token that came before it. For each individual output token, the hardware must load the model’s weights from GPU memory again to do relatively little arithmetic.
As Chng notes, the raw compute per token is similar, but the extra cost comes from memory traffic: generating tokens sequentially leaves the chip waiting on memory transfers over and over. That is the usual explanation for the premium; providers don’t publish their cost breakdowns.
How much does a task cost in tokens?
A typical document task costs anywhere from a fraction of a cent to under a dollar in AI tokens, depending on the model tier and how many reasoning tokens the model generates behind the scenes. You can calculate the exact price of any API call with one formula:
Cost = (Input tokens × Input price + Output tokens × Output price) ÷ 1,000,000
Example 1: Summarizing a 20-page contract
Suppose you want a model to read a 20-page contract and write a clear summary. Let’s make a few explicit assumptions so you can check the math: at roughly 500 words per page, the contract is 10,000 words. Using the 0.75 words-per-token rule of thumb and rounding up for safety, that comes to 13,500 input tokens. Assume the model’s summary (including any minimal thinking) takes 1,500 output tokens, with no prompt caching.
| Model | Calculation (per 1M rates) | Total cost |
|---|---|---|
| GPT-6 Astra | (13,500 × $10.00 + 1,500 × $50.00) ÷ 1,000,000 | $0.21 |
| Claude Opus 5.5 / Gemini 4 Argon (from Dec 1) | (13,500 × $4.00 + 1,500 × $20.00) ÷ 1,000,000 | $0.084 |
| GPT-6.1 Sol / Claude Sonnet 5.5 / Gemini 4 Argon (through Nov 30) | (13,500 × $2.00 + 1,500 × $10.00) ÷ 1,000,000 | $0.042 |
| GPT-6 Luna / Claude Haiku 5.5 | (13,500 × $0.10 + 1,500 × $0.50) ÷ 1,000,000 | $0.0021 |
On a mid-tier workhorse model like GPT-6.1 Sol or Claude Sonnet 5.5, reading and summarizing that 20-page contract costs about 4.2 cents as of November 2026. On a small model like GPT-6 Luna or Claude Haiku 5.5, it costs roughly two-tenths of a cent.
Example 2: The hidden cost of reasoning tokens
Now take the exact same 20-page contract (13,500 input tokens) and the exact same 1,500-token visible summary, but assume the model spends 10,000 reasoning tokens “thinking” through edge cases before it writes the answer.
Because reasoning tokens are billed as output tokens, your billed output jumps from 1,500 tokens to 11,500 tokens, even though the text on your screen looks identical:
- On GPT-6.1 Sol:
(13,500 × $2.00 + 11,500 × $10.00) ÷ 1,000,000 = $0.142— up from $0.042, or more than 3x the cost for the same visible length. - On GPT-6 Astra:
(13,500 × $10.00 + 11,500 × $50.00) ÷ 1,000,000 = $0.71— up from $0.21.
A short visible reply does not guarantee a small bill when reasoning or thinking modes are turned on.
What is a token in AI context windows?
In an AI context window, tokens measure the model’s total working memory for a single request—every token you send in plus every token the model generates in response. Once a conversation or document exceeds that token limit, the request either fails or drops older information.
As of November 2026, the flagship model families all offer context windows around 1 million tokens, though the exact caps and output ceilings differ:
- OpenAI (GPT-6 Astra, GPT-6.1 Sol, GPT-6.1 Terra, GPT-6 Luna): 1.05 million token context window, with a maximum output of 128,000 tokens.
- Anthropic (Claude Opus 5.5, Sonnet 5.5, Haiku 5.5): 1 million token context window and 128,000 max output tokens. Anthropic says 1 million tokens equals roughly 555,000 words (or 2.5 million Unicode characters) on its current tokenizer, introduced with Claude Opus 4.7; earlier Claude models fit about 750,000 words into 1 million tokens.
- Google (Gemini 4 Argon): A single 1,048,576-token context window shared across input, thinking, and output tokens, with synchronous responses capped at 65,536 output tokens by default.
Three practical rules govern how context windows fill up:
- Everything in the request counts. Your system prompt, chat history, tool definitions, uploaded documents, images, thinking tokens, and final answer all share the same window.
- Prompt caching lowers your bill, not your token count. Caching repeated instructions cuts what you pay for those tokens by 90% to 95%, but cached tokens still take up the exact same space inside the context window.
- Bigger context can hurt accuracy. Anthropic warns in its documentation that as the token count in a request grows, a model’s accuracy and recall degrade—a phenomenon known as context rot. Just because a model accepts 1 million tokens does not mean you should dump 500,000 words into every prompt when a focused excerpt would do.
Images, audio, and video are tokens too
Multimodal AI models convert images, audio clips, and video into tokens right alongside text, and bill them into the same token totals. Google’s Gemini documentation spells out the exact conversion rates its models use:
- Images: Any image up to 384 pixels in both dimensions costs 258 tokens. Larger images are divided into 768×768-pixel tiles, and each tile counts as 258 tokens.
- Audio: Gemini tokenizes audio at 32 tokens per second. If you send one hour of meeting audio straight to a Gemini model, that single recording equals
3,600 seconds × 32 tokens/second = 115,200 input tokens. - Video: Using static processing, video runs about 100 tokens per second at default low resolution, or about 300 tokens per second at high resolution. Google notes that a one-hour lecture video can consume roughly 1.08 million tokens in static mode—nearly filling a 1M context window on its own—or about 108,000 tokens when handled with agentic processing.
If your workflow processes hours of recordings or high-resolution PDFs scanned as images, non-text tokens can quickly outweigh the text in your prompts.
What I’d actually do
If you are trying to keep AI token usage predictable without turning token math into a part-time job, here is the workflow I recommend:
- Use the provider’s real token counter, not word-count guesses. For quick ballpark math in English, assume 0.75 words per token and add a 20% to 40% buffer if your text is in Spanish, French, Chinese, or another non-English language. Before you put anything into production, check real numbers using OpenAI’s Tokenizer page, the
tiktokenlibrary, Google’s token guide, or Anthropic’s free token-counting API endpoint—and always read theusagefield (input_tokens,output_tokens, cached, and thinking tokens) returned in every API response. - Watch reasoning tokens and cap output length. A model that spends 10,000 hidden tokens thinking through a simple summary can triple your bill at 5x output rates. Use thinking modes where hard problems demand them, and set sensible output limits for routine work.
- Cache everything you repeat. If every API call includes the same long system instructions, policy handbook, or tool definitions, turn on prompt caching so you pay 90% to 95% less on that repeated input.
- Compare cost per finished task, not price per million tokens. As OpenAI notes in its own help docs, a lower price per million tokens does not automatically mean a lower total bill, because different models tokenize the same text differently and generate different amounts of output and reasoning. Run a small test on your own prompts—our guide on how to choose an AI model walks through a 30-minute test—and check our AI API pricing comparison when you are ready to budget.
FAQ
How many words is 1,000 tokens?
In English, 1,000 tokens is roughly 750 words under OpenAI’s rule of thumb, or between 600 and 800 words under Google’s estimate. In my test on UN human-rights text, English ran closer to 900 words per 1,000 tokens, while Spanish, French, or Chinese text will fit fewer words or equivalents into 1,000 tokens because non-English languages require more tokens for the same meaning.
Do reasoning tokens cost money?
Yes, reasoning (or thinking) tokens cost money and are billed at the model’s output token rate. Even though you do not see reasoning tokens in the final displayed answer, OpenAI, Anthropic, and Google all count the tokens a model uses to think through a problem as output usage. Because output tokens cost five times as much as input tokens on major models, heavy reasoning can multiply the price of a request.
How much do AI tokens cost?
As of November 2026, standard API prices for major models range from $0.10 to $10.00 per 1 million input tokens and $0.50 to $50.00 per 1 million output tokens. Small models like GPT-6 Luna and Claude Haiku 5.5 cost $0.10 per million input tokens and $0.50 per million output tokens, mid-tier models like GPT-6.1 Sol and Claude Sonnet 5.5 cost $2.00 and $10.00, and GPT-6 Astra costs $10.00 and $50.00.
Are AI tokens the same as crypto tokens?
No. In artificial intelligence, a token is simply the unit of text or media that a language model reads, generates, and uses to measure context limits and API usage bills. When an AI pricing page, usage dashboard, or context-window spec mentions tokens, it means units of text, images, or audio the model processed, and the bill is calculated per million of them. It is completely unrelated to cryptocurrency tokens.
What does 1 million tokens look like?
On Anthropic’s current tokenizer for Claude 5.5 models, 1 million tokens equals roughly 555,000 words, or about 2.5 million Unicode characters (earlier Claude models fit around 750,000 words into 1 million tokens). In multimodal terms on Google’s Gemini models, 1 million tokens is roughly the size of a one-hour lecture video processed in high-resolution static mode (about 1.08 million tokens).
Prices and limits last checked November 1, 2026. Next review: April 30, 2027.
Sources
- OpenAI Help Center, Understanding and counting tokens, accessed November 1, 2026
- OpenAI, Models documentation, accessed November 1, 2026
- OpenAI, API pricing, accessed November 1, 2026
- OpenAI, tiktoken GitHub repository, accessed November 1, 2026
- Google, Understand and count tokens (Gemini API docs), accessed November 1, 2026
- Google, Gemini Developer API pricing, accessed November 1, 2026
- Anthropic, Models overview, accessed November 1, 2026
- Anthropic, Token counting, accessed November 1, 2026
- Anthropic, Context windows, accessed November 1, 2026
- Anthropic, Pricing, accessed November 1, 2026
- United Nations, Universal Declaration of Human Rights, accessed November 1, 2026
- Peter Chng, Why do LLM input tokens cost less than output tokens?, May 1, 2024, accessed November 1, 2026
- Bruno Magalhaes, Prefill vs decode, roofline, KV cache, batching and disaggregation, accessed November 1, 2026
