Yuval Avidani
Author
"I'm sick of feeling like a sucker." If you've ever looked at your OpenAI, Anthropic, or Google bill and seen rows of input, output, cache write, cache read — and had no idea what you're actually paying for — you're not alone. Today we're going to break this down completely, with real numbers from the official pricing pages, and no BS.
Let's take it slow, because once you understand the mechanism, you stop being afraid of it — and you start saving money.
First off, what even is a token
Let's start with the most basic unit, because everything else is built on top of it. A token is a small piece of text that the model actually "sees" — not a letter, not a whole word, but something in between. The model doesn't read letters like we do; it pre-broke the entire language into common chunks, and each chunk is a token.
Think of it like language Lego. The word "hello" might be one token, but a rare word will break into several pieces. The method itself is called BPE (Byte Pair Encoding), and the idea is simple: whatever shows up a lot gets kept as one piece; whatever's rare gets broken into small pieces. That way the model manages with a limited vocabulary and still covers every text in the world.
And here's a number worth remembering: in English, one token equals roughly 4 characters, or about three-quarters of a word. That's OpenAI's official estimate, and Google says the exact same thing in the Gemini docs. So 100 tokens is roughly 75 English words.
Best to just see it happen. Here's a real engine — type whatever you want, in Hebrew and English, and watch the text break into tokens right in front of you:
The part that hurts us as Israelis: the Hebrew tax
Now notice something we found when we typed Hebrew into that same engine — Hebrew breaks into way more tokens than English, and that costs us money directly.
Let's put numbers on it. If an average English word is about 1.33 tokens, an average Hebrew word was measured at about 5.6 tokens under GPT-4's tokenizer — roughly 4x. In another measurement, on Mistral's tokenizer, Hebrew came out to 5.81 tokens per word — almost a token per letter. And among the world's most extreme languages, the exact same text can cost up to 15x more tokens, depending on the language.
Why does this happen? Because the models were trained mostly on English, so English got the big, efficient chunks, while Hebrew was left with crumbs. That means the exact same question, in Hebrew, simply costs us more than in English — a transparent tax we pay without noticing.
And here's a question I get asked a lot: can you swap the tokenizer to save money? Short answer: no. The tokenizer is baked into the model, fixed, and you can't swap it — not in Claude, not in GPT, not in Gemini. What you *can* do is use Anthropic's endpoint called count_tokens: you send it text before running anything, and it tells you how many tokens it'll cost — for free. Worth its weight in gold when you want to budget ahead of time.
(Small note for those who know: embeddings, those vectors used for smart search, are a completely separate world with their own pricing. Anthropic doesn't even generate them itself — it points you to a provider called Voyage AI. They don't affect chat pricing, so we won't dwell on them today.)
Why output costs 5x more than input
Now for the part that confuses people most on the bill: why does a token the model *outputs* cost so much more than a token we *feed in* (input)? At Anthropic, for example, output costs exactly 5x input. That's not arbitrary — it's physics.
Let's dive into FLOPs for a second. A FLOP is a single computation the processor does, and each token requires roughly twice the model's parameter count in such operations. A model with a hundred billion parameters burns about 200 billion operations on a single token. That's the real, hardware-level cost of "thinking" about one token.
But here's the crucial difference, and this is the heart of it. When we send a prompt, all the input tokens go into the model *in parallel*, all at once — like photographing an entire page in one shot. This stage is called prefill, and it's very efficient because the GPU runs at full throughput. Generating the output, on the other hand — a stage called decode — the model produces one token at a time, and for every new token it has to re-read all its weights from memory — like a writer who writes a word, gets up, runs to the library, comes back, and writes the next word.
The result: generating output is bottlenecked by memory speed, not compute speed, and that's much slower and more expensive. That's why across the whole industry, output tokens are priced at roughly 3x to 5x input tokens. Now that we know this, we already understand half the bill.
And just so we have a sense of scale: the GPUs running all this, like NVIDIA H100, cost about $4/hour to rent in the cloud, and a new B200 card about $7/hour. Every second that machine runs costs money, and that's exactly what we're paying for when we buy tokens. We're not buying "text" — we're buying compute time on expensive hardware, measured in tokens. That's the most basic reason we pay by tokens at all: it's the machine's unit of work, exactly like kWh is for electricity.
Caching: the biggest discount most of us miss
Now let's meet the tool that saves the most money and that the fewest people understand: the cache.
Let's understand the problem it solves. Say we're building an AI agent that sends the same long instructions at the start every single time — the same "system prompt" that's thousands of tokens long. Without caching, the model processes those instructions from scratch on every request, and we pay for them again and again. A cache is short-term memory: the model saves the fixed part of the prompt, and when it comes back around — you read it at a massive discount instead of paying for it again.
And the discount really is massive. At Anthropic, reading from cache costs only a tenth of a regular input price — a 90% discount. There's just one catch: the first write to cache costs a bit more than regular input (1.25x for the short version, 2x for the long version). So you pay a small one-time premium to save a ton on every read that follows.
And why is there a time limit on the cache? Because GPU memory is expensive and limited. Anthropic keeps the cache for five minutes by default, and every time it's used the timer resets for free. If you need more, you can pay for a one-hour version. Think of it like a locker at a train station: it's relatively free for a short stay, but if you want to leave stuff in there a long time — you pay more, because the space is worth money.
So how does the model know what to save and what counts as cache? This is the elegant part: we mark it ourselves. You put a small marker in the code (called cache_control) at the end of the fixed part, and the system saves exactly up to there. On the next request, if the beginning is 100% identical — you get a "cache hit" and the discount; if you changed even one character at the start — the cache is invalidated and has to be rewritten. So here's the golden rule: put whatever's fixed (instructions, background docs) at the start, and whatever changes (the user's question) at the end.
Let's see this with a real example. Say we're running a customer service bot with an 8,000-token instruction manual:
- Without caching: every conversation pays for the full 8,000 input tokens, from scratch, every single time.
- With caching: you pay for the 8,000 tokens once (plus a small premium), and then every additional conversation pays only a tenth for those same 8,000 — up to 90% savings on the fixed part.
Here's a real calculator. Play with the sliders — how much input, how much output, how much comes from cache, how many requests per month — and watch the price move yourself, for every Anthropic model:
Anthropic's real price list, no surprises
Now that we understand the units, let's put the full price list on the table. All the numbers below are per million tokens, in dollars, from the official pricing page, as of July 2, 2026:
| Model | Input | Output | Cache write (5 min) | Cache read |
|---|---|---|---|---|
| Claude Haiku 4.5 | $1 | $5 | $1.25 | $0.10 |
| Claude Sonnet 5 (launch price) | $2 | $10 | $2.50 | $0.20 |
| Claude Opus 4.8 | $5 | $25 | $6.25 | $0.50 |
| Claude Fable 5 | $10 | $50 | $12.50 | $1 |
Three things worth flagging. First, Sonnet 5 is at a launch price of $2 and $10 until the end of August 2026, after which it jumps to $3 and $15 — if you're planning a project, good to know. Second, there's a 50% Batch discount if you don't need an immediate answer. Third, the cache (the right-hand columns) is really where the big cut in your bill happens.
Which model actually pays off: value per dollar
Price alone tells you nothing — the question is how much intelligence you get per dollar. For that there's an independent benchmark called the Artificial Analysis Intelligence Index, which ranks models on performance across nine different tests. We cross-referenced each model's score against its average price, and got a map of who's actually worth it and who isn't.
The chart below is the heart of this. The higher a model sits — the smarter it is; the further right — the cheaper it is. The top-right corner is heaven: smart and cheap. Notice where Opus 4.8 (in purple) sits versus Fable 5:
What's fascinating here: Fable 5 is the smartest (60 points), but also the most expensive; Opus 4.8 gives up four points of intelligence and gets half the price in return. And on the other end, models like Gemini Flash and MiniMax give you decent intelligence for really cheap. There's no "best model" here — there's only the right model for your task and your budget.
Monthly subscription or API? The question that's worth real money
Now for the question everyone asks: work with the API, pay per token, or buy a monthly subscription? Let's understand what each one actually gives you.
The API is usage-based: you pay per token, no upper limit, perfect for apps and automations. The monthly subscription is a fixed sum for personal use through the chat and tools. And here's the annoying part: Anthropic, like everyone else, doesn't publish exactly how many tokens you get with a subscription — just "5x" or "20x" relative to Pro. There's a five-hour rolling window limit and two weekly limits, but they won't give you the exact number. That's on purpose: this way they can change it without changing the price.
Here's what we do know, and it's a fair comparison to put on the table:
| Subscription | Price/month | Roughly what you get |
|---|---|---|
| Claude Pro | $20 | Medium usage, including Claude Code |
| Claude Max 5x | $100 | 5x the usage of Pro |
| Claude Max 20x | $200 | 20x the usage of Pro |
| ChatGPT Plus / Pro | $20 / $200 | Plus is regular, Pro is almost unlimited |
| Google AI Pro / Ultra | $19.99 / $100–200 | Gemini Pro, storage, perks |
| GitHub Copilot Pro | $10 | Unlimited code completions + $15 credit |
| GLM Coding (Z.ai) | $18+ | Cheap alternative for coding agents |
In my view, the rule of thumb is simple: if you're using it personally through the chat — a subscription is almost always cheaper. If you're building a product that fires off requests automatically — API is the way, because a subscription isn't built for that at all. And for anyone who asked about AWS Bedrock: the per-token price there is identical to Anthropic's direct price, so the difference is in infrastructure and billing, not in token cost.
So how much does one infographic cost? Nano Banana vs GPT
Now we get to my favorite part, because it's practical. Say we want to generate one high-quality infographic image, 1024x1024. How much does that cost across different tools? Here are the official numbers, in dollars per image:
Interesting to see that Google's cheap-tier Nano Banana generates an image for under 4 cents, while the leading models from Google and OpenAI sit around 13 to 21 cents per image. And here's a point worth knowing: Anthropic doesn't generate images at all. Claude can analyze an image you show it, but it can't draw — that's why it's not on this chart at all.
And speaking of generating images — here's a real, copy-paste-ready prompt that produces a clean, professional infographic with an image model. Notice how specific it is, because precision in the prompt is the difference between an amateur-looking image and one that looks like a magazine cover:
Bottom line, and my take
So let's wrap this up in a format I like. A token is the model's unit of work — a small piece of text that costs money because it consumes real compute time on expensive hardware, for anyone using AI. Input is cheap, output is 5x more expensive because it's inherently slow, and caching is the tool that cuts your bill by 90% on anything repetitive.
In my view, the most liberating thing in this whole story is that once you understand the units, you stop being a sucker. You can pick a model based on value per dollar instead of hype, design prompts that take advantage of caching, write in English when cost is critical, and choose correctly between a subscription and the API. That transparency is our power.
My caveats here, because without them this is basically an ad: prices change all the time — everything I wrote is accurate as of July 2, 2026, and it's always worth checking the official pricing page before deciding anything. Some of the subscription numbers are estimates, because the companies simply don't publish everything. And this is obviously not investment advice or financial counsel — just a breakdown of how things work.
And if transparency really is our power, here's the question I want to leave you with: now that we know exactly what we're paying for — what's the first thing we're going to change about the way we work with AI?