What a million tokens really costs.

As of September 23, 2026, across the 13 models compared here, a million input tokens costs anywhere from $0.10 (OpenAI’s GPT-6 Luna) to $10 (Claude Fable 5.1 and GPT-6 Astra), and a million output tokens from $0.50 to $50. That is a 100-fold spread between the cheapest and the most expensive models.

LLM API pricing is only half the story, though. What you actually pay depends on how many tokens a task uses, how much of each prompt is served from cache, and whether the job can wait for a batch discount. This guide covers all three, with prices from each vendor’s official pricing page.

01LLM API pricing at a glance (September 2026)

Prices are in US dollars per million tokens, for standard requests under each vendor’s long-prompt threshold. We checked every number on the official pricing pages on September 23, 2026.

Two warnings before you compare rows. A token is not the same size everywhere: Anthropic says its current tokenizer produces about 30% more tokens for the same text than its previous one. And OpenAI and Anthropic charge extra to write to the cache, covered below. If tokens themselves are new to you, start with our guide to tokens and context windows.

02Why output costs more than input

Reading your prompt is fast, because the model processes all of it at once. Writing is slow, because it generates one token at a time. Vendors price that difference in: across this table, output costs 3 to 6 times as much as input.

Reasoning makes the gap bigger. When a model thinks before it answers, those hidden thinking tokens are billed as output. Google’s pricing page says so outright (“including thinking tokens”), and xAI lists reasoning tokens as a billed type. A short answer after a long think can cost more than a long answer without one.

03The discounts that change the math

Every vendor discounts repeated input and patient jobs, but the rules differ. This is where two models with the same list price can end up with very different bills:

DeepSeek’s peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays other than Chinese public holidays; everything else, including weekends, is off-peak. Caching only kicks in above a minimum prompt size, such as 1,024 tokens for OpenAI’s newest models and 4,096 for Gemini 3.8 Flash and 3.1 Pro. Our guide to cutting your AI bill shows how to structure prompts so the cache actually hits.

04What typical tasks cost, worked out

Here are three everyday jobs, costed with the prices above. The token counts are our assumptions, chosen to be typical rather than extreme:

• A chatbot reply: 2,000 input tokens (instructions, history and a help article) and 300 output tokens, no caching. Shown per 1,000 replies.

• Sorting reviews overnight: 100,000 product reviews at 400 input tokens and 10 output tokens each.

• A long coding-agent session: 2.5 million input tokens across many calls, 90% of them cache reads, plus 50,000 output tokens. New input is billed at the cache-write rate where one applies.

Three lessons stand out. A single chat reply costs between 0.035 cents and 3.5 cents, so model choice matters more than prompt trimming at small scale. Batch discounts halve bulk jobs at most vendors, but not on Grok 4.7. And caching cuts the agent session by 64% to 82%, a big part of why long agent sessions stay affordable.

05Hidden costs that are not on the price list

These extras show up on real bills too:

• Tool definitions. Every tool you offer the model adds input tokens to each request. On Claude, enabling tool use adds a few hundred tokens of system prompt, and the computer use toolset adds about 4,500.

• Search. Web search costs $10 per 1,000 searches at Anthropic and OpenAI and $5 per 1,000 at xAI. Google includes 5,000 grounded searches a month, then charges $14 per 1,000.

• Long prompts. Crossing 200,000 or 272,000 tokens can double the input price for the whole request on some models.

• Data location. Keeping processing in one region adds about 10% at Anthropic (US-only), OpenAI (regional endpoints) and xAI (its US endpoint).

• Growing conversations. Each turn resends the history, so a 30-turn chat costs far more than 30 separate questions. Caching softens this.

06How to estimate your own bill

You can get within a reasonable margin in an hour. Here is the method:

1. 01

   Measure real token counts

   Send 20 typical requests and read the input, cached and output token counts that every API returns. Real averages beat any rule of thumb.

2. 02

   Multiply by the price

   Cost per request is input tokens times the input price, plus output tokens times the output price, divided by one million. Add cached tokens at the cached price.

3. 03

   Add overhead

   Add 10% to 20% for retries, tool definitions and odd long requests until your logs tell you the real figure.

4. 04

   Apply the discounts you will really use

   Batch only what can wait up to a day. Count on cache hits only for prefixes that repeat within the cache lifetime.

5. 05

   Set a hard limit

   Set a monthly spend limit and an alert in the vendor’s console before launch, not after the first surprise.

The arithmetic fits in a few lines. This version handles caching too:

# Prices are dollars per million tokens. Token counts are per request.
def monthly_cost(requests, input_tokens, output_tokens, input_price, output_price,
                 cached_share=0.0, cached_price=0.0):
    fresh = input_tokens * (1 - cached_share) * input_price
    cached = input_tokens * cached_share * cached_price
    output = output_tokens * output_price
    return requests * (fresh + cached + output) / 1_000_000

# 30,000 support replies a month on a $2 in / $10 out model
print(f"No caching:  ${monthly_cost(30_000, 2_000, 300, 2.00, 10.00):,.2f}")
# Same job with 80% of each prompt served from cache at $0.20
print(f"80% cached:  ${monthly_cost(30_000, 2_000, 300, 2.00, 10.00, 0.8, 0.20):,.2f}")

We ran it with Python 3.10 and 3.14:

No caching:  $210.00
80% cached:  $123.60

It leaves out cache-write premiums, which the overhead allowance above covers.

07FAQ

Next, learn how to cut your AI bill without worse results, or find out when a small model beats a giant one.