LLM Tokens and Pricing Explained (2026): $0.10 to $50 per Million

The first LLM bill that surprised me was not large, it was just wrong by a factor I could not explain until I sat down with the usage export. The prompt was the same size it had always been; the model had changed, and with it the tokenizer, the cache price and the number of invisible reasoning tokens. This post explains LLM tokens and pricing as they stand in November 2026: what a token is, why the same text produces different token counts, the four meters every provider now bills on (input, output, cached and reasoning), the current per-million-token prices for OpenAI, Anthropic and Google, the discounts and premiums stacked on top, and a small script for estimating a monthly bill before finance asks.

What is a token in an LLM?

A token is the unit the model reads and writes. Before your prompt reaches the model, a tokenizer splits it into pieces from a fixed vocabulary, usually built with byte-pair encoding: common words become one token, rare words become several, and whitespace, punctuation and bytes that are not in the vocabulary get their own pieces. The model never sees characters, and the provider never bills characters. Every price on every pricing page is per token, almost always quoted per million tokens (MTok).

The practical consequence is that "how long is my prompt" has no single answer. It depends on the language, the content type and the tokenizer of the model you call. Rules of thumb such as "four characters per token" hold for plain English prose and fall apart for JSON, code, logs and most non-Latin scripts. OpenAI's own token counting guide says character-based estimates are inaccurate once images, files, tools or schemas are involved, and that the counting API includes the formatting tokens used for roles and message boundaries, which a local tokenizer will not see.

Why the same prompt has a different token count on every model

I ran four strings through two of OpenAI's open-source tokenizers with tiktoken 0.14.0: cl100k_base (the GPT-4 and GPT-3.5 era) and o200k_base (GPT-4o through GPT-5, according to tiktoken's model table).

# tok.py: count the same strings with two tokenizers (pip install tiktoken==0.14.0)
import tiktoken

samples = {
    "English sentence": "The deployment failed because the readiness probe timed out after 30 seconds.",
    "JSON log line": '{"level":"error","ts":"2026-11-10T09:14:02Z","pod":"api-7d9f","msg":"probe timeout"}',
    "Hindi sentence": "तैनाती विफल रही क्योंकि रेडीनेस प्रोब 30 सेकंड के बाद टाइम आउट हो गया।",
}
for name in ("cl100k_base", "o200k_base"):
    enc = tiktoken.get_encoding(name)
    for label, text in samples.items():
        print(f"{name:12} {label:17} chars={len(text):4} tokens={len(enc.encode(text)):3}")

# Output on my machine, 10 Nov 2026:
# cl100k_base  English sentence  chars=  77 tokens= 14
# cl100k_base  JSON log line     chars=  84 tokens= 35
# cl100k_base  Hindi sentence    chars=  70 tokens= 70
# o200k_base   English sentence  chars=  77 tokens= 14
# o200k_base   JSON log line     chars=  84 tokens= 35
# o200k_base   Hindi sentence    chars=  70 tokens= 24

Three things fall out of that run. English prose came in at 5.5 characters per token on both. The JSON log line, which is the kind of text agents and observability pipelines push through models all day, came in at 2.4 characters per token: punctuation, quotes and timestamps are expensive. And the Hindi sentence cost 70 tokens on the older vocabulary and 24 on the newer one, nearly a 3x difference for identical text. A short Python function I also tested came in at 36 and 37 tokens, so code was roughly a wash.

The same effect runs the other way on Claude. Anthropic's pricing page states that Claude 4.7 and later models use a newer tokenizer that "produces approximately 30% more tokens for the same text", while Sonnet 4.6 and earlier use the previous one. A per-token price cut can therefore be partly eaten by a token-count increase, and you only see it if you recount. Anthropic's token counting docs say exactly that: do not reuse counts measured on an older model.

Two more cautions. tiktoken's mapping table still stops at the gpt-5 prefix, so for the GPT-6 family I would not assume a local tokenizer matches the billed count; OpenAI ships a POST /v1/responses/input_tokens endpoint for that. Anthropic's POST /v1/messages/count_tokens is free, rate limited separately (5,000 RPM on the Start tier), and returns an estimate that can differ "by a small amount" from the billed number. Gemini prices are per token too, with its own tokenizer. Count with the model you will actually call.

Input, output, cached and reasoning tokens: the four meters

Every major API now bills on at least four meters, and they are priced very differently.

Input tokens are everything you send: system prompt, tool definitions, conversation history, retrieved documents, images converted to tokens. In agent loops this is usually the biggest count, because the whole history is resent on every turn.

Output tokens are what the model generates. Across all three vendors in the table below, output costs between five and about eight times input. On every OpenAI flagship and every current Claude model I list, the ratio is exactly 5x.

Cached input tokens are input the provider recognises as a prefix it has already processed. They are billed at a steep discount, but caching has its own write price. On Claude, a 5-minute cache write costs 1.25x base input and a 1-hour write 2x; a cache hit costs 0.1x on most models, 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1 and 5.2. OpenAI's pricing page now lists cached input plus separate 30-minute and 12-hour write prices for each flagship model. Google adds a twist: Gemini context caching charges a per-token caching price and an hourly storage fee, $0.50 per million tokens per hour on Gemini 3.8 Flash. I covered the mechanics in Prompt Caching Explained; for this post the point is that "cached" is a separate line item with its own price.

Reasoning tokens are the model's thinking. They are the ones that catch people out, because you are billed for tokens you never see. OpenAI's reasoning guide says reasoning tokens are not visible via the API but "are billed as output tokens", and reports them in usage.output_tokens_details.reasoning_tokens. Its example response has 1,186 output tokens, of which 1,024 were reasoning. Anthropic's thinking docs say the same of Claude: thinking is billed as output even when the text is omitted, and the billed output count will not match the tokens you see. Google labels the Gemini output price "including thinking tokens". If a model's answer looks short and its output bill looks long, this is why.

LLM API prices per million tokens in November 2026

These are standard (pay-as-you-go, global routing, short-context) list prices per million tokens, checked on the vendors' pages on 10 November 2026. Several are about to change, which I note in the last column.

Model	Input	Cached input	Output	Notes	Source
OpenAI gpt-6-astra	$10.00	$1.00	$50.00	$20 / $75 above 272K input tokens	OpenAI
OpenAI gpt-6.1-sol	$2.00	$0.10	$10.00	$4 / $15 above 272K input tokens	OpenAI
OpenAI gpt-6.1-terra	$1.00	$0.05	$5.00	$2 / $7.50 above 272K input tokens	OpenAI
OpenAI gpt-6-luna	$0.10	$0.01	$0.50	$0.20 / $0.75 above 272K input tokens	OpenAI
Claude Fable 5.2	$8.00	$0.20	$40.00		Anthropic
Claude Opus 5.5	$4.00	$0.20	$20.00		Anthropic
Claude Sonnet 5.5	$2.00	$0.10	$10.00		Anthropic
Claude Haiku 5.5	$0.10	$0.01	$0.50	$0.50 / $2.50 above 100K prompt tokens	Anthropic
gemini-4-argon	$2.00	$0.10	$10.00	doubles to $4 / $20 on 1 Dec 2026	Google
gemini-3.8-flash	$0.75	$0.075	$3.75	doubles to $1.50 / $7.50 on 1 Jan 2027	Google
gemini-3.5-flash-lite	$0.30	$0.03	$2.50		Google

Two observations. First, the spread is 100x on both input and output between the cheapest and most expensive rows, which is why model choice is the biggest cost lever you have. And in the middle, the list prices have converged: gpt-6.1-sol and Claude Sonnet 5.5 are identical on input, cached input and output, so the real difference between them on your bill is token count (tokenizer), how many reasoning tokens each spends on your task, and cache hit rate. Also watch for scheduled changes: Gemini 4 Argon's input and output prices double on 1 December, GPT-5.6 Sol's promotional price ends on 30 November, and Anthropic made Sonnet 5's introductory $2 / $10 the permanent price rather than raising it in September.

Batch, flex and fast mode: discounts and premiums

List price is the middle of a range. All three vendors give 50 percent off for asynchronous batch work: Anthropic's Batch API halves input and output and lets the discount stack with cache multipliers, OpenAI prices Batch and Flex together at half of standard, and Google's batch tier is 50 percent of standard. If a job can wait (nightly evals, back-filling embeddings for a search index, classifying a support backlog), sending it synchronously is paying double for latency nobody needs.

At the other end, speed costs extra. OpenAI renamed Priority processing to Fast mode on 30 July 2026 and lists it at 2x standard, with an Ultrafast tier at 6x (gpt-6-astra output is $300 per million there). Anthropic's fast mode for Opus 5.5 is $8 / $40, also 2x, and is not available through batch. Data residency adds a smaller uplift: 1.1x on Claude when you set inference_geo: "us", and a 10 percent uplift on OpenAI regional endpoints for models released on or after 5 March 2026. Long context can step the price up too, as the OpenAI and Haiku 5.5 rows show.

The order I apply these in is boring and reliable: right-size the model, cache the stable prefix, push anything non-interactive to batch, and pay for fast mode only on the one user-facing path where latency is the product. The LLM cost-cutting guide walks through each with code.

How to estimate a monthly LLM API bill

The estimate needs five numbers per workload: requests per month, uncached input tokens, cached input tokens, visible output tokens and reasoning tokens. Get the token numbers from real usage objects on a sample of traffic, not from character counts. Then multiply by the price sheet.

# estimate_llm_bill.py: monthly LLM API cost from token counts (Python 3.10+, no dependencies).
# Prices: USD per 1M tokens from the vendors' pricing pages on 10 Nov 2026.
PRICES = {
    #  model               input  cache_read cache_write  output
    "claude-sonnet-5-5": (2.00,  0.10,      2.50,        10.00),  # 5-minute cache write
    "gpt-6.1-sol":       (2.00,  0.10,      2.50,        10.00),  # 30-minute cache write
    "claude-haiku-5-5":  (0.10,  0.01,      0.125,       0.50),   # prompts up to 100K tokens
    "gpt-6-luna":        (0.10,  0.01,      0.125,       0.50),
}

requests_per_month = 20_000 * 30        # 20k requests a day
cached_in = 2_000                       # stable system prompt + docs
uncached_in = 1_000                     # the per-request part
cache_writes_per_month = 12 * 24 * 30   # assume one prefix rewrite every 5 minutes
visible_out = 400
reasoning_out = 600                     # billed as output, never shown

def monthly(model, use_cache=True, batch=False):
    p_in, p_read, p_write, p_out = PRICES[model]
    m = 1_000_000
    if use_cache:
        cost_in = (requests_per_month * uncached_in * p_in
                   + requests_per_month * cached_in * p_read
                   + cache_writes_per_month * cached_in * p_write) / m
    else:
        cost_in = requests_per_month * (cached_in + uncached_in) * p_in / m
    cost_out = requests_per_month * (visible_out + reasoning_out) * p_out / m
    return round((cost_in + cost_out) * (0.5 if batch else 1), 2)

for model in PRICES:
    print(model, monthly(model, use_cache=False), monthly(model), monthly(model, batch=True))

# Output:
# claude-sonnet-5-5 9600.0 7363.2 3681.6
# gpt-6.1-sol 9600.0 7363.2 3681.6
# claude-haiku-5-5 480.0 374.16 187.08
# gpt-6-luna 480.0 374.16 187.08

For this made-up but typical workload (600,000 requests a month, 3,000 input tokens and 1,000 output tokens each), the mid-tier models cost $9,600 a month uncached and $7,363 with a two-thirds cache hit on the input. The more interesting number is inside the cached figure: $6,000 of the $7,363 is output, and $3,600 of that is reasoning the user never reads. Caching fixed the input side; only effort settings, a shorter answer format or a cheaper model move the output side. Dropping to the small tier takes the same workload to $374, a 20x difference, and batch halves whatever is left. Treat batch-plus-cache as an upper bound until you have measured your batch cache hit rate.

Three things the script does not model, and your bill will: retries (each one resends the full input, and a response cut off at max_output_tokens can bill input and reasoning with no visible answer, per OpenAI's reasoning guide; the companion guide on fixing 429 and 529 rate limit errors covers retrying without multiplying cost), agent loops that resend a growing history every turn, and tool definitions, which are input tokens on every call. For the governance side of this (budgets, allocation, the FOCUS token columns), see FinOps for AI.

FAQ

How many words is 1,000 tokens?

It depends on the tokenizer and the text. In my tiktoken test, a 12-word English sentence was 14 tokens, about 5.5 characters per token, which works out to roughly 850 words per 1,000 tokens for plain prose. JSON and logs are far denser in tokens, and many non-Latin scripts tokenize very differently between vocabularies, so measure your own content with the provider's counting endpoint.

Are reasoning tokens billed?

Yes. OpenAI bills reasoning tokens as output tokens and reports them in output_tokens_details.reasoning_tokens. Anthropic bills Claude's thinking as output even when the thinking text is omitted from the response, and Google's Gemini output price explicitly includes thinking tokens. Lowering the effort or reasoning setting is the main way to control them.

Why is output more expensive than input?

Input tokens are processed in parallel in one prefill pass, while output tokens are generated one at a time, each needing its own pass through the model. That makes output far more expensive to serve per token, and current price sheets reflect it: output is 5x input on every OpenAI and Claude model in the table above.

Is the Batch API always 50% cheaper?

On list price, yes for all three vendors as of November 2026, on both input and output. The catch is latency: batch jobs are asynchronous and not suitable for interactive requests, and Anthropic's fast mode cannot be combined with batch. On Claude, cache multipliers stack with the batch discount, so a cached batch request is cheaper still.

What I would do this quarter

If I were responsible for an LLM bill this quarter, I would pull a week of usage objects and split spend into the four meters before touching anything, because the reasoning share is the number I would least trust myself to guess. Then I would recount prompts on any model migrated in the last six months, move every non-interactive job to batch, and diary the 1 December and 1 January Gemini price changes and the 30 November end of GPT-5.6 Sol's promotion. None of that is clever. It is the same discipline as reading a cloud bill line by line, applied to a meter that runs much faster. If you are weighing whether to stop paying per token at all, the break-even maths is in Self-Hosting LLMs vs API Costs.

Related: Prompt Caching Explained (2026): 0.05x Reads, 5-Minute TTLs, Real Math, How to Cut LLM API Costs: Prompt Caching, Batching, Routing (2026) and FinOps for AI in 2026.