Every AI price and every usage limit comes down to one unit. Here's what it is, where it piles up, and the simple checks I use so the bill never surprises me.
You ask a chatbot a quick question and get a quick answer. It feels free. Then one day you paste in a long report, switch on the "think harder" mode, or leave an agent running over lunch, and suddenly you've hit your monthly limit or the invoice has jumped.
Both moments run on the same meter. You pay for text going in and text coming out, and the expensive parts are the answers the model writes and the long history it re-reads on every turn.
You're not paying for questions. You're paying for every token the model reads, writes and quietly thinks.
Once that clicks, pricing pages stop looking like a foreign language. Here's how to read the meter.
What a token is
A token is a small chunk of text that a language model reads and writes. Sometimes it's a whole word, often it's part of one, and sometimes it's just a comma. The model splits your message into tokens, works through them, then writes its reply one token at a time.
The rule of thumb for English, from OpenAI's own help material: about 100 tokens is roughly 75 words. So one token is about three-quarters of a word, or around four characters.
Treat this as a guide, not a law. Small things change the split: a capital letter or a space in front of a word can turn it into a different token. Other languages don't follow the English ratio at all, so if you work in another language, count your own text.
Anthropic has published rough sizes for real documents: an average webpage lands in the low thousands of tokens, a big documentation page in the tens of thousands, and a long research PDF can run past a hundred thousand.
Try it yourself. OpenAI has a free tokenizer page on its platform site. Paste in one of your own emails and watch it light up in chunks. Then paste the same text with different capitalisation. Two minutes of this teaches more than any explainer.
Input, output, cached, reasoning
Four kinds of tokens show up on a serious bill, and each is priced differently.
The last row is the one that catches people. A reasoning model can think through a problem at length and then hand you three lines. You see three lines. You pay for the thinking too. Short answer, big meter.
Tool definitions are the quiet one. In an agent setup, every tool you leave switched on gets described to the model with each request. That description is input, and you pay for it whether the tool gets used or not.
How tokens set the price
There are two ways you pay.
API pricing is what developers use when they plug AI into their own apps. You pay per million tokens, with one rate for input and a higher rate for output. Rates differ a lot between models and they change often, so check the provider's pricing page the week you build a budget.
Subscriptions like ChatGPT, Claude, Gemini or Grok plans charge a flat monthly fee with usage limits. There's no token line on your invoice, but tokens still decide when you hit the wall. The wasteful habits are the same. The symptom is different: a slowdown or a "come back later" message instead of a bigger bill.
One trap: a cheaper model is not automatically cheaper. A budget model that needs five attempts, or writes a page when you wanted a line, can cost more than a top model that gets it right once. Price per token is not price per result.
Where the meter spins fastest
Output and reasoning. Long answers and deep thinking are the priciest tokens you buy.
Long chats. Most models don't remember anything between turns. The app resends the whole conversation every time you reply. A 40-turn chat means turn 41 pays to re-read the first 40.
Stuffed context. Attach ten long documents to every question and you've spent thousands of input tokens before the model writes a word.
Agents in loops. Each step can resend instructions, history and tool results. Without a cap, it's like leaving the oven on overnight.
Public post-mortems of runaway agent bills do exist: loops that ran for days, no kill switch, sub-agents that kept going after the main one stopped. Treat any dollar figures in those stories as reported, not as a forecast for you. The lesson holds either way: put hard limits outside the model.
What this looks like on a real invoice line
Here's a walk-through with illustrative numbers, worked out from the rule of thumb above. Three jobs on the same Tuesday:
1. Rewrite a 150-word email in a warmer tone, on a small model. 150 words is about 200 tokens in, and roughly the same out. Cheap. Done.
2. Ask questions about a long PDF. Say the file comes to 30,000 tokens. You keep it in the chat and ask ten questions. Because the whole conversation is resent each time, you pay to read the file ten times: about 300,000 input tokens, before any answers. Now do it differently. Ask the model once for a tight summary of about 1,000 tokens, start a fresh chat with just the summary, and ask your ten questions there. That's 30,000 to read the file once, plus about 10,000 for the questions: roughly 40,000 in total. Around a seventh of the first approach, for the same work.
3. An agent that retries a flaky web form ten times. Say it starts with 5,000 tokens of instructions and context, and each failed attempt adds 2,000 more to its history. Attempt one sends 5,000. Attempt ten sends 23,000. Across all ten, that's 140,000 input tokens for a form that should have cost 5,000. The bill isn't the form. It's the loop.
Same "AI subscription." Three very different meters. When someone asks why usage spiked, bring the loop story, not a shrug.
If you remember one pattern from this piece: output and reasoning usually cost several times more than input. Asking for shorter answers isn't a style preference. It's cost control.
Seven habits that cut the bill (or stretch the plan)
Right-size the model. A mid-range model for daily work, the top model only when you're stuck, a small model for high-volume simple jobs.
Start a new chat when the topic changes. Don't drag 40 turns of history into a new problem.
Paste less. Summarise the brief yourself, or give the model only the pages that matter.
Ask for short answers when you don't need an essay. Output is the expensive side.
Switch off unused tools in agent setups so their descriptions aren't in every request.
Use caching where your platform offers it, especially for long instructions you send again and again.
Cap your agents. Step limits, spend ceilings, timeouts and loop detection, set before the first run you're not watching.
On a flat subscription, these habits won't shrink the invoice. They push back the moment you hit the limit.
Subscription or pay-per-token?
A simple monthly check
Once a month, open your usage page, whether that's your plan's limits or your API dashboard, and answer four questions:
Which project used the most?
Was it a person chatting, a document-heavy job, or an agent loop?
Did a top model do work a small one could have handled?
Does any agent run without a hard stop?
If you can't answer those, you don't have cost control yet. You have hope, and hope is not a brake.
When I hand over an agent, the setup always includes a maximum number of steps, a maximum spend or token count per run, an alert channel, and a named person who gets the alert. The model doesn't get a vote on whether those exist. Same personal rule for anything else: if it spends money or sends something in my name, it waits for a yes.
FAQ
Is a token the same on every model? No. Each provider splits text its own way, so the same paragraph can come out as a different token count, and a different price, on different models.
Why did a short answer cost so much? Usually one of three things: hidden reasoning, a long history being resent, or tool descriptions riding along with every request. Your usage dashboard, where there is one, will show which.
What's the single biggest waste? In the setups I see: a top model doing routine work, and agents with no kill switch.
The takeaway
Tokens are the electricity bill of AI. Know what fills the meter: what you send, what comes back, what gets cached and what the model thinks in private. Keep chats short, keep answers tight, and put brakes on anything that can loop. Cheap per question is not the same as cheap per result.
About Me
I’m Laurent Terrijn, an engineer and business builder. I build the systems businesses run on. On the side, out of curiosity, I explain AI in plain English for busy business people. I’m a nerd who speaks ten languages and loves learning. If this helped, follow along for the next one. More at laurentterrijn.com.
