AI API pricing: how the bill works and how to cut it without losing quality

AI API pricing is calculated per million tokens, with one rate for the text the model reads and a higher rate for the text it writes. To lower the bill, you first need to know what you actually send on each call, then match the model to the task and switch on the discounts providers already offer.

How an AI API bills you

When you plug a model into an app, a website or an automation, you go through its API, a technical entry point. You no longer pay a flat subscription but for usage, measured in tokens: chunks of text a few characters long. Since a single token costs a fraction of a cent, providers quote a price per million tokens.

Almost every price list has two rates:

• input: everything the model reads (instructions, history, documents, the question);
• output: everything it writes, including, for providers that say so, its hidden reasoning tokens.

The formula fits on one line:

cost = input tokens × input price ÷ 1,000,000 + output tokens × output price ÷ 1,000,000

Two details matter a lot. First, the same text does not produce the same number of tokens on every model, because each tokenizer splits text its own way. Second, output costs several times more than input with most providers, so a chatty answer quickly outweighs a long document. To see how many tokens your own text represents, paste it into our token estimator.

Model prices as of October 22, 2026

Prices change often, which is why the date of the snapshot matters. The table below shows public list prices compiled by models.dev, collected on October 22, 2026, for a selection of recent models, from flagship to lightweight.

Model	Developer	Release	Context (tokens)	Input ($/M tokens)	Output ($/M tokens)	Open weights
Claude Opus 5.5	Anthropic	September 22, 2026	1 M	$4	$20	No
GPT-6 Astra	OpenAI	September 4, 2026	1.05 M	$10	$50	No
Gemini 4 Argon	Google DeepMind	October 13, 2026	1.05 M	$2	$10	No
Claude Sonnet 5.5	Anthropic	September 28, 2026	1 M	$2	$10	No
Mistral Large 4	Mistral AI	October 6, 2026	1.05 M	$1.36	$4.18	No
DeepSeek V4.1 Flash 1017	DeepSeek	October 17, 2026	1.05 M	$0.15	$0.60	Yes
Claude Haiku 5.5	Anthropic	October 7, 2026	1 M	$0.10	$0.50	No
GPT-6 Luna	OpenAI	September 22, 2026	1.05 M	$0.10	$0.50	No
Qwen3.7 Flash	Alibaba Cloud (Qwen)	July 15, 2026	1 M	$0.03	$0.13	No

The next chart shows the output price of the same models. The gap between the most expensive and the lightest runs into tens of times, which makes model choice your biggest lever.

Output price ($ per million tokens)

• Claude Opus 5.5$20
• GPT-6 Astra$50
• Gemini 4 Argon$10
• Claude Sonnet 5.5$10
• Mistral Large 4$4.18
• DeepSeek V4.1 Flash 1017$0.60
• Claude Haiku 5.5$0.50
• GPT-6 Luna$0.50
• Qwen3.7 Flash$0.13

A worked example: same workload, two models

Take a fictional but realistic case: a customer support assistant for an online store that handles 1,000 conversations a day. Each conversation sends about 1,500 tokens (instructions, history, question) and receives 500. That adds up to 1.5 million input tokens and 0.5 million output tokens per day.

Using models.dev prices from October 22, 2026:

Model	Input per day	Output per day	Total per day	Over 30 days
Claude Haiku 5.5	1.5 × 0.10 = $0.15	0.5 × 0.50 = $0.25	$0.40	about $12
Claude Opus 5.5	1.5 × 4 = $6	0.5 × 20 = $10	$16	about $480

The same service costs 40 times more on the flagship model. Notice too that in both cases output, though three times smaller in volume, weighs more than input. This math does not tell you which model serves your customers better: it tells you how much the quality gap is worth to you. To rerun it with your own volumes and other models, use our agent cost calculator.

What inflates the bill without warning

Overruns rarely come from the listed price. They come from the real token volume, which people tend to underestimate.

• Conversation history. An API remembers nothing: to keep context, the whole conversation is sent again with every message. By the twentieth turn, you are paying to reread the previous nineteen.
• System prompt and attached files. Standing instructions and documents placed at the start of a request are reread, and billed, on every call.
• Reasoning. A reasoning model produces thinking tokens billed as output. A three-line answer can cost as much as a full page.
• Agent loops. An agent that plans, calls a tool, reads the result and tries again makes several calls for a single task, each with its own context. Our guide on how to build an AI agent, from no-code to code explains how these loops work.
• Retries. An error, a malformed output or hitting a rate limit triggers a new call, which is billed again.

Check yourself Your agent costs twice what you planned, yet the number of users has not changed. What should you check first?

The average number of tokens per task, with input and output tracked separately. A jump usually comes from growing history, a document added to the system prompt, a higher reasoning setting or an agent taking more steps. Request logs in the provider’s console or an observability tool will show it call by call.

Seven ways to cut the bill

Here are the most effective levers, from the simplest to the most technical. None of them requires giving up quality, as long as you measure before and after.

Lever	What it does	Effort
1. Pick the model per task	Keep flagship models for hard tasks only	Low
2. Shorter outputs	Ask for a brief format, set a maximum length	Low
3. Prompt caching	Pay less for a repeated request prefix	Low to medium
4. Batch processing	Group tasks that are not urgent	Medium
5. Leaner context	Summarize history, send only useful passages	Medium
6. Tune reasoning	Lower thinking effort for simple tasks	Low
7. Cap agent loops	Limit an agent’s steps and retries	Medium

1. The right model for each task. Sorting an email, pulling out a date or rephrasing a sentence does not need the most powerful model. A common setup routes triage and simple work to a light model and only calls the flagship for hard cases. In the support example above, if the light model handled most conversations and only the trickiest ones were escalated, the monthly bill would land much closer to the low figure than the high one. The exact saving depends on your escalation rate, so measure it on real traffic. Our model comparison tool helps you spot cheaper candidates with similar capabilities.

2. Shorter outputs. Since output is the expensive part, ask explicitly for a concise format, a list instead of a paragraph, or structured output in JSON when software reads the answer. The techniques in our prompt engineering guide help here too.

3. Prompt caching. Prompt caching reuses the processing of a request prefix that stays identical from one call to the next. According to Anthropic’s documentation, cited in our glossary, writing to the cache costs 1.25 times the normal input price and reading from it 0.1 times that price. Put stable content first and the user’s question last.

4. Batch processing. For work that can wait (summarizing an archive, tagging thousands of records), several providers offer a cheaper delayed queue. Anthropic states a 50% discount on both input and output, according to its documentation as summarized in our glossary.

5. Leaner context. Instead of sending an entire manual with every question, pass only the relevant passages: that is the idea behind RAG, which lets an AI use your documents without rereading everything each time. Summarizing a long history from time to time has the same effect.

6. Reasoning on demand. Many recent models let you set the reasoning effort. Keep it low by default and raise it only for tasks that need it.

7. Guardrails on agents. Set a maximum number of steps and retries, and stop the agent if it goes in circles. This is a safety issue as well as a money issue.

Open weights and local AI: really free?

Open-weight models can be downloaded and run on your own hardware. There is no per-token bill anymore, but the cost moves elsewhere: hardware, electricity, maintenance and your time. For personal use or sensitive data, it is a serious option, covered in our tutorial on how to run AI locally. For a high-traffic service, it takes real math, because a well-sized server is expensive even when idle.

Many open-weight models are also offered through hosting providers’ APIs, often at low prices: the table above includes one example.

Monitor and cap your spending

Before you put a service into production, take three simple precautions.

• A cap and alerts. The major providers’ consoles let you set a spending limit or get notified at a threshold. Set them on day one.
• One API key per project. You will know which service uses what, and a leaked key will not drain your whole budget. Never put it in public code.
• Regular reviews. Check cost per task and average tokens every week. Drift shows up early, well before the monthly invoice.

If you work for a company, loop in whoever handles purchasing early on. Pay-as-you-go spending is easy to start on a personal card and hard to track later, so check whether your provider offers an organization account with separate projects, roles and billing.