AI API Pricing in 2026: What a Business Actually Pays

AI API pricing for business is charged per token, with two separate rates — one for what you send and another, four to six times higher, for what the model generates. As of August 2026, frontier models sit between $2 and $10 per million input tokens and between $10 and $50 per million output tokens, while fast tiers drop to fractions of a dollar. With those figures and three numbers from your own process, you can estimate an agent's monthly bill before you commission it.

This article does two things: it lists the published rates with the date they were checked, and — more importantly, because rates move every few months — it explains the method for estimating your specific case. We run this calculation before quoting any agent, including the ones running our own businesses. If you're after a capability comparison between vendors rather than a price one, that's in our analysis of OpenAI versus Anthropic for business.

What does a million tokens cost in August 2026?

These are the published rates for the three platforms most used in enterprise settings, checked on 11 August 2026. They bill in US dollars per million tokens; input is what you send (instructions, context, documents) and output is what the model writes.

Two warnings about this table. First: these prices change. OpenAI cut rates on 30 July 2026, and Anthropic is running an introductory $2/$10 price on Sonnet 5 through 31 August 2026. Always verify on the vendor's pricing page before committing. Second: comparing models on list price is misleading, because an expensive model that solves the task in one call can be cheaper than a cheap one that needs three attempts and a human review.

Why does output cost five times more than input?

Because generating text is computationally far more expensive than reading it: the model produces output token by token, while input is processed in one pass. That asymmetry — consistent across all three platforms, with multipliers between 4 and 6 — has a direct consequence for how you design agents.

If your process sends long documents and receives short answers — classifying invoices, extracting fields, choosing a route — the bill is dominated by input and you sit on the cheap side of the curve. If it generates reports, drafts emails or produces documentation, output rules and cost climbs even with a small context.

The design lever becomes obvious the moment you see the numbers: asking the model to be concise is an economic decision, not an aesthetic one. An agent that answers in 400 tokens instead of 1,200 costs a third on the expensive line. Across thousands of monthly executions, that difference shows up on the invoice.

Caching and batch: the two discounts that actually matter

Two mechanisms cut the bill substantially and almost nobody applies them in a first deployment. Used properly they can divide cost by three or four without changing model.

Prompt caching. If every call shares a large identical block — the product manual, the agent's instructions, the catalogue — that block can be cached: the first call writes it at a premium (with Anthropic, 1.25× for a five-minute lifetime or 2× for an hour) and subsequent calls read it at roughly 10% of the input price. OpenAI and Google apply equivalent discounts, around 90% off cached reads. The technical requirement is that the cached block be byte-identical and sit at the very start of the prompt: put a timestamp at the top of your instructions and nothing caches at all.

Batch processing. If the work isn't interactive — classifying overnight email, enriching a database, generating 5,000 product descriptions — all three platforms offer an asynchronous mode at 50% off both input and output, in exchange for results arriving within up to 24 hours. It is the easiest discount to obtain and the most neglected: a lot of work that runs in real time today has no need to.

A third factor is less a discount than a trap: long context is billed separately. OpenAI charges a higher rate above a context threshold, and Gemini doubles the Pro price above 200,000 tokens. If your architecture stuffs the entire document into every call instead of retrieving only the relevant passages, you pay that penalty on every execution. It's one reason a well-built retrieval layer pays for itself; we break the numbers down in our guide to what a corporate RAG system costs.

Estimating your agent's monthly spend in five minutes

You need three numbers from your process and a calculator:

1. Executions per month. How often the agent fires: invoices processed, conversations handled, reports generated.
2. Input tokens per execution. Approximate with the rule that 1,000 tokens is roughly 750 English words. Add instructions + context + document.
3. Output tokens per execution. Same for the expected answer. Be realistic — most people underestimate this by half.
4. Multiply and add: (executions × input ÷ 1,000,000 × input price) + (executions × output ÷ 1,000,000 × output price).
5. Apply a factor of 1.5 to 3 depending on how many calls the agent chains per execution. A tool-using agent makes several model calls per task, and that is the number-one source of billing surprises.

A real SMB example: an agent processing 3,000 invoices a month, with 2,500 input tokens and 300 output tokens each, on a mid-tier model at $2/$12. Input: 7.5M tokens ≈ $15. Output: 0.9M ≈ $11. Total before chaining: $26/month. With a 2.5× factor for intermediate calls: about $65, roughly €60 a month. That's the typical order of magnitude for a scoped process in a mid-sized company, and it explains why compute cost is almost never the deciding variable.

So why does AI cost worry everyone so much?

Because the spend that hurts isn't the API. In most projects we audit, model consumption represents 2-10% of total first-year cost; the rest is build, integration with your systems, and maintenance. A custom agent for a scoped SMB process lands between €15,000 and €40,000, with maintenance at 10-20% a year — that's the line to watch, not tokens. The full breakdown is in how much a custom AI agent costs.

There are two exceptions where API cost genuinely dominates, and it pays to spot them early: high-volume customer-facing products (a public chatbot with tens of thousands of monthly conversations) and long-running autonomous agents that chain hundreds of calls per task. In those two cases, model choice and caching discipline stop being a technical detail and become the business model.

Budgeting mistakes we see over and over

• Estimating on the most expensive model "just in case". Most steps in an agent — classify, route, extract — are handled by a low tier at a tenth of the price. Save the frontier tier for the step that genuinely needs judgment.
• Forgetting chaining. A tool-using agent doesn't make one call per task; it makes three to ten. Budgeting for one is an order-of-magnitude error.
• No spend limits. Every platform lets you set caps and alerts per project. A badly terminated loop in an autonomous agent can generate a startling invoice overnight; the limit takes five minutes to configure.
• Comparing list price only. Real cost per solved task includes retries, human reviews and the tasks the cheap model doesn't solve. Measure cost per correctly completed task, not cost per token.
• Ignoring volatility. Prices have fallen for three years running, but new billing dimensions also appear (long context, extended reasoning modes). Compare the real invoice against your estimate one month after launch.

If you're sizing a project and want a defensible figure before committing budget, that's exactly what a short diagnostic delivers: measure the process, estimate consumption, compare against the saving. That's how we scope it from our AI consulting practice.

Frequently asked questions

Are these prices inclusive of VAT, and are they billed in dollars?

All three platforms publish and bill in US dollars; VAT treatment depends on your tax residency and VAT registration. To budget in euros, add the prevailing exchange rate plus a 10-15% margin for fluctuation. At small volumes it's irrelevant; at four-figure monthly spend it's worth modelling.

Is self-hosting an open model cheaper?

Only at high, sustained volume. The per-token bill disappears, but GPU cost (rented or owned), operations and model upgrades appear. As a rule of thumb, below a few hundred euros a month of API spend the answer is almost always no — and the strong argument for local models is usually privacy or regulatory compliance, not price.

How far have prices fallen, and will they keep falling?

The three-year trend is clearly downward at equivalent capability, with cuts across all three platforms — the most recent from OpenAI on 30 July 2026. That said, new frontier models tend to launch at the expensive end of the table, so a company that always runs the latest model sees a smaller drop than the headline suggests.

What's the difference between paying per API and an enterprise seat licence?

The API is consumption-based and only makes sense if you're building something on top of it. Per-user licences (corporate assistants) are seat-based and cover day-to-day conversational use. Many companies need both and compare them as if they were alternatives; we treat that in detail in our vendor comparison.

Can I switch providers if prices go up?

Technically yes, and it's worth designing for: if your code talks to models through your own abstraction rather than coupling to one SDK, switching is a matter of days. What isn't portable is prompt tuning and evaluations, which have to be redone and revalidated. Budget one to two weeks of work per serious provider change.