Solutions for
Please select
Try the Web App
ki-modelle

AI Pricing Made Simple

Redaktion ·

Why AI pricing matters to you

The first Anthropic or OpenAI bill almost always comes as a surprise. A prototype that cost 30 cents per day in testing suddenly racks up €80 a month under load. A coding agent that barely registers at ten requests a day quickly costs $5–15 on an active day with multi-turn dialogues. And a RAG system with large contexts can easily eat 10 cents per request — which is no longer trivial at 1,000 users per day.

AI pricing is no dark art, but it works differently from what you know from SaaS or cloud hosting. Once you grasp three concepts — tokens, the input/output ratio and the hidden cost drivers — you make better architectural decisions. This article walks you through the basics, the most important levers and concrete worked examples.

The basic mechanic: token-based billing

AI providers don’t bill per request and not per processing time, but per token — the smallest unit language models work with internally. A token is usually a word fragment, sometimes a single character. Rule of thumb: 1,000 tokens equal roughly 750 English or 600 German words. One million tokens — the standard pricing unit — are roughly half a novel to a full one.

The standard price quote looks like this: $3 / $15 per MTok for Claude Sonnet. Translated: 3 US dollars per million input tokens, 15 US dollars per million output tokens. This split is central.

Input tokens — what you send the model

Everything in the prompt counts as input: system prompt, user question, context documents, conversation history, tool definitions. Before the model can respond, it has to read these tokens and convert them into its internal representations. That’s cheap: input prices at the major providers range from $0.15 to $3 per MTok.

Output tokens — what the model sends back

Output is significantly more expensive — typically three to five times the input price. Reason: for every single output token, the model has to push the entire context through its layers again to choose the next most likely token. Output prices range from $0.60 to $75 per MTok at frontier models like Claude Opus.

This asymmetry has an important consequence: long inputs are cheaper than long outputs. Letting a model summarise a 50-page document mostly costs the summary — not the document.

The hidden cost drivers

Three mechanics quietly drive costs up.

Context window ≠ free

Modern models offer context windows up to one million tokens. Tempting — until you notice: every token in the context is billed when sent, and every single time. Whoever resends the entire history in a multi-turn dialogue pays for it every turn. 50 requests with 30k tokens of context each cost on Claude Sonnet 50 × 30,000 × ($3 / 1,000,000) = $4.50 in input alone — before the model has produced a single output token.

Reasoning models produce invisible output tokens

Models like GPT-5.5-Reasoning or Claude with extended thinking generate internal “thinking tokens” before the actual answer. You don’t see them in the response, but they are fully billed as output tokens. A single reasoning answer can easily cost 5,000–20,000 output tokens. On a frontier model at $75/MTok output, that’s $0.38 – $1.50 per request.

Tool use bills double

When an agent calls tools (function calling), each tool call creates two roundtrips: one in which the model decides which tool to call with which parameters (output), and one in which the tool result flows back into the model (input). An agent calling ten tools in sequence sends the entire prior context ten times — exponential token accumulation.

Three levers to save

In practice: those who consciously price-optimise their build pay 30–80 % less than a naive setup. Three levers are particularly effective.

1. Tier switching — the right model for each task

Not every task needs a frontier model. Classification, routing, simple extraction and short answers are handled just as well by the small tier models (Haiku, GPT-Nano, Gemini Flash-Lite) — at a fraction of the cost. The price gap between top and bottom tier is typically a factor of 30–60.

A sensible default architecture: small model as “router” or pre-classifier, big model only for genuinely complex steps.

2. Prompt caching — repeated context almost free

Whoever sends the same prompt prefix in many requests (large system prompt, attached documents, tool definitions) can have that part cached on the provider side. Cache hits typically cost only 10 % of the regular input price. Anthropic, OpenAI and Google all offer this feature. For coding agents or RAG systems with stable context, this often saves 70–90 % of input cost.

3. Batch API — async for 50 % discount

For non-interactive workloads — classifying a large corpus, embedding generation, evaluations — OpenAI, Anthropic and Google offer the batch API. You upload a JSONL file with hundreds or thousands of requests, the provider processes them within 24 hours, and you pay roughly half the real-time price. Plus a separate, larger rate limit.

Current price table (as of May 2026)

The values below are in US dollars per million tokens and are meant as orientation — please double-check provider pages before going to production, the field moves fast.

| Model | Input | Output | Cache read | Provider | |---|---|---|---|---| | Claude Opus 4.7 | $15.00 | $75.00 | $1.50 | Anthropic | | Claude Sonnet 4.6 | $3.00 | $15.00 | $0.30 | Anthropic | | Claude Haiku 4.5 | $0.80 | $4.00 | $0.08 | Anthropic | | GPT-5.5 | $5.00 | $20.00 | $0.50 | OpenAI | | GPT-5.5-mini | $0.40 | $1.60 | $0.04 | OpenAI | | GPT-Nano | $0.10 | $0.40 | $0.01 | OpenAI | | Gemini 3 Pro | $3.50 | $14.00 | $0.35 | Google | | Gemini 3 Flash | $0.35 | $1.40 | $0.04 | Google | | DeepSeek V4 | $0.55 | $2.20 | $0.06 | DeepSeek |

You’ll find current changes in the news on LLM pricing.

Three worked examples from the field

Example 1: Chatbot with 10,000 requests per month

Assumptions: 2,000 input tokens per request on average (system prompt + short question), 500 output tokens.

  • Pure Sonnet: 10,000 × (2,000 × $3 + 500 × $15) / 1,000,000 = $135 / month
  • With prompt caching (90 % of input cached): 10,000 × (200 × $3 + 1,800 × $0.30 + 500 × $15) / 1,000,000 ≈ $87 / month — 35 % saved
  • With tier mix (70 % Haiku, 30 % Sonnet) + caching: ≈ $42 / month — 69 % saved

Example 2: RAG system with large context chunks

Assumptions: 5,000 requests per month, 25,000 input tokens each (question + 20k retrieved chunks), 1,500 output tokens.

  • Pure Sonnet: 5,000 × (25,000 × $3 + 1,500 × $15) / 1,000,000 = $487 / month
  • With prompt caching of stable system and instruction prompts (5k of 25k cached): ≈ $432 / month
  • With an additional reranker tier (Haiku reduces chunks from 20k to 8k before the Sonnet call): ≈ $215 / month — 56 % saved

Example 3: Coding agent with tool use

Assumptions: 200 active sessions per month, 15 tool calls each, 12,000 input tokens per roundtrip near session end on average, 3,000 output tokens total per session.

  • Pure Opus (for top quality): 200 × (15 × 12,000 × $15 + 3,000 × $75) / 1,000,000 = $585 / month
  • With aggressive prompt caching (repository context cached): ≈ $135 / month — 77 % saved
  • With Sonnet as primary + Opus only for critical steps: ≈ $80 / month — 86 % saved

Bottom line

The question “which AI model” is always also a question “which price point for which task”. Whoever uses frontier models for everything wastes money; whoever uses only low-tier risks quality. The economic sweet spot almost always lies in a thoughtful mix — and in disciplined use of the three levers: tier switching, prompt caching, batch API.

Concretely, for most projects: start with mid-tier (Sonnet, GPT-5.5-mini). Once load is measurable, add prompt caching — it has the best effort-to-impact ratio. Tier mix and batch API come once the application runs in production and load profiles are known.

Whoever has own hardware or data protection requirements that rule out cloud usage should also consider local models — they have no token price, but hardware investment and electricity as cost items.

Themenuebersicht

KI-ModelleLLM-Pricing