Quick verdict
OpenAI API pricing is a sticker rate plus three multipliers that usually dominate the invoice. If you only compare “$/1M tokens,” you will under-budget production. The short version:
- Sticker $/1M ≠ production bill. Input and output have different rates; output-heavy agents and tool-calling loops move the total more than the headline input number.
- Automatic prompt caching is the first lever on chat and RAG paths with large, stable prefixes. Cached input is typically about 50–75% off the matching input rate, depending on model (verify live).
- Batch API is about 50% off for offline / async jobs (often up to ~24h turnaround). Do not put interactive chat on Batch.
- Model routing (4.1 / 4.1-mini / 4.1-nano, or 4o / 4o-mini) dominates early cost more than any discount. Route simple turns to mini/nano; keep frontier models for hard reasoning.
- AU/SG regulated builds: if residency or enterprise procurement prefers Azure OpenAI or AWS Bedrock, do not force direct OpenAI API as the default — platform choice can beat token sticker.
Cipher’s first-hand cutover: measure cached-input % and output/input ratio weekly before you upgrade a model tier. Teams that only watch total spend usually upgrade too early and miss the cheaper win (cache + routing).
Last updated: August 2026. Rates change; re-verify the official OpenAI pricing page before you publish a budget externally.
Directional per-1M token rates (re-verify)
These are order-of-magnitude planning figures from OpenAI’s published API pricing as of August 2026. Always confirm at openai.com/api/pricing.
| Model | Input / 1M | Output / 1M | Notes |
|---|---|---|---|
| GPT-4.1 | ~$2 | ~$8 | Strong default for agent reasoning |
| GPT-4.1 mini | ~$0.40 | ~$1.60 | High-volume classification, routing, simple extraction |
| GPT-4.1 nano | ~$0.10 | ~$0.40 | Cheapest tier for very simple turns |
| GPT-4o | ~$2.50 | ~$10 | Multimodal / established production path |
| GPT-4o mini | ~$0.15 | ~$0.60 | High-volume lite path on the 4o family |
Cached input: typically about 50–75% off the matching input rate depending on model. Batch API: about 50% off standard rates for supported async workloads. Treat both as directional until you confirm the live card for your model and org.
Automatic prompt caching vs Batch API
These two discounts answer different traffic shapes. Mixing them up is a common budgeting error.
Automatic prompt caching
OpenAI can discount repeated prompt prefixes when the cache hits. This is the right lever for interactive chat, RAG Q&A with a large system prompt or tool schema, and any path where the first N tokens stay stable across turns. You still pay full (or write) rates on misses and on novel tokens. Design prompts so the stable block comes first; do not bury a giant changing user blob ahead of the reusable prefix.
Batch API
Batch is for offline / asynchronous jobs — golden-set evals, document enrichment, nightly rewrites — often with turnaround measured in hours (commonly up to ~24h; confirm current docs). Pricing is published at roughly half of standard rates for supported models. Do not put customer-facing chat or low-latency tool loops on Batch.
Cipher cutover rule: if the job can wait overnight, Batch first. If the job is interactive and the system prompt or tool schema is large and stable, optimize for cache hits before you upgrade model tier.
Worked agent bills: three monthly shapes (directional)
These are planning shapes, not quotes. Plug your token mix into the live rate card. Numbers assume roughly GPT-4.1-class rates unless noted; mini routing and cache change the totals sharply.
| Scenario | Traffic shape | Dominant cost drivers | Planning note |
|---|---|---|---|
| 1. Chatbot — 100k turns / month | ~100k user turns; short system prompt; moderate replies | Output tokens + model tier | If most turns are FAQ-simple, route to 4.1-mini / nano; keep 4.1 for escalations. Sticker math without routing overstates the “need 4.1 everywhere” bill. |
| 2. RAG Q&A — large system prompt + cache hits | Stable system + retrieval instructions; retrieved chunks vary; high prefix reuse | Cached input % + retrieve size | A large stable prefix with strong cache hit rate can cut effective input cost substantially (often in the 50–75% discount band on cached tokens). Measure hit rate weekly; a “cheap” model with poor cache design can still lose. |
| 3. Tool-calling agent — high output | Multi-step tools; long JSON/tool traces; high output/input ratio | Output $/1M + step count | Output is typically several× input. Cap verbose tool dumps, summarize intermediate steps, and avoid upgrading tier until you know the output/input ratio. This path often surprises teams who only budgeted input stickers. |
Order-of-magnitude intuition (illustrative only): at ~100k turns/month with ~1.5k input + ~500 output tokens per turn on GPT-4.1 sticker rates, you are already in the low-to-mid hundreds of dollars before caching and routing. Cache hits on a large prefix and mini routing for easy turns can cut that sharply; a verbose tool agent can push it the other way. Re-run the math on your logs, not this paragraph.
When NOT to use the OpenAI API directly
Direct OpenAI API is not always the right procurement or residency answer:
- Data residency / AU government and regulated buyers: many prefer Azure OpenAI or AWS Bedrock under a customer-owned cloud account with region locks. Token sticker can be secondary to where inference runs and who holds the contract.
- Multi-model + IAM/VPC already standardized on AWS: Bedrock may win on operational fit even when a single OpenAI sticker looks lower. See AWS Bedrock pricing explained (2026).
- You need Claude-class quality on long cached system prompts: compare Anthropic’s cache-hit economics before locking the stack. See Anthropic Claude API pricing explained (2026).
Choose OpenAI pricing levers if…
- Choose GPT-4.1 (or 4o) if the turn needs strong reasoning or complex tools and eval quality fails on mini.
- Choose 4.1-mini / nano (or 4o-mini) if the turn is classification, routing, short extraction, or FAQ-like and your eval set still passes.
- Optimize for automatic caching if you have a large, stable system prompt, tool schema, or RAG instruction block reused across turns.
- Choose Batch if the job is offline and can wait (evals, enrichment, backfills).
- Choose Azure OpenAI or Bedrock instead if residency, enterprise agreement, or account ownership requirements say so — then re-price on that platform’s card.
Related: Cost breakdown: running AI products (2026) · Anthropic Claude API pricing · AWS Bedrock pricing · Applied AI Engineering · Pricing
FAQ
Is the OpenAI API sticker price what I will pay in production? Rarely in isolation. Cached input discounts, Batch for offline jobs, output-heavy agents, and model routing usually move the bill more than the headline $/1M input rate.
How much does prompt caching save? OpenAI publishes cached input at a discount to standard input — commonly in a roughly 50–75% off band depending on model. Your realized savings equal that discount × your cache hit rate on eligible tokens. Measure weekly.
When should we use the Batch API? When latency can stretch (often up to ~24 hours for batch-style jobs — confirm docs) and the work is offline: evals, enrichment, nightly processing. Not for interactive chat.
Should Australian teams always call OpenAI directly? No. For many AU gov and regulated buyers, Azure OpenAI or AWS Bedrock under a customer-owned account is the better residency and procurement path even if a direct sticker looks attractive.
Who is Cipher Projects and why listen on API cost shape? Cipher Projects is an Australian-led AI engineering studio that ships production agent and RAG systems for AU/SG teams. We budget OpenAI, Anthropic, and Bedrock cutovers from real traffic logs — cached-input %, output/input ratio, and model routing — not from slide-deck stickers alone.
Conclusion
OpenAI API pricing rewards teams that treat sticker rates as the start of the model, not the end. Cache the stable prefix, Batch what can wait, route easy turns to mini/nano, and watch output/input ratio before upgrading tier. That is how you avoid both under-powered pilots and surprise invoices. For the wider product cost stack beyond model tokens, read running AI products: cost breakdown.