AI API pricing in 2026: calculate token usage and your budget

You put money into an API account and almost immediately run into the question: how long will it last? You have something like “I’ve got ten thousand, input costs this much, output costs more, there’s some kind of cache discount too” in your head—and it’s unclear how to turn all that into one number. I’ll break it down in order, with numbers.

The main point up front: an API bill is calculated with one formula—number of tokens multiplied by the price per token. Input and output tokens are counted separately because they have different prices. Next, I’ll show how to use this to work out how long your budget will last and where caching comes into the calculation.

Information about using Ailoot is available in the documentation.

How AI API pricing adds input and output token costs#

When you call a model through an API, you’re charged for the amount of text that passed through the model. That amount is measured in tokens. A token is a small piece of text; I’ll come back to it in the next section, but for now, think of it as the unit everything is measured in.

A single call has two sides. The first is what you sent to the model: the question itself, attached pieces of code or a document, previous messages in the conversation, and the system instruction at the beginning. This is input. The second is what the model wrote in response. This is output. DeepSeek says it directly in its pricing description: the bill is based on the total number of input and output tokens.

Input and output have different prices, so they’re counted separately. The formula for one request is simple:

cost = (input tokens × input price) + (output tokens × output price)

Prices are usually listed per million tokens—that’s more convenient because a single token costs a fraction of a monetary unit. All the arithmetic from here on revolves around this formula, and your budget covers exactly as many requests as fit within your available funds at that price.

A Token Isn’t a Word: How Can You Estimate How Many You’ll Use?#

The first thing everyone trips over: a token is not the same as a word. The model splits text into chunks according to its own rules, and a chunk can be a whole short word, part of a longer one, a space with a letter, or a punctuation mark. So you can’t work out exactly in your head “how many tokens my request will take”—you can only estimate.

Here’s a rough guide. In English text, one token corresponds to about four characters; that’s a starting point from Anthropic and OpenAI themselves. Models split Russian text into smaller pieces: Cyrillic is broken into shorter chunks, so the same text in terms of meaning uses more tokens. How many more depends on the model, but you should allow for one and a half to two times as many as in English.

Here’s what that looks like in tokens. If you send the model a page of text and get a paragraph in response, that’s already thousands of input tokens and hundreds of output tokens. And if you attach a large file to a request or carry a long conversation history, input can grow to tens of thousands of tokens, with the lion’s share of the bill coming from that. The API response will show the exact figure—in its metadata fields, it returns how many tokens were actually used for input and output. But for estimating your budget in advance, a rough character-based estimate is enough.

Why Does Output Cost More Than Input, and How Does That Affect Your Bill?#

Here’s a table of official prices per million tokens as of early September 2026—you can see that output costs several times more than input across the board.

The price gap between providers is enormous: one million input tokens for Claude Opus 5 costs as much as about 7.58 million for DeepSeek Pro at the table’s input rates ($5 ÷ $0.66 ≈ 7.58). But within each pricing tier, one rule holds: output costs three to six times more than input. The reason is simple: it’s easier for the model to read your request than to write a response, and the more demanding work costs more.

That leads to a conclusion that directly affects your bill. A long response is more expensive than a long question. If you ask the model to “explain it in as much detail as possible,” you’re inflating the most expensive part of the bill yourself. The same meaning packed into a short answer costs several times less. This is one reason vibe coding is cheap for one person but burns through another person’s budget in a day—even with the same model.

How Can You Calculate How Long Your Budget Will Last?#

Let’s put it all into a step-by-step calculation. Plug in your own prices, typical token volume, and budget.

1. Estimate a typical request. Suppose one call uses 20,000 input tokens (the question plus a piece of code and some history) and 2,000 output tokens (the model’s response).
2. Calculate input cost: divide the number of input tokens by one million and multiply by your input price per million tokens.
3. Calculate output cost: divide the number of output tokens by one million and multiply by your output price per million tokens.
4. Add the input and output costs.
5. Divide your budget by the resulting cost per request.

Using the Opus 5 rates in this article’s table: 20,000 ÷ 1,000,000 × $5 = $0.10 for input, and 2,000 ÷ 1,000,000 × $25 = $0.05 for output. Total: $0.15 per uncached request. A $10 budget covers 66 whole requests ($9.90), assuming the same token counts and no other charges.

A real request is almost never “average”: attach a large file or stretch out a long conversation, and input grows from 20,000 tokens to 200,000. So calculate based on your usual way of working; an idealized request will give you the wrong answer. It’s also better to round up.

Devin, Claude Code, and any other AI agent use the same API and spend tokens according to the same formula—the only difference is that an agent uses more because it makes many calls behind the scenes. I covered separately why this makes vibe coding cost more than expected in the article about the hidden cost of vibe coding.

What Is the Cache Discount, and When Does It Apply?#

Now for caching—the “up to 80 percent discount” that makes the calculation seem complicated. The mechanics are simple. Some input stays the same from one request to the next: the system instruction at the beginning, a large piece of context, or an attached document you work with over several calls. Caching lets the model avoid rereading that piece from scratch each time and retrieve it from memory at a much lower price.

How much lower depends on the provider. For Claude, rereading from cache costs ten times less than regular input: for Opus 5, regular input is $5 per million, while a cache read is $0.50. DeepSeek’s discount is even steeper: cached input for the flash model costs $0.007 versus $0.22 for regular input, more than thirty times less. So “up to 80 percent off” is a modest estimate; the actual discount can be greater.

Keep two conditions in mind, or your cache calculation will be off.

• The discount applies only to repeated input. The model generates output from scratch each time, and it gets no cache discount at all. If most of your bill comes from long responses, caching will save you very little.
• The first write to the cache costs slightly more than regular input. For short-term storage, Claude charges 1.25 times the regular input price for a cache write. Savings begin with the second request, which reads the piece that was already cached. Caching won’t help at all on a one-off request and will even cost slightly more.

How Do You Recalculate Your Budget to Account for Caching?#

Let’s return to the example request volume and add caching. The idea is to split input into two parts: the part that repeats and qualifies for the discount, and the part that is new in each request.

Take the same request with 20,000 input tokens and 2,000 output tokens. Let 15,000 input tokens be unchanged context and 5,000 be fresh. Use the Opus 5 prices already given above: $5 per million fresh input, $0.50 per million cache-read tokens, $6.25 per million short-term cache-write tokens (1.25 × $5), and $25 per million output tokens.

The repeated request is 45% cheaper than the uncached $0.15 request, although its cached input portion is 90% cheaper. The first write costs more. Two calls (one write and one hit) cost $0.25125 rather than $0.30. With a $10 budget, one write followed by 119 verified hits gives 120 calls for $9.98625. This assumes the cache remains valid, all calls have these token counts, and no other charges apply; use actual cache-read and cache-write usage rather than assuming every repetition hits.

That gives us the rule: caching is worthwhile when you run one large context through many requests, and useless for scattered, short questions.

Where Do Tokens Get Used Up Without You Noticing?#

Bills often end up higher than estimated, almost always because of three things you can’t see at a glance.

The first and biggest is conversation history. The model doesn’t remember previous messages by itself; the entire conversation is sent to it again as part of the input every time. This means the tenth message in a long conversation carries all nine previous messages plus their responses. A request costs little at the start of a conversation, but by the end, a question with the same meaning costs several times more because the input has grown. Here’s a simple trick: when the topic changes, start a new conversation. There’s no need to drag one out forever.

The second is reasoning mode. Newer models have a mode where the model first works through its reasoning internally and only then responds. That reasoning also counts as output tokens, and output is the most expensive part. The response looks short, but there are many tokens behind it, so the bill comes as a surprise.

The third is large attachments. Attach a large document or a batch of files to a request, and they’re sent in full as input with every call for as long as they remain in context. If you work with the same document for a while, it’s worth keeping it cached so you don’t keep paying full price for it. Managing what stays in context is a separate skill, called context engineering, and it directly affects your bill.

How Can You Track Spending Without Calculating It Manually?#

You only need to estimate manually once—to understand how long your money will last in general. After that, you don’t need to calculate it by hand; the API does it for you.

Every model response comes with metadata fields showing the exact number of request tokens: how many went to input, how many to output, how many input tokens were read from cache, and how many were written to it for the first time. Those are exact facts about a particular call, and they show where your budget is really going. If you use a tool like Claude Code, it usually shows usage itself after each task.

There’s also a usage page in the provider’s dashboard, with spending by day and your current balance. Check it from time to time, especially in the first few weeks, until you get a feel for your usual spending pattern. A couple of habits will also help save money: set a monthly spending limit if your provider allows it, and don’t turn on automatic balance top-ups until you understand how much you normally spend. Otherwise, an agent that runs away overnight could charge more than you expected.

Get to know Ailoot.