What Are LLM Tokens? Complete Guide to Tokens, Context Windows, and API Costs (2026)

What Is a Token? (The Part AI Providers Never Explain Clearly)

Every AI API — OpenAI, Anthropic, Google, Meta, Mistral — bills you per token. Not per word, not per request, not per second. Per token. So if you have ever been surprised by an AI API invoice, tokens are almost certainly the reason. Here is what they actually are.

A token is the smallest chunk of text that a language model processes internally. When you send a prompt to GPT-4o or Claude, your text does not travel as readable words — the model first converts it into a sequence of token IDs, processes those IDs, and then converts the output tokens back into text. Think of it as the model's native alphabet.

Here is the rule of thumb every developer working with AI APIs should have memorized: 1 token ≈ 4 characters ≈ 0.75 words in English. Flip it around: 1 English word ≈ 1.3 tokens. So a 500-word prompt is actually closer to 650 tokens, not 500. That 30% gap adds up fast when you are making tens of thousands of API calls per day.

The token-to-word relationship is not uniform. Short, common words ("the", "is", "a", "of") are each 1 token. Medium-length words ("token", "model", "system") are 1–2 tokens. Long or technical words ("tokenization", "unprecedented", "hamburger") split into 2–4 tokens. Capitalization can also matter — some tokenizers treat "TOKEN" and "token" as different IDs.

Real-World Token Benchmarks You Should Memorize

Before thinking about pricing, get these practical benchmarks into your head. They will save you from bad cost assumptions when building production applications:

• "Hello, world!" = 4 tokens
• A 100-word paragraph ≈ 130 tokens
• A 1,000-word blog post ≈ 1,300–1,500 tokens
• A 10-line Python function ≈ 150–250 tokens (code is denser than prose)
• A typical system prompt (200 words) ≈ 260–310 tokens
• A full A4 page of text ≈ 600–800 tokens
• A 5,000-word article ≈ 6,500–7,500 tokens
• A 300-line codebase with comments ≈ 3,500–5,000 tokens
• A short novel (50,000 words) ≈ 65,000–75,000 tokens
• A legal contract (10 pages) ≈ 5,000–8,000 tokens

The fastest way to check any specific text: paste it into the LLM Token Counter. It counts tokens for GPT-4o, Claude 3.5, Gemini 2.0, Llama 3.1, and Mistral instantly in your browser — no API key, no account required.

Why GPT-4 and Claude Give Different Token Counts for the Same Text

This trips up a lot of developers. If you take the same paragraph and count tokens in GPT-4o and Claude 3.5, you will usually get different numbers. Both are correct — they just use completely different tokenizers.

OpenAI uses a tokenizer called tiktoken across all GPT models. It is open-source, which means you can run it locally or inspect exactly how it splits text. Anthropic Claude uses a different proprietary tokenizer that was designed and trained independently. Google Gemini uses a SentencePiece-based tokenizer. Meta Llama uses yet another variant of SentencePiece. Each was trained on different data and splits text at different word boundaries.

For plain English text, the differences are usually small — within 5–10%. But in these situations the gap becomes significant:

• Code — Python, JavaScript, JSON, and SQL have high variance between tokenizers. Variable names, indentation, and special characters are handled very differently.
• Non-Latin scripts — Chinese, Japanese, Korean, Arabic, and Hindi can differ by 20–40%. These languages were underrepresented in tokenizer training data, so they are less efficiently encoded.
• Mathematical notation — Equations and symbols often tokenize very differently. A LaTeX formula that is 30 characters might be 15 tokens in one model and 40 tokens in another.
• Special characters and URLs — File paths, email addresses, and URLs are handled inconsistently and can balloon token counts unexpectedly.

The practical takeaway: always count tokens using the model you will actually deploy. The LLM Token Counter uses model-specific estimation formulas to give you the most accurate count for whichever provider you select — GPT, Claude, Gemini, Llama, or Mistral.

Input Tokens vs Output Tokens — The Cost Gap Most Developers Miss

This is the most expensive misunderstanding in AI API development. Input tokens and output tokens are not priced the same. Output is always more expensive — and the gap is large enough to completely change your cost model if you ignore it.

• GPT-4o: $2.50 / 1M input vs $10.00 / 1M output — output is 4x more expensive
• Claude 3.5 Sonnet: $3.00 / 1M input vs $15.00 / 1M output — output is 5x more expensive
• GPT-4.1: $2.00 / 1M input vs $8.00 / 1M output — output is 4x more expensive
• Claude 3.5 Haiku: $0.80 / 1M input vs $4.00 / 1M output — output is 5x more expensive
• Gemini 2.0 Flash: $0.10 / 1M input vs $0.40 / 1M output — output is 4x more expensive

Here is what this means in practice. Imagine you have a 500-token system prompt, a 200-token user message, and the model generates a 2,000-token response. That is 700 input tokens and 2,000 output tokens. On GPT-4o, your input costs $0.00175 and your output costs $0.020. The output is your entire bill — the input is almost a rounding error.

The most effective fix: always set max_tokens on your API requests. If a task needs a 2-sentence answer, cap the response at 100 tokens. If you need a 500-word article, cap at 700. Models left unconstrained often pad responses with unnecessary elaboration you did not ask for and would not pay for if you knew.

Context Windows: What They Are and Why Hitting the Limit Breaks Your App

Every LLM has a context window — the absolute maximum number of tokens it can process in a single API call, counting both input and output together. Exceed this limit and you get an API error. Not a warning, not a partial response — an error that will crash whatever you built if you have not handled it.

Here are the limits that matter in 2026:

• GPT-4o: 128,000 tokens (~96,000 words, or about 640 pages of text)
• GPT-4.1: 1,047,576 tokens — effectively an entire book per request
• Claude 3.5 Sonnet: 200,000 tokens (~150,000 words)
• Gemini 2.0 Flash: 1,048,576 tokens (~786,000 words)
• Gemini 1.5 Pro: 2,097,152 tokens — the largest commercially available context window
• Llama 3.1 70B: 128,000 tokens
• Mistral Large 2: 131,072 tokens

The failure mode that hits teams in production is conversation history accumulation. A chatbot starts at 300 tokens per turn. After 30 conversation turns you have 9,000 tokens of history. After 100 turns you are approaching GPT-4o's limit. The solution most teams eventually adopt: summarize older conversation turns into a compact 100–150 token summary rather than passing the full transcript. This keeps the conversation coherent without burning context space on turns from two hours ago.

How to Choose the Right Model for Your Token Budget

The model selection decision is mostly a token economics decision. Here is how to think about it by use case:

• High-volume chatbots and support tools: GPT-4o mini ($0.15 / $0.60 per 1M) or Gemini 2.0 Flash ($0.10 / $0.40 per 1M). Both handle everyday conversation very well at a fraction of flagship costs. Most customer-facing chatbots do not need GPT-4o-level reasoning.
• Complex reasoning, code review, nuanced writing: GPT-4o or Claude 3.5 Sonnet. The quality difference is real and worth the premium when accuracy matters more than cost. These are the models to use when mistakes are expensive.
• Long-document processing (legal, research, books): Gemini 1.5 Pro (2M context) or GPT-4.1 (1M context). Other models will truncate your document or require chunking that degrades quality.
• Budget-constrained batch processing: Llama 3.1 8B via Groq or Together AI ($0.03 / $0.05 per 1M). Genuinely useful for extraction, classification, and simple summarization at near-zero cost.
• Privacy-sensitive workloads: Self-hosted Llama or Mistral. No data leaves your infrastructure, which solves compliance questions entirely.

How to Count Tokens Before Every API Call (Step by Step)

Before running any significant AI workload — a new batch job, a freshly written system prompt, a document processing pipeline — count your tokens first. Guessing is how you end up with API bills that are 3x your budget.

Here is the fastest method using the free LLM Token Counter:

1. Open the token counter — no login, no install, nothing. It runs entirely in your browser.
2. Select your platform and model — OpenAI (GPT), Anthropic (Claude), Google (Gemini), Meta (Llama), or Mistral. Pricing and context window limits update automatically for each model.
3. Paste your system prompt first — this is the single most overlooked step. A 200-word system prompt adds ~260 tokens to every single API request you make, indefinitely. See exactly what that costs at scale.
4. Add a representative user message — paste a typical user input so you see the real combined cost of a realistic request, not just a toy example.
5. Set your expected output length — enter how many tokens you expect the model to generate. This reveals your actual total cost: input and output combined, with separate line items for each.
6. Check the context window bar — if your prompt already consumes 40% of the context window before a single conversation turn, a long chat session will hit the limit in just a few exchanges.
7. Download or copy the report — save it as a cost baseline for budget planning or share it with your team before committing to a provider or deploying to production.

7 Proven Ways to Reduce Token Usage and Cut Your AI Bill

• Rewrite system prompts more concisely. This is almost always the highest-return change you can make. A 500-word system prompt rewritten to 200 words saves 400 tokens on every single API call. At 100,000 calls per month on GPT-4o, that is 40 million tokens saved — roughly $100 per month off your input bill from a single editing session.
• Summarize conversation history. Instead of passing the full chat transcript in every request, have the model periodically compress older turns into a 100–150 token summary paragraph. This keeps the conversation coherent and prevents context window overflow in long sessions.
• Set max_tokens on every request. Never leave it uncapped. If the task needs a one-paragraph answer, set max_tokens: 150. Models that are not constrained will elaborate, explain, and repeat themselves in ways that serve no one except the billing department.
• Remove few-shot examples when they are not needed. Three examples add 300–600 tokens to every request. Test whether zero-shot or one-shot works for your task. Many developers discover that carefully worded zero-shot prompts outperform expensive few-shot prompts they wrote hastily.
• Route simple tasks to smaller models. Not every request needs GPT-4o. Text classification, sentiment analysis, simple yes/no decisions, and data extraction can often run on GPT-4o mini or Gemini 2.0 Flash at 10–20x lower cost with output quality that is indistinguishable for the task at hand.
• Chunk documents intelligently instead of sending everything. If you are answering a question about a 50,000-word PDF, you probably need the relevant 3,000 words — not the whole document. Retrieval-augmented generation (RAG) patterns exist specifically for this: embed the document, retrieve relevant chunks, and send only those to the model.
• Use prompt caching where available. OpenAI and Anthropic both offer caching for frequently repeated system prompts. Cached tokens are billed at 50–90% less than uncached tokens, making it highly effective for high-volume applications with a shared system prompt that does not change between requests.

Common Token Counting Mistakes That Cost Developers Money

• Assuming 1 word = 1 token: The actual average is 1.3 tokens per word in English. A 500-word prompt is 650 tokens. This error compounds hard at scale — at 50,000 requests per day, underestimating by 30% means your month-end API bill is 30% higher than your model predicted.
• Counting only the user message, not the system prompt: The system prompt runs on every single API request. A 300-word system prompt is ~400 tokens multiplied by your total request volume for the month. For an app doing 1 million requests per month, that is 400 million input tokens you may not have budgeted for.
• Treating input and output costs as equal: They are not even close. A request with 500 input tokens and 1,500 output tokens costs roughly the same as a request with 2,500 input tokens — even though the second request sent 5x more input. Output always dominates cost for generative tasks.
• Testing with short prompts and deploying with long ones: It is common to prototype with a minimal 50-word system prompt, then flesh it out to 400 words before deployment. The cost difference is not linear — it shows up as a sudden 8x increase in input token costs that catches teams off guard after launch.
• Not accounting for language differences: Non-English text can use significantly more tokens per character. Japanese, Chinese, Korean, and Arabic often require 2–3x more tokens than equivalent English text, because these languages were underrepresented in the tokenizers' training data and are encoded less efficiently.