DEV Community: scorpion4ik26-lang

AI Cost Optimization Checklist 2026: 15 Steps to Lower Your API Bill

scorpion4ik26-lang — Tue, 03 Nov 2026 14:00:38 +0000

I am the founder of PromptUnit. This post first appeared on the PromptUnit blog, where it is kept up to date.

A 40-70% lower AI bill is our estimate for a workload with many simple requests. It is not a guarantee, and it does not come from a single clever optimization. It comes from working through a list. Model selection, caching, prompt compression, routing, batching, context pruning. None of these techniques is complicated individually. The savings compound when you apply them in combination, and most teams have only done two or three of them.

This is a 15-point checklist written for engineering and platform teams managing production LLM workloads. The items are ordered roughly by typical savings impact, with the highest-leverage actions first. Each item includes an estimated savings range, though your actual results will depend on your current setup.

1. Audit Which Model You Are Defaulting To

Before anything else, find out what model your application is actually calling in production. Teams regularly discover they are running on a flagship model because it was the default in a tutorial or set during prototyping and never revisited. If you are running GPT-5.4 at $2.50 per million input tokens and $15 per million output tokens on tasks a smaller model handles equally well, a model change alone cuts the cost of those calls by 70% on GPT-5.4 mini ($0.75 and $4.50) or about 92% on GPT-5.4 nano ($0.20 and $1.25), at OpenAI's list prices as of October 2026. Check your API usage dashboard, match model names to current pricing, and establish your baseline before moving on. The hidden cost of defaulting to your flagship model shows what each month of leaving it costs.

2. A/B Test Cheaper Models on Your Actual Production Tasks

Do not assume the quality gap between models is meaningful for your use case. The only reliable test is running both models on a representative sample of your real production inputs and scoring the outputs using a rubric that matches your actual quality requirements. Take 100 examples from your production logs. Run both the current model and a cheaper candidate. Score them. If the cheaper model performs within 5% of the current model on your rubric, you have a clear routing decision. The measurement takes a day to set up. Skipping it means either missing savings or discovering quality regressions through user complaints. We estimate GPT-4o-mini handles 60-70% of typical production tasks about as well as GPT-4o. That is a rough estimate, not a measurement, and the question is whether your specific tasks are in that majority.

3. Enable Provider-Side Prompt Caching

Anthropic offers 90% off cached token reads when prompt caching is enabled on requests with repeated system prompts or context. OpenAI automatically caches the prefix of prompts over a certain length, providing 90% or more off for cached input tokens on current models (95% on GPT-6.1 Sol). For applications with large, static system prompts, the savings on input costs are significant. A system prompt of 2,000 tokens sent 100,000 times per day costs $600 per day in input tokens at Claude Sonnet 4.6 pricing without caching. With caching, after the first call, those reads cost $60 per day. Estimated savings: 20-60% on input costs for any application with repeated system prompt content. The implementation requires a small change to how you structure requests, and the savings begin immediately.

4. Tag API Calls by Feature

This item does not directly reduce costs, but it enables every other optimization on this list. Without per-feature attribution, you cannot know which tasks to target, which optimizations have the highest impact, or whether your changes are working. Tag every API call with at minimum the feature name and user tier. Store these alongside the token counts from API responses. Build a weekly report sorted by total spend per feature. The first time you run this report, you will almost certainly find that one or two features account for the majority of your AI spend, and at least one of them will be a candidate for immediate optimization. The complete guide to LLM cost attribution by feature covers implementation approaches in detail.

Catching a new expensive model call before it merges is cheaper than catching it on next month's invoice. The PromptUnit GitHub Action scans every pull request diff for newly added GPT-4o, Claude Opus, or Gemini 2.5 Pro calls and posts a routing savings estimate as a PR comment, so the cost conversation happens at code review time instead of at audit time.

5. Compress System Prompts

System prompts grow over time. Developers add instructions to handle edge cases, include examples to improve output quality, and paste in context that seemed useful during testing. Few people go back to remove content that is no longer needed. Audit your system prompts for redundancy, filler phrases, and instructions that are not actually changing model behavior. A disciplined compression pass typically achieves 30-50% token reduction on system prompts without any quality change. At high call volumes, the savings from prompt compression alone can be substantial. A 1,000-token system prompt compressed to 600 tokens saves 400 tokens on every call, and those savings multiply directly against your call volume and input token rate.

6. Add Output Length Constraints to Prompts

Output tokens cost more than input tokens on every major provider. Claude Sonnet 4.6 charges $3 per million input tokens and $15 per million output tokens. Unconstrained output length means you are paying for however many tokens the model decides to generate, which is often more than you need. Adding explicit length guidance to prompts, such as "respond in under 100 words" or "return a JSON object with exactly these fields," reduces output length without reducing output quality for most structured tasks. Estimated savings: 20-40% on output costs for tasks with unconstrained generation where the output length is not inherently variable.

7. Implement Application-Level Caching for Repeated Identical Queries

If users in your application ask the same questions, and they do, those are opportunities for full response caching at the application layer. A Redis or Memcached store keyed by the hash of the user query and system prompt context can return instant, free responses for repeat queries without any API call. Savings are up to 100% of cost for cached queries. For products with shared corpora, high user overlap, or predictable query patterns, cache hit rates of 20-50% are realistic. The engineering investment is low. The savings begin immediately on deployment.

8. Move Batch Workloads to the Batch API

OpenAI and Anthropic both offer 50% off standard token rates for requests submitted through their Batch APIs. The tradeoff is latency. Batch API requests are processed asynchronously, typically within a few hours rather than in real time. For any workload that is not user-facing and does not require immediate responses, this is a straightforward 50% cost reduction. Document processing, embedding generation, content classification, offline analysis, and evaluation runs are all strong candidates. If you are currently running these synchronously because nobody set up the batch pipeline, the setup cost is a few hours of engineering work. The ongoing savings are immediate. See the full batch API decision framework for a routing guide.

9. Implement Cross-Provider Model Routing

Different providers offer different price-performance points for different task types. Claude Haiku 4.5 at $1 per million input tokens and $5 per million output tokens handles many classification and extraction tasks at lower cost than some OpenAI alternatives. Gemini 3 Flash Preview at $0.50 per million input tokens and $3.00 per million output tokens is competitive for high-volume simple tasks. Routing simple tasks to the cheapest capable model while reserving more capable models for complex requests can lower the cost of those requests sharply: in our own 24 comparisons the cheaper models cost about 89% less per call, and across a whole bill we estimate 40-70% for a workload with many simple requests (an estimate, not a guarantee; see what we measured). PromptUnit provides routing infrastructure for cross-provider dispatch so teams can implement this without custom routing code. The cross-provider routing guide covers the provider comparison in depth.

10. Prune Conversation Context

Multi-turn applications that send the full conversation history on every API call are paying for context that is often irrelevant to the current user request. A conversation that has been going for ten turns before reaching the current question includes early context, clarifications, and prior outputs that may have no bearing on the next response. Summarize older turns rather than sending them verbatim. Limit context to the most recent N turns plus the original task context. For most conversation types, the most recent 3-5 turns plus the system context is sufficient. Estimated savings: 30-60% on input costs for multi-turn applications. This is one of the highest-impact optimizations for chat-based products.

11. Reduce Few-Shot Examples

System prompts that include multiple few-shot examples are often carrying more examples than necessary. The marginal quality improvement from a fifth example over a second example is typically small, while the token cost is linear. Test 2-shot versus 5-shot on your task. Run the comparison on 50-100 examples and measure output quality. For most classification and extraction tasks, 2-shot achieves 90% or more of the quality improvement available from 5-shot, at 60% lower cost for the example portion of the prompt. The exact savings depend on the length of your examples, but for prompts where examples represent 30-50% of total input tokens, this test is worth running.

12. Use Structured Output Modes

For structured extraction or transformation tasks, JSON mode produces denser outputs than conversational responses. A preamble like "Sure! Here is the information you requested in JSON format: {..." wastes tokens. A clean JSON object with no framing is more useful and cheaper. Structured output modes also reduce malformed response rates, meaning fewer retries and lower total cost per successful call. Estimated savings: 20-40% on output tokens for extraction and transformation tasks.

13. Set Per-Feature and Per-User Cost Budgets in Code

Implement cost guardrails in your application that stop or throttle API calls when a user or feature exceeds a defined spend threshold within a billing period. This prevents cost anomalies from compounding undetected. A bug that causes a loop to generate thousands of API calls, a user who constructs adversarial prompts that produce long outputs, or a spike in traffic that triggers unexpectedly high consumption, all of these can be caught early if you have budget limits in code rather than discovering them in the next billing statement. This is not primarily an optimization. It is cost governance, and it prevents the kind of five-figure surprise bills that have hurt real companies.

14. Monitor Your Retry Rate

High retry rates silently multiply your API costs. If your application retries on rate limit errors, timeout errors, or output validation failures, each retry is an additional API call. A 20% retry rate effectively increases your cost per successful call by 20%, before accounting for the output tokens spent on failed calls that still counted toward your bill. Pull your retry rate from application logs. If it is above 5%, investigate the root cause rather than absorbing the cost. Common causes include prompts that reliably produce outputs failing your validation schema, rate limit misconfiguration, and inconsistent output length causing timeout errors. Fixing the root cause saves costs and improves latency simultaneously.

15. Re-Evaluate Model Choices Quarterly

Model pricing and capabilities change fast. A routing decision that was optimal three months ago may not be optimal today. In 2026, multiple providers have released new model tiers with meaningfully lower pricing at comparable quality levels. A quarterly review of your routing configuration against current model offerings is low effort and can identify opportunities that did not exist when your configuration was last set. Run a quick A/B test on any new model that looks competitive. For a current view of model pricing across providers, see the OpenAI API cost calculator and pricing guide.

The Compounding Effect

These fifteen techniques are additive. A team that applies model selection, prompt caching, system prompt compression, and batch routing to eligible workloads sees the product of several independent multipliers applied to their baseline cost. A 30% reduction from model selection combined with a 40% reduction from caching combined with 50% off batch workloads produces a combined reduction substantially larger than any single item.

Working through a list like this one and compounding the savings is how a bill comes down by more than any single item allows. Our estimate is 40-70% for a workload with many simple requests, not a guarantee. Most of the work is measurement and configuration, not fundamental engineering changes.

PromptUnit automates the model-choice items on this list at the proxy, with no application code changes: it checks each request and, when a cheaper model is just as good for it, uses that model, including one at another provider whose key you connected. The other items are changes to your own prompts and code.

Start reducing your AI API costs systematically at www.promptunit.ai.

LLM Routing: How It Works, Strategies and Real Data

scorpion4ik26-lang — Fri, 30 Oct 2026 14:00:38 +0000

Liquid syntax error: Unknown tag 'endraw'

Gemini 2.5 Pro vs Flash Cost (and the Newer Gemini Models)

scorpion4ik26-lang — Tue, 27 Oct 2026 14:00:38 +0000

I am the founder of PromptUnit. This post first appeared on the PromptUnit blog, where it is kept up to date.

Gemini 2.5 Flash costs about a quarter of what Gemini 2.5 Pro costs per token at standard prompt lengths, and as little as an eighth on prompts over 200,000 tokens. That gap makes the routing question simple on the surface, but the real question is not "which is cheaper?" It is "which tasks actually need Pro, and what does it cost to get that wrong?"

All prices below are Google's paid-tier list prices per million tokens, from the Gemini API pricing page, checked October 15, 2026.

The pricing structure in detail

Gemini 2.5 Pro has two price tiers based on prompt length: one for prompts up to 200,000 tokens and a higher one above that. Gemini 2.5 Flash has a single price for text, image and video input at any length, with a separate price for audio input.

Model	Input, prompts up to 200k	Input, prompts over 200k	Output, up to 200k	Output, over 200k
Gemini 2.5 Pro	$1.25	$2.50	$10.00	$15.00
Gemini 2.5 Flash	$0.30 (audio $1.00)	$0.30 (audio $1.00)	$2.50	$2.50

At standard lengths Pro costs about 4.2 times Flash on input ($1.25 against $0.30) and exactly 4 times on output ($10.00 against $2.50). On prompts over 200,000 tokens the gap widens to about 8.3 times on input and 6 times on output, because Flash has no long-prompt surcharge. Both output prices include thinking tokens, so an answer that reasons at length costs more than its visible text suggests.

Here is what that means on a long call. A 250,000-token document costs $0.625 to send to Pro (250,000 tokens at $2.50 per million) and $0.075 to send to Flash. A 5,000-token answer adds $0.075 on Pro and $0.0125 on Flash. Ten thousand such calls a month come to $6,250 in input alone on Pro, against $750 on Flash.

Context caching is available for both. Cached Pro input costs $0.125 per million tokens for prompts up to 200,000 tokens and $0.25 above that, plus $4.50 per million tokens per hour of storage. Cached Flash input costs $0.03 per million tokens for text, image and video ($0.10 for audio), plus $1.00 per million tokens per hour of storage. If you work with large documents that several calls in a session refer to, caching cuts Pro's effective cost substantially.

Both models also have a Batch price at half the standard input and output rates, for work that can wait.

To compare these with other providers, see the current GPT prices in our Azure OpenAI vs OpenAI direct table and Anthropic's in the Claude API pricing guide.

When Flash is the right call

Flash performs well on a wide range of tasks that do not require deep multi-step reasoning. Classification is the clearest case: routing customer queries to the right department, labeling sentiment, tagging content categories. These tasks are largely pattern matching against a fixed taxonomy, and Flash handles them accurately and fast.

Extraction tasks, pulling structured data from documents, are another strong Flash use case. The model needs to find specific fields in text and return them in a structured format. It does not need to reason through ambiguity or connect long chains of logic. Most production extraction pipelines can use Flash and meet their quality bar.

Standard-length document summarization, Q&A over clear and well-structured source text, customer support routing and intent classification all fall into this group. These tasks have well-defined inputs and outputs, and the main failure mode is missing an explicit piece of information rather than failing to reason through something complex. Flash's lower ceiling rarely matters for these workloads.

For a detailed look at how to segment workloads by complexity and route accordingly, see the LLM model routing guide.

When Pro is worth the premium

The case for Pro rests on two arguments: stronger reasoning and the cost of quality errors.

Gemini 2.5 Pro is the stronger model on problems that need multi-step reasoning: debugging complex logic, writing non-trivial algorithms and understanding large codebases. If your application generates code where errors have downstream costs, such as code that goes into production or runs in an automated pipeline, the extra $0.95 per million input tokens and $7.50 per million output tokens may be the cheapest quality insurance available.

Complex multi-step reasoning is the other clear Pro case. Legal document analysis where the model has to track several clauses and how they interact, medical record summarization where accuracy matters clinically, financial report analysis where misreading a number has consequences. In these contexts the cost of a wrong answer usually far exceeds the price difference between the models.

The general principle: when a model error is cheap, use Flash. When a model error is expensive, work out whether Pro's lower error rate pays for itself at your volume. Take 1,000 medical document analyses a month at about 10,000 input tokens and 1,000 output tokens each. On Pro that is $12.50 for input and $10.00 for output, $22.50 a month. On Flash it is $3.00 plus $2.50, $5.50 a month. If Pro avoids even a handful of errors that each cost a person time to catch and correct, the $17 a month difference pays for itself.

The long-context case

Both models accept very long prompts, an area where Google is ahead of many competitors. Long prompts have a cost beyond the price tier, though.

A 500,000-token prompt costs $1.25 in input alone on Pro (500,000 tokens at $2.50 per million) and $0.15 on Flash. If you send entire codebases, long contracts or large research documents in every prompt, model choice matters even more at this size, and Pro's long-prompt tier doubles its input price.

There is also a quieter point: for many long-context tasks you do not need to send the whole document every time. Retrieval that pulls the relevant 5,000 to 10,000-token chunks can shrink your prompts dramatically and keep Pro under the 200,000-token threshold. The RAG pipeline hidden costs post covers the tradeoffs between full-context and retrieval-based approaches.

A practical routing rule for production systems

The most cost-effective pattern for Gemini is usually not to pick one model and stay with it. It is to default to Flash and escalate to Pro when a quality check fails.

In practice: start every request on Flash. After the response arrives, run a lightweight quality check, a simple heuristic, a small classifier or a confidence score where the task allows it. If the check fails, run the request again on Pro. If it passes, return the Flash answer.

As an illustration, suppose 80% of calls pass on Flash and 20% escalate, and a Pro call costs about 4 times a Flash call. The cost becomes 0.8 times the Flash cost plus 0.2 times (the Flash cost plus the Pro cost), which is 1.8 times the Flash cost. Running everything on Pro would cost 4 times the Flash cost, so the cascade costs 45% of all-Pro, or 55% less, while still giving Pro's answer to the calls that need it. Your own pass rate decides the real number.

The key engineering requirement is a quality check in production. Without one, you cannot cascade sensibly. The routing guide linked above covers implementation patterns.

Where the newer Gemini models fit

Google still serves Gemini 2.5 Pro and 2.5 Flash, and its deprecations page lists no shutdown date for either. But Google now limits access to the 2.5 models to users who have actively used them in the past, and points new projects to Gemini 3.5 Flash-Lite or 3.8 Flash. The newer models, per million tokens, from Google's pricing page:

Gemini 3.5 Flash-Lite: $0.30 input, $2.50 output
Gemini 3.6 and 3.8 Flash: $0.75 input, $3.75 output through December 31, 2026, then $1.50 and $7.50 from January 1, 2027. Gemini 3.5 Flash and 3.7 Flash were deprecated on October 8, 2026, and requests to them are answered by 3.6 Flash and 3.8 Flash.
Gemini 3.1 Pro Preview: $2.00 input and $12.00 output for prompts up to 200k tokens, $4.00 and $18.00 above
Gemini 4 Argon, released October 13, 2026: $2 input and $10 output through November 30, 2026, then $4 and $20 (full breakdown)
Gemini 3.1 Flash-Lite: $0.25 input, $1.50 output, but it is deprecated and shuts down on May 7, 2027 (its replacement is 3.5 Flash-Lite)

Price alone does not tell you which to use. 3.5 Flash-Lite costs the same as 2.5 Flash, and the 3.6 and 3.8 Flash models cost more today and double in price at the start of 2027. If your account still has 2.5 Flash and a task passes your quality bar on it, test 3.5 Flash-Lite on your own requests before you have to move, and re-check your numbers when the January price change lands.

Tracking the cost difference in production

PromptUnit shows every request with the model you asked for, the model that answered, what it cost and what it saved, so you can see what each part of your app really spends on Gemini. It works with your own Google key. It moves a request to a cheaper model only when it expects the answer to be just as good, and otherwise keeps the model you asked for.

If your Gemini costs have grown faster than you expected, start free: the first $5 of savings is free.

FAQ

How much cheaper is Gemini 2.5 Flash than Gemini 2.5 Pro?

About four times per token at standard lengths: Flash costs $0.30 per million input tokens and $2.50 per million output tokens, Pro $1.25 and $10.00 for prompts up to 200,000 tokens (Google's pricing page, October 2026). Above 200,000 tokens Pro rises to $2.50 and $15.00 while Flash stays the same, so the input gap grows to about eight times.

Can new projects still use Gemini 2.5 Pro and 2.5 Flash?

Google still serves both and lists no shutdown date, but it now limits access to the 2.5 models to users who have actively used them before, and points new projects to Gemini 3.5 Flash-Lite or Gemini 3.8 Flash.

Which newer Gemini model costs the same as Gemini 2.5 Flash?

Gemini 3.5 Flash-Lite: $0.30 per million input tokens and $2.50 per million output tokens, the same as 2.5 Flash, with a 1M-token context window. Gemini 3.8 Flash costs $0.75 and $3.75 through December 31, 2026, then $1.50 and $7.50.

When is Gemini 2.5 Pro worth the extra cost?

When a wrong answer is expensive: multi-step reasoning, debugging complex logic or writing non-trivial code, where Pro's lower error rate can pay for its price. When a mistake is cheap and easy to catch, Flash usually wins. Test both on a sample of your own requests before you decide.

Claude on AWS Bedrock vs Anthropic API: Cost Compared

scorpion4ik26-lang — Fri, 23 Oct 2026 14:00:38 +0000

I am the founder of PromptUnit. This post first appeared on the PromptUnit blog, where it is kept up to date.

The short answer: Claude costs the same per token on AWS Bedrock and on the Anthropic API, at global endpoint rates. The two platforms list identical input and output prices for every current Claude model. Costs diverge in specific situations: if you need regional data residency, Bedrock charges a 10% premium for region-locked routing (Anthropic's own API charges the same 10% for US-only inference). Beyond price, the platforms differ in feature availability, model freshness, and what you can build on top, and those differences affect total cost more than the per-token rate does.

The Baseline: Token Prices Are at Parity

Anthropic's pricing documentation is explicit that AWS Bedrock and Google Cloud use the same per-token rates as the direct Claude API for global endpoint traffic. Every figure in the table below reflects that: identical numbers on both platforms, on-demand, at standard global routing.

Model	Input (per 1M tokens)	Output (per 1M tokens)	Cache read (per 1M tokens)
Claude Haiku 5.5 (≤100K tokens)	$0.10	$0.50	$0.01
Claude Haiku 4.5	$1.00	$5.00	$0.10
Claude Sonnet 5.5	$2.00	$10.00	$0.10
Claude Sonnet 5	$2.00	$10.00	$0.20
Claude Opus 5.5	$4.00	$20.00	$0.20
Claude Opus 5 / Opus 4.8	$5.00	$25.00	$0.50
Claude Fable 5.1	$10.00	$50.00	$0.25

Prices per million tokens, on-demand, global endpoints. Source: Anthropic pricing documentation, October 2026.

Claude Sonnet 5's $2/$10 rate, which launched as introductory pricing with a scheduled increase to $3/$15 on September 1, 2026, had that increase cancelled. That permanent $2/$10 price applies on both platforms.

Where the Price Actually Diverges

Regional routing adds 10% on both sides

Starting with Claude Haiku 4.5, Sonnet 4.5, and Opus 4.5, Anthropic's pricing documentation specifies that Bedrock regional and multi-region endpoints carry a 10% premium over global endpoints. The global endpoint routes dynamically across available regions; a regional endpoint guarantees that inference stays within a specific geography for data residency. If you need data to stay in EU-West or US-East, you pay 10% more.

The same logic applies to the Anthropic direct API. Using the inference_geo: "us" parameter on Claude 4.6 and later models applies a 1.1x multiplier across all token categories, including input, output, cache writes, and cache reads. Neither platform is cheaper when you constrain geography: they both add 10% for data residency.

Batch processing: identical 50% discount

Both the Anthropic API and Bedrock offer a Batch API at 50% off on-demand rates. Sonnet 5 drops from $2/$10 to $1/$5 per million tokens in batch mode on both platforms. There is one important caveat on Bedrock: the Batch API is available only through the legacy InvokeModel integration for older models (Opus 4.6 and earlier). For newer models accessed via Bedrock's Messages API integration (Opus 4.7 and later), the Batch API is not currently available on Bedrock. If your workload runs on current-generation Claude models and you want batch pricing, the Anthropic direct API gives you access that Bedrock does not.

Prompt caching: same rates, same math

Prompt caching rates match across platforms. A 5-minute cache write costs 1.25x the base input price; a 1-hour write costs 2x; a cache read costs 0.1x (dropping to 0.05x on Claude Opus 5.5 and Sonnet 5.5, and 0.025x on Claude Fable 5.1). The prompt caching savings math is identical regardless of which platform you use.

Feature Differences That Drive Real Cost

Beyond token prices, the platforms differ in what they let you do, and those gaps affect your architecture and therefore your total bill.

New models arrive on Anthropic's API first

Anthropic releases new Claude models to its own API first. Bedrock availability follows, sometimes by weeks, sometimes by months depending on the AWS integration effort required. If a new model is meaningfully faster or cheaper than its predecessor, every week you spend waiting on Bedrock is a week you pay the old rate. Teams that depend on current-generation capabilities, or who want to benchmark new models immediately at launch, can only do that through the Anthropic direct API.

Server-side tools are not available on Bedrock

The Anthropic API's built-in web search and code execution tools are not available through Amazon Bedrock's standard integration. This matters for cost because server-side tools can replace agent loop architectures that otherwise compound token usage. If your agent needs web search at every step, the multi-agent cost spiral of hand-rolling that capability with API calls can add up quickly, and Bedrock does not give you a shortcut.

Rate limits are set independently

Bedrock and Anthropic set their own rate limits, and the limits differ by model and tier. Anthropic's direct API uses usage tiers (Start, Build, Scale) with explicit requests-per-minute and tokens-per-minute limits, and these scale automatically as you build usage history. Bedrock has its own quota system, managed through the AWS console, with separate limits per region and inference profile. For teams already on AWS with committed spend, Bedrock reserved throughput is an option for high-volume steady workloads, though it requires contacting AWS for pricing. Neither platform is obviously better here: it depends on your volume, region, and whether you already have AWS enterprise agreements that affect capacity.

The Third Option: Claude Platform on AWS

There is a middle path worth knowing about: Claude Platform on AWS, which launched in general availability in May 2026. Anthropic operates the stack, not AWS. It uses the standard Anthropic Messages API, gets new models on the same day as the direct API, and includes the same server-side tools and beta features. Billing runs through AWS Marketplace using Claude Consumption Units (CCUs), where 100 CCUs equals $1.00 at standard Anthropic per-model rates. If your team needs AWS-native billing and IAM authentication but also needs the latest features on day one, Claude Platform on AWS is worth evaluating separately from standard Bedrock.

The Practical Decision

For most teams running current-generation Claude models, the token-level cost comparison is a wash at global rates. The decision comes down to three non-price factors:

Use the Anthropic direct API if you: want the Batch API on current models (Opus 4.7 and later), need new models immediately on launch, use or plan to use server-side tools like web search, or prefer simpler billing without AWS.

Use AWS Bedrock if you: already have AWS infrastructure and want data within AWS boundaries, need IAM-based authentication or AWS CloudTrail for audit, or want to combine Claude with AWS-native services like Bedrock Guardrails and Bedrock Knowledge Bases. Be aware that Bedrock's standard integration does not currently support the Batch API for newer Claude models, so if 50% batch discounts matter for your workload, plan accordingly.

Use both if failover matters. Because the same Claude model sits on separate capacity pools, calling Anthropic direct as primary and Bedrock as failover keeps requests succeeding when one platform returns rate limit errors. A proxy or gateway layer handles the routing transparently. This is a common production pattern and worth considering if Claude is on the critical path of your application. The failover guide for AI APIs covers the error codes and retry logic for exactly this setup.

If you are trying to reduce the total Claude spend regardless of platform, the levers are the same on both sides: prompt caching, batch for async work, model tiering by task complexity, and output length control. The Claude API cost reduction guide walks through those steps in detail, and every technique in it applies whether your requests go to Anthropic or Bedrock. A cost optimization proxy like PromptUnit can also route calls to a cheaper model automatically when the task does not need the full capability of the model you asked for, connecting keys from multiple providers to widen the options.

The platform choice affects your architecture, compliance posture, and feature access. The token price, at global rates, is not the thing that distinguishes them.

FAQ

Is Claude cheaper on AWS Bedrock or the Anthropic API?

At global endpoint rates, the price is identical on both platforms. Claude Sonnet 5 costs $2 per million input tokens and $10 per million output tokens on both AWS Bedrock and the Anthropic direct API. The cost diverges if you use regional endpoints (both add a 10% premium for data residency) or if you want the Batch API on current-generation models, which is only available through the Anthropic direct API for Claude Opus 4.7 and later.

Does AWS charge a markup on Claude tokens compared to Anthropic's own API?

No, not at the standard global endpoint rate. Anthropic's own pricing documentation confirms that Bedrock global endpoints match the direct API dollar for dollar. The only token-level premium on Bedrock is for regional endpoints, which cost 10% more to guarantee that inference stays within a specific geography, and that same 10% applies on the Anthropic API too when you use the inference_geo parameter.

Does AWS Bedrock support the Claude Batch API for 50% off?

Bedrock supports a 50% batch discount, but only for older Claude models accessed through the legacy InvokeModel integration. For newer models using the Bedrock Messages API integration (Claude Opus 4.7 and later), the Batch API is not currently available on Bedrock. If you want batch pricing on current-generation Claude models, the Anthropic direct API is the only option.

Are all Claude models available on AWS Bedrock?

Not simultaneously with Anthropic's own API. Anthropic releases new Claude models to its direct API first, and Bedrock availability follows later, sometimes by weeks or months. If your application needs the latest model the day it launches, the Anthropic direct API is the only reliable choice.

What is Claude Platform on AWS and how does it differ from Bedrock?

Claude Platform on AWS is a separate offering where Anthropic operates the infrastructure, not AWS. It uses the standard Anthropic Messages API, gets new models on the same day as the direct API, and includes server-side tools like web search and code execution that are not available on standard Bedrock. Billing runs through AWS Marketplace using Claude Consumption Units, where 100 CCUs equals $1 at Anthropic's standard rates.

OpenAI API Cost Too High? Six Fixes, Ordered by Effort

scorpion4ik26-lang — Tue, 20 Oct 2026 14:00:38 +0000

I am the founder of PromptUnit. This post first appeared on the PromptUnit blog, where it is kept up to date.

If your OpenAI API cost feels too high, it usually is, and the fix is rarely "switch providers." OpenAI's current GPT-6 lineup alone spans a 100x price range: GPT-6 Astra costs $10.00 per million input tokens and $50.00 per million output tokens, while GPT-6 Luna costs $0.10 and $0.50. A team that sends every call to one strong model can often cut its bill sharply on the tasks where a cheaper model holds up. Moving a call from GPT-5.4 ($2.50/$15.00) to GPT-5.4 mini ($0.75/$4.50), for example, cuts that call's cost to 30% of what it was. The savings come from six approaches, none of which require rebuilding the product. They stack on top of each other, and the first two require almost no engineering work. Start there.

How to reduce OpenAI API costs: a checklist

The short version, in the order we would do it. Prices here and below are OpenAI's standard rates per million tokens (input/output) for prompts up to 272K input tokens, checked on OpenAI's pricing page on October 16, 2026.

Measure what each request costs. Log input, cached, output and reasoning tokens for every call, grouped by feature. There is a short code sample further down.
Use the cheapest model that passes your test. GPT-6 Luna ($0.10/$0.50) costs a twentieth of GPT-6.1 Sol ($2.00/$10.00) and a hundredth of GPT-6 Astra ($10.00/$50.00). Test on a sample of real traffic before you switch.
Check you are not paying more for an older model. GPT-5.5 ($5.00/$30.00) and GPT-5.6 Sol ($4.00/$20.00) cost more per token than GPT-6.1 Sol. GPT-6 Sol has the same list price as GPT-6.1 Sol but twice the cached-input price.
Set reasoning effort per task. GPT-5.5, GPT-5.6, GPT-6 Sol, GPT-6.1 Sol and GPT-6 Luna default to medium, and reasoning tokens are billed as output. Try low, or none where the model accepts it, on simple tasks.
Cap the output. Ask for short answers or JSON only, and set max_output_tokens with room left for reasoning.
Make prompt caching actually hit. Put stable content first, keep tools and settings the same between calls, and on GPT-5.6 and later add an explicit cache breakpoint after the static part. Cached input costs 50% to 95% less than normal input, depending on the model.
Send work that can wait to Flex or Batch. Both cost half the standard rate.
Skip the surcharges you do not need. Fast mode costs 2x on the GPT-6 models, prompts over 272K input tokens cost 2x input and 1.5x output on GPT-5.4, GPT-5.5, GPT-5.6 and GPT-6 models, and regional (data residency) endpoints add 10% for models released on or after March 5, 2026.
Trim what is left, then route per request. Shorten prompts and history, and only then consider sending some calls to other providers.

The rest of this post goes through the six main fixes in order of effort, then the newer settings (Flex, reasoning effort, Batch limits), current prices, a cost formula and the measuring code.

Option 1: Model Downgrade (Zero Engineering Effort)

The biggest single lever is also the easiest to pull. If your application is using GPT-5.4 ($2.50/$15.00) for tasks that do not require frontier reasoning, GPT-5.4 mini ($0.75/$4.50) costs 3.3 times less on both input and output. That is not a rounding error. A workload costing $3,000 per month on GPT-5.4 costs roughly $900 per month on GPT-5.4 mini for the same call volume, if the cheaper model passes your test.

The same logic applies one generation up. OpenAI's models page points to GPT-6 Astra ($10.00/$50.00) for complex reasoning and coding, GPT-6.1 Sol ($2.00/$10.00) to balance intelligence and cost, and GPT-6 Luna ($0.10/$0.50) for cost-sensitive, high-volume workloads. Astra to 6.1 Sol is 5 times cheaper per token. 6.1 Sol to Luna is another 20 times.

The practical test is simple: run 200 representative samples from your production traffic through both models. Score the outputs using whatever quality metric matters for your use case: accuracy on a labeled test set, human review ratings, downstream task performance. Classification, extraction, summarization, and Q&A with well-defined source context are where a cheaper model most often holds up, but how close it gets depends on your prompts, and OpenAI does not publish a gap you can rely on for your task. Let your own eval decide. For tasks requiring complex multi-step reasoning, extended chains of logic, or synthesis across long documents, expect a larger gap.

If you are running GPT-5.4 mini today and looking to go further, GPT-6 Luna at $0.10 per million input tokens and $0.50 per million output tokens is 7.5 times cheaper on input and 9 times cheaper on output. It also costs less than GPT-4o-mini ($0.15/$0.60). A workload costing $900 per month on GPT-5.4 mini would cost roughly $100 to $120 per month on GPT-6 Luna for the same tokens, if the task allows it. One catch: GPT-5.4 mini defaults to no reasoning, while GPT-6 Luna defaults to medium reasoning effort, and reasoning tokens are billed as output. Set the effort you need before you compare (Luna accepts none). Run the eval and find out. The downside of a failed experiment is a few hours of engineering time. The "GPT-4o vs GPT-4o-mini" section below gives a framework for making this decision.

Option 2: Output Length Control (Low Engineering Effort)

Output tokens cost more than input tokens on every GPT and o-series model on OpenAI's price list. On GPT-5.4, output costs $15.00 per million versus $2.50 per million for input, a 6:1 ratio. On the GPT-6 models it is 5:1 (GPT-6.1 Sol: $10.00 versus $2.00). On GPT-4o-mini, it is $0.60 versus $0.15, a 4:1 ratio. Reducing output token count has an outsized impact on total cost compared to reducing input by the same amount.

Adding output constraints to your existing prompts takes 10 minutes and costs nothing. "Respond in under 100 words" cuts verbose responses. "Return only the JSON object, no explanation or preamble" eliminates all the conversational wrapper around structured outputs. "Use at most three sentences" bounds conversational replies. If your application currently generates 300 tokens of output on average and these constraints bring it to 180 tokens, you have cut output costs by 40%. On a $2,000 monthly OpenAI bill where 70% is output token cost, that is $560 per month saved from prompt edits.

On reasoning models, the output also includes thinking you never see. OpenAI bills reasoning tokens as output tokens, and depending on the problem a model can generate anywhere from a few hundred to tens of thousands of them. Two settings help. reasoning.effort is covered in the Flex and reasoning section below. max_output_tokens caps reasoning and visible output together, so leave room: if the model hits the cap while still reasoning, the response comes back incomplete and you have still paid for the input and the reasoning. The Responses API also has a text.verbosity setting that changes how much detail the model writes.

Test the constrained prompts against your quality metric before deploying. For many structured tasks, shorter outputs are not worse outputs, they are more direct outputs. The model can often answer the question in 100 words. The extra 200 tokens are hedging, context-setting, and preamble that your application discards anyway.

Option 3: Prompt Caching (Medium Engineering Effort)

OpenAI's prompt caching is on by default for supported models, but a cache hit is not guaranteed and the discount depends on the model. Cached input costs 50% less on GPT-4o and GPT-4o-mini, 90% less on the GPT-5 and GPT-6 models (GPT-5.4: $0.25 instead of $2.50 per million), and 95% less on GPT-6.1 Sol. From GPT-5.6 on there is also a write charge: putting a prefix into the cache costs 1.25 times the normal input rate. So caching pays when a prefix is reused. OpenAI's own example: one write and nine full reads cost 2.15 times the ordinary input cost of that prefix, against 10 times without caching.

The requirement is structural. Stable content (the system prompt, tool definitions, shared reference material) goes first, and anything that changes, such as timestamps or user-specific data, goes at the end. On GPT-5.6 and later the shared prefix must be at least 1,024 tokens; on earlier models the minimum varies with request settings. A cached prefix on GPT-5.6 and later stays available for at least 30 minutes after it was last written or reused.

One catch on the newer models. With implicit caching, OpenAI places the cache breakpoint at the end of the latest eligible message, which in a simple request is the user message. If every request is the same system prompt followed by a different user message, the shared system prompt on its own is not reused. OpenAI's fix is an explicit breakpoint (prompt_cache_breakpoint) after the static part, which works on GPT-5.6 and later. Changing tools, reasoning.effort or text.verbosity between requests can also break the match. Check usage.input_tokens_details.cached_tokens instead of assuming caching works.

The savings add up for high-volume workloads with consistent system prompts. Consider a workload on GPT-6 Luna with a 2,000-token system prompt and 50,000 calls per day. Uncached input cost for the system prompt alone: 2,000 times 50,000 divided by 1,000,000 times $0.10 equals $10 per day. Now assume 9 in 10 calls read the prompt from the cache at $0.01 per million and 1 in 10 writes it again at $0.125 per million. That is $0.90 plus $1.25, or $2.15 per day. The saving is $7.85 per day, about $235 per month, from a stable prompt and one breakpoint. The 9-in-10 hit rate is an assumption: OpenAI's guide reports example deployments at about 70% and above 90% and says real rates depend on your application.

Anthropic's Claude models also discount cached input, under their own pricing rules. If you are evaluating whether to stay on OpenAI or move some workloads with large, stable system prompts to Anthropic, compare the cached rates on both sides, not just the list prices. The prompt caching cost savings guide covers both providers in detail.

Option 4: Prompt Compression (Medium Engineering Effort)

After caching, the next target is the non-cached portions of your prompt: the user-specific context, the conversation history, and the query itself. Prompt compression applies systematic token reduction to this content before it reaches the API.

The three highest-impact compression techniques are system prompt consolidation (removing redundant instructions), context trimming (summarizing or truncating old conversation turns), and few-shot reduction (testing whether fewer examples maintain quality). How much they save depends on how much padding your prompts carry today.

A concrete example: a summarization endpoint with a 1,200-token system prompt, 2,800-token document context, and 500-token user query totals 4,500 tokens per call. After compression: 400-token system prompt, 1,400-token trimmed context, 300-token query totals 2,100 tokens. A 53% reduction. At $2.50 per million input tokens on GPT-5.4 and 100,000 calls per month, that is $600 per month in input cost savings from prompt optimization. For the detailed technique breakdown, see LLM token reduction techniques.

Two caveats from OpenAI's caching guide. Summarizing or truncating conversation history changes the prompt prefix and can reset cache reuse, so compare total input cost before and after, not just token counts. And on GPT-5.6 and later a prefix under 1,024 tokens is not cached at all: cutting a 1,200-token system prompt to 400 tokens can turn a discounted cached prefix into a full-price one. Fewer tokens can still come out cheaper. Measure it.

Option 5: Cross-Provider Routing (Higher Engineering Effort)

OpenAI is not always the right provider for every call. For tasks where an alternative model performs adequately, routing those calls to a cheaper provider can produce substantial savings. The question is which tasks qualify.

The usual candidates for classification, extraction, and simple Q&A are the low-cost tiers at other providers, such as Google's Gemini Flash-Lite models and Anthropic's Claude Haiku models. Their prices change often, so check today's numbers on the Gemini 3.5 Flash-Lite and Claude Haiku 5.5 price pages rather than a table in a blog post, this one included. Before you add a second provider, compare against OpenAI's own cheap tier: GPT-6 Luna costs $0.10 per million input tokens and $0.50 per million output tokens. Cheaper is not automatically good enough, either. In our own early checks below, a cheaper model was judged worse on a research step.

Cross-provider routing requires maintaining API integrations with multiple providers and building quality validation for the routed calls. It is more engineering work than the earlier options, but for high-volume workloads, the payoff is proportionally larger. See the cross-provider LLM routing guide for implementation patterns that handle fallback, quality scoring, and provider selection logic.

Option 6: Batch API (Higher Effort for Some Teams, Easy for Others)

OpenAI's Batch API takes 50% off standard rates on the models that support it, which is most of them. Requests are submitted in bulk as a file, and each batch completes within 24 hours, often sooner. For workloads that do not require real-time responses, this is one of the simplest cost reductions available.

The use cases that qualify for batching are broader than most teams assume. Nightly data enrichment pipelines, content moderation queues, document classification for uploaded files, embedding generation, and analytics processing are all candidates. If a workload runs on a schedule or processes a queue rather than responding to live user requests, it likely qualifies.

The code change is small: write the requests to a .jsonl file, upload it, create the batch, and collect the results when it finishes. For a workload currently costing $2,000 per month that can be moved to batch, the savings are $1,000 per month. The implementation often takes a day. If a file and a 24-hour window do not fit your job, Flex processing (next section) gives the same 50% rate on ordinary requests. For more on the routing decision between batch and real-time, see the batch API routing decision guide.

Flex processing, reasoning effort and Batch limits

Three settings that change the bill without changing the model. All the facts here are from OpenAI's Flex processing, reasoning and Batch API guides.

Flex processing: Batch prices on ordinary requests

Set service_tier to "flex" on a normal Responses or Chat Completions request, and the tokens are billed at Batch API rates, half the standard price, with prompt caching discounts on top. The trade is slower responses and occasional resource unavailability. Flex is in beta with limited model availability. On the pricing page today that includes the GPT-6, GPT-6.1, GPT-5.6, GPT-5.5 and GPT-5.4 models, but not GPT-4o or GPT-4o-mini.

from openai import OpenAI

client = OpenAI()

response = client.with_options(timeout=900.0).responses.create(
    model="gpt-6-luna",
    input="Summarize this support thread in two sentences: ...",
    service_tier="flex",
)
print(response.output_text)

When capacity runs short, Flex returns a 429 Resource Unavailable error, and OpenAI does not charge for that request. Retry with exponential backoff if the job can wait, or retry with service_tier set to "auto" to pay the standard rate and get the answer now. Raise the SDK timeout as well: the default is 10 minutes, and OpenAI's own example uses 15 (the 900 seconds above).

Flex fits jobs that already run as ordinary API calls and can wait: model evaluations, data enrichment, background summaries. Batch fits large offline jobs you can package into a file.

Reasoning effort: the output tokens you do not see

The GPT-6 and GPT-5.6 models are reasoning models. They think in reasoning tokens before they answer, and OpenAI bills those as output tokens even though the API does not return them. reasoning.effort sets how much they think: lower effort favors speed and fewer tokens, higher effort a more thorough answer.

The defaults matter if you never set it. GPT-5.5, GPT-5.6, GPT-6 Sol, GPT-6.1 Sol and GPT-6 Luna all default to medium. Accepted values differ by model: GPT-6 Luna accepts none, GPT-6 Astra does not, GPT-6.1 Sol starts at low, and GPT-5.4 mini and nano default to none.

For classification, extraction and short replies, test low or none against the default on a sample and compare quality and cost.
Read usage.output_tokens_details.reasoning_tokens to see how much of each answer was thinking.
If you set max_output_tokens, remember it includes reasoning. OpenAI suggests reserving at least 25,000 tokens for reasoning and output when you start, then tightening once you know your numbers.
reasoning.mode: "pro" on GPT-5.6 and GPT-6 models does more work per answer and bills it at standard token rates, so the same request costs more. Use it where your evals show it pays.
Changing reasoning.effort between requests can break prompt caching. On GPT-6 models, OpenAI's guide shows how to change effort mid-conversation with a configuration_update input item that keeps the cached prefix.

Batch API limits worth knowing

A batch can hold up to 50,000 requests, and the input file can be up to 200 MB. Each file can only target one model.
The only completion window is 24 hours. If a batch expires, unfinished requests are cancelled and you pay for the ones that completed.
Batch has its own rate-limit pool, so it does not use up your standard per-model limits. You can create up to 2,000 batches per hour.
Output files are deleted 30 days after the batch completes, so download them.

Processing	Price vs standard	How you use it	Fits
Standard	1x	The default	Live user requests
Flex (beta)	0.5x	`service_tier: "flex"`	Evals, enrichment, background jobs that can wait
Batch	0.5x	Upload a `.jsonl` file, 24-hour window	Large offline jobs
Fast (Priority until July 30, 2026)	2x on GPT-5.4, GPT-5.6 and GPT-6 models	`service_tier: "fast"` or a project setting	User-facing traffic where speed is worth paying for

Fast mode deserves a check of its own. OpenAI lets you set Fast as a project's default service tier, and requests that do not name a tier then run in Fast mode at the higher price. If your bill looks double what the token counts suggest, look at the project setting.

What Combined Savings Look Like

This is an illustration with assumed percentages, not a measurement. Your numbers depend on your traffic, and each step only applies where quality holds. Applying all six options in sequence to an example high-volume workload:

Starting point: $5,000 per month on GPT-5.4 for mixed classification, extraction, and generation workloads.

Model downgrade (classification and extraction to GPT-5.4 mini or GPT-6 Luna where quality holds): saves 50 to 60% of those workloads' costs. New baseline: roughly $3,200 per month.

Output length control: reduces output costs by 35% across all remaining workloads. New baseline: roughly $2,500 per month.

Prompt caching: assume the repeated system prompt is read from the cache on most calls. Cached input on GPT-5.4 costs $0.25 instead of $2.50 per million, and here that trims roughly another 15% of the remaining bill. New baseline: roughly $2,100 per month.

Prompt compression: reduces variable token count by 40%. New baseline: roughly $1,500 per month.

Batching or Flex for workloads that can wait: cuts those workloads' costs by 50%. New baseline: roughly $1,100 per month.

Cross-provider routing for tasks that pass quality checks on cheaper models: reduces remaining workload costs by another 20 to 30%. Final baseline: roughly $800 per month.

The path from $5,000 to $800 per month is not a single dramatic change. It is six incremental optimizations applied in order of effort. Each one compounds on the others. The first two take a day. The last two take a week or more. But the direction is clear, and the arithmetic adds up.

Current OpenAI API pricing (2026)

Per million tokens, Standard tier, prompts up to 272K input tokens, from OpenAI's pricing page and models page on October 16, 2026:

Model	Input	Cached input	Output	What OpenAI positions it for
GPT-6 Astra	$10.00	$1.00	$50.00	Most demanding work, complex reasoning and coding
GPT-6.1 Sol	$2.00	$0.10	$10.00	Balance of intelligence and cost
GPT-6 Sol	$2.00	$0.20	$10.00	Coding and agents (6.1 Sol is the newer Sol)
GPT-6 Luna	$0.10	$0.01	$0.50	Focused, high-volume tasks
GPT-5.6 Sol	$4.00	$0.40	$20.00	GPT-5.6 flagship (promotional price)
GPT-5.6 Terra	$2.00	$0.20	$12.00	Balance of intelligence and cost (GPT-5.6 mini tier)
GPT-5.6 Luna	$0.20	$0.02	$1.20	Cost-sensitive work (GPT-5.6 nano tier)
GPT-5.5	$5.00	$0.50	$30.00	Earlier flagship for complex professional work
GPT-5.4	$2.50	$0.25	$15.00	Coding and professional work
GPT-5.4 mini	$0.75	$0.075	$4.50	High-volume work, coding, subagents
GPT-5.4 nano	$0.20	$0.02	$1.25	Classification, extraction, ranking
GPT-5	$1.25	$0.125	$10.00	Previous reasoning model
GPT-5 mini	$0.25	$0.025	$2.00	Cost-sensitive, high-volume work
GPT-5 nano	$0.05	$0.005	$0.40	Lowest per-token price in this table
GPT-4o	$2.50	$1.25	$10.00	Older general-purpose model
GPT-4o-mini	$0.15	$0.075	$0.60	Older small model for focused tasks
o3	$2.00	$0.50	$8.00	Older reasoning model, succeeded by GPT-5

Three things to notice. First, output tokens cost far more than input on every model (5:1 on the GPT-6 models, 6:1 on GPT-5.4), which is why output length control (Option 2) punches above its weight. Second, the gap between GPT-6 Astra and GPT-6 Luna is 100x, which is the whole reason model choice (Option 1) is the biggest lever. Third, newer is not always pricier: GPT-6.1 Sol costs less per token than GPT-5.4, GPT-5.5 and GPT-5.6 Sol, and less than GPT-5.6 Terra on output.

On top of the list prices:

Batch and Flex: 50% off standard on the models that support them.
Prompt caching: cached input costs 50% less on GPT-4o and GPT-4o-mini, 75% less on GPT-4.1 and o3, 90% less on the GPT-5 and GPT-6 models, and 95% less on GPT-6.1 Sol. On GPT-5.6 and later, cache writes cost 1.25 times the input price.
Long prompts: above 272K input tokens, GPT-5.4, GPT-5.5, GPT-5.6 and GPT-6 models charge twice the input price and 1.5 times the output price.
Fast mode (called Priority processing until July 30, 2026): 2x the standard price on the GPT-5.4, GPT-5.6 and GPT-6 models.
Regional processing (data residency) endpoints: 10% more for models released on or after March 5, 2026.
GPT-5.6 Sol's $4.00/$20.00 is a promotional price that OpenAI says runs at least through November 21, 2026.

If you buy OpenAI models through Azure instead, they are billed through Azure, not OpenAI. The Azure OpenAI pricing comparison has the side-by-side table and a worked monthly example. Note that the data residency surcharge is not Azure-only: OpenAI's own regional processing endpoints add 10% on newer models, as listed above.

Estimate your monthly cost

The formula is straightforward:

monthly cost = calls per month × (avg input tokens × input price + avg output tokens × output price) ÷ 1,000,000

Worked example, 200,000 calls per month at 1,000 input and 500 output tokens each:

On GPT-6 Astra: 200,000 × (1,000 × $10.00 + 500 × $50.00) ÷ 1,000,000 = $7,000/month
On GPT-5.4: 200,000 × (1,000 × $2.50 + 500 × $15.00) ÷ 1,000,000 = $2,000/month
On GPT-6.1 Sol: the same volume is about $1,400/month
On GPT-5.4 mini: about $600/month
On GPT-4o-mini (where the task allows): about $90/month
On GPT-6 Luna (where the task allows): about $70/month

The distance between those rows is the opportunity. One warning: on reasoning models, the 500 output tokens must include the reasoning tokens, and at the default medium effort the real number can be much higher than the visible answer. The only way to know which row your traffic can safely sit in, and what it really costs there, is to measure it per task, not per app.

Measure first: log what each request really costs

Before you change models or settings, record the real cost of each call. The Responses API returns everything you need in response.usage: input_tokens, input_tokens_details.cached_tokens and, on GPT-5.6 and later, input_tokens_details.cache_write_tokens, plus output_tokens and output_tokens_details.reasoning_tokens. This Python function turns that into dollars:

from openai import OpenAI

client = OpenAI()

# USD per 1M tokens, Standard tier, prompts up to 272K input tokens.
# From developers.openai.com/api/docs/pricing on Oct 16, 2026. Recheck before you rely on them.
PRICES = {
    "gpt-6.1-sol": {"input": 2.00, "cached": 0.10, "write": 2.50, "output": 10.00},
    "gpt-6-luna": {"input": 0.10, "cached": 0.01, "write": 0.125, "output": 0.50},
    "gpt-5.4-mini": {"input": 0.75, "cached": 0.075, "write": 0.75, "output": 4.50},  # no write charge before GPT-5.6
}


def request_cost(model: str, usage) -> dict:
    p = PRICES[model]
    details = usage.input_tokens_details
    cached = details.cached_tokens or 0
    written = getattr(details, "cache_write_tokens", 0) or 0
    uncached = usage.input_tokens - cached - written
    reasoning = usage.output_tokens_details.reasoning_tokens or 0
    cost = (
        uncached * p["input"]
        + cached * p["cached"]
        + written * p["write"]
        + usage.output_tokens * p["output"]  # output_tokens already includes reasoning tokens
    ) / 1_000_000
    return {
        "model": model,
        "cost_usd": round(cost, 6),
        "cache_hit_rate": round(cached / usage.input_tokens, 2) if usage.input_tokens else 0.0,
        "reasoning_tokens": reasoning,
        "output_tokens": usage.output_tokens,
    }


model = "gpt-6-luna"
response = client.responses.create(
    model=model,
    reasoning={"effort": "low"},
    input=[
        {"role": "developer", "content": "Label the support ticket as billing, bug or other. Reply with the label only."},
        {"role": "user", "content": "I was charged twice this month."},
    ],
)
print(request_cost(model, response.usage))

Log that result with a feature name for every call, then add it up per feature per day. Three numbers tend to explain a high bill: which features cost the most, how much of the input comes from the cache, and how much of the output is reasoning. Fix the biggest one first. The LLM cost tracking guide covers storing and grouping these numbers.

Not sure which of these fixes matters most for you? PromptUnit shows the cost of every request and checks which ones a cheaper model can answer just as well. You change two settings, the API base URL and a PromptUnit key (your own OpenAI key stays), and it is free until it has saved you $5 (individual accounts) or $100 (business accounts with a work email). Start free

GPT-4o vs GPT-4o-mini: when the cheaper model wins

GPT-4o-mini is about 16.7 times cheaper than GPT-4o on both input and output ($0.15 versus $2.50 per million input tokens, $0.60 versus $10.00 output). For a large share of production work, the cheaper model can hold up, but only your own test can tell you where:

Where mini is most likely to hold up: summarization, classification and intent detection, structured extraction with a clear schema, and well-scoped customer support replies. These are bounded tasks with a checkable right answer.
Where GPT-4o is more likely to earn its price: multi-step reasoning, non-trivial code generation, long-context synthesis, and brand-sensitive creative work.

The decision rule is simple: send the bounded, verifiable tasks to mini and keep the open-ended, high-stakes ones on the stronger model. Do not switch blind, run a sample of your real traffic through both and compare on your own quality metric before you move anything.

Both are older models now. If you are choosing today, the same split applies one generation up: GPT-6 Luna ($0.10/$0.50) costs less than GPT-4o-mini on both input and output, and GPT-6.1 Sol ($2.00/$10.00) costs less than GPT-4o on input and the same on output. The newer models are reasoning models, though, and reasoning tokens are billed as output, so compare cost per request on your own traffic, not just the price per token.

What we measured

We do not have to argue this from theory. With PromptUnit's optional side-by-side checks, after the answer has gone back to the app, cheaper models answer a sample of its real requests and the model the app asked for judges whether each cheaper answer is as good. This is early data from one production account:

From October 2 to 7, 2026, about 83% of its 183 live requests were simple question-answering and about 6% were heavy reasoning or complex code. PromptUnit's own classifier assigns these task types, so they are approximate.
In 24 side-by-side comparisons (October 5 to 7), a cheaper model matched or beat the chosen one 18 times (75%), at roughly 89% lower cost on those calls. Claude Sonnet 5 to GPT-5.4 mini matched 8 of 10. The judge was Claude Sonnet 5, the model the app had asked for, so it is not independent.

In an app the PromptUnit team runs itself (checks up to October 12, 2026, again judged by Claude Sonnet 5, the model the app asked for), GPT-5.4 mini was judged as good on the app's video-prompt step in 23 of 23 checks, at about 73% lower cost. On its web-research step, Claude Haiku 4.5 was judged worse than Sonnet 5 in 2 of 3 checks, so PromptUnit kept that step on Sonnet 5. Claude Haiku 5.5 was judged as good in only 4 of 8 checks on the same step. Cheaper models win on some steps and lose on others, which is why the test has to be per step, not per app.

Across the whole bill, the measured drop on the live account is about 11%, because most of its spend is long writing steps that stay on the stronger model. For a workload with many simple requests, we estimate a 40 to 70 percent reduction across the bill. That is an estimate, not a measurement.

The samples are small, so treat them as a signal, not a benchmark. The method and limits are in What We Measured Routing GPT-4o Traffic to Cheaper Models.

That is the pattern behind every fix above: most of the bill is spent on calls that are simpler than the model running them. The hidden cost of defaulting to your flagship model turns that into dollars per month of waiting.

PromptUnit automates the per-request part of options 1 and 5: it checks each call, and when a cheaper model is just as good for that request, including one at another provider whose key you connected, it uses that model; otherwise the call goes to the model you asked for. You change two settings, your API base URL and your PromptUnit key, instead of building the routing yourself.

If your OpenAI bill has grown faster than your usage or revenue, PromptUnit gives you the per-call cost data to identify where to apply these optimizations first.

FAQ

How do I reduce OpenAI API costs?

Measure what each request costs first, then work down the list: move simple tasks to a cheaper model after testing a sample of real traffic (GPT-6 Luna costs $0.10 per million input tokens and $0.50 per million output tokens), set reasoning effort per task, cap output length, put stable content first so prompt caching hits, and send work that can wait to Flex processing or the Batch API at half the standard rate. None of this requires leaving OpenAI.

Why is my OpenAI API cost so high in the first place?

Usually it's one default nobody revisited: every call goes to the flagship model regardless of task, output length is uncapped, reasoning effort stays at the default even for simple tasks, and caching either isn't set up or isn't structured to actually hit. None of those are hard problems, they just need someone to look.

Do I need to switch away from OpenAI to fix a high API bill?

No. Five of the six fixes here work entirely within OpenAI. Cross-provider routing is the one exception, and it comes late in the list because it's the most engineering work for the least additional savings once the other fixes are in place.

How fast can I see savings after fixing a too-high OpenAI API cost?

Model downgrade and output length control are same-day changes that need little engineering. Test quality on a sample of real requests first. Once they are live, you'll see the drop on your next invoice.

Is OpenAI prompt caching automatic?

It is on by default for supported models, but a cache hit is not guaranteed. Requests must start with the same content, and on GPT-5.6 and later the shared prefix must be at least 1,024 tokens. On those models a cache read costs 10% of the input price (5% on GPT-6.1 Sol) and a cache write costs 1.25 times the input price. If each request is a fixed system prompt plus a new user message, add an explicit cache breakpoint after the fixed part. Check usage.input_tokens_details.cached_tokens to see what was actually cached.

What is OpenAI Flex processing?

Flex is a service tier for requests that can wait. You set service_tier to flex on a normal Responses or Chat Completions request and pay Batch API rates, which are half the standard price. Responses are slower, and when capacity is short you get a 429 Resource Unavailable error, which OpenAI does not charge for. Flex is in beta and only some models support it, including the GPT-6, GPT-5.6, GPT-5.5 and GPT-5.4 models.

Claude API Pricing Per Million Tokens: All Models (Oct 2026)

scorpion4ik26-lang — Fri, 16 Oct 2026 09:37:20 +0000

I am the founder of PromptUnit. This post first appeared on the PromptUnit blog, where it is kept up to date.

Claude API pricing is per million tokens (MTok), with separate rates for input and output. As of October 14, 2026, Anthropic's pricing page lists four current models: Claude Haiku 5.5 at $0.10 input and $0.50 output (for prompts up to 100,000 tokens), Sonnet 5.5 at $2 and $10, Opus 5.5 at $4 and $20, and Fable 5.1 at $10 and $50. The Batch API halves those prices, and a cache read costs between 2.5% and 10% of the input price, depending on the model.

This guide lists every model's rates, recomputes four common workloads on the current models with the arithmetic shown, and covers the costs that sit outside the per-token table: long prompts on Haiku 5.5, the tokenizer change, US-only inference, fast mode, web search and code execution. Every Claude price below comes from Anthropic's documentation, read on October 14, 2026.

Claude API prices for every current model

Anthropic's models overview names four current models. Sonnet 5 and Haiku 4.5 are now legacy models but still available, so they are in the table too. Prices are per million tokens on the Claude API with global routing, which is the default.

Model	Input	Output	Cache hit	Context window	Anthropic's description
Claude Fable 5.1	$10	$50	$0.25	1M	Demanding reasoning and long-horizon agentic work
Claude Opus 5.5	$4	$20	$0.20	1M	Long-running agentic coding and knowledge work
Claude Sonnet 5.5	$2	$10	$0.10	1M	The best combination of speed and intelligence
Claude Haiku 5.5, prompts up to 100K tokens	$0.10	$0.50	$0.01	1M	High-volume, latency-sensitive tasks such as classification, extraction and routing
Claude Haiku 5.5, prompts over 100K tokens	$0.50	$2.50	$0.05	1M	Same model, higher rates
Claude Sonnet 5 (legacy)	$2	$10	$0.20	1M	Anthropic suggests moving to Sonnet 5.5
Claude Haiku 4.5 (legacy)	$1	$5	$0.10	200K	Anthropic suggests moving to Haiku 5.5

A few things the table does not show:

Sonnet 5's price is now permanent. Sonnet 5 launched at $2 and $10 as introductory pricing through August 31, 2026. Anthropic has made that the standard price, and the planned rise to $3 and $15 on September 1 will not happen.
Thinking tokens are output tokens. Thinking is on by default on Fable 5.1, Opus 5.5, Sonnet 5.5, Sonnet 5 and Haiku 5.5, and it cannot be turned off on Fable 5.1 and Opus 5.5. Anthropic's thinking docs say the reasoning tokens are billed as output tokens even when the thinking text is not returned to you. The effort parameter is the control: Opus 5.5 and Haiku 5.5 default to medium, the other models to high, and low spends the fewest tokens.
Haiku 4.5 is legacy, not deprecated. Anthropic's model deprecations page lists its retirement as not sooner than October 15, 2026, and Anthropic gives at least 60 days' notice before retiring a publicly released model. It also has the smallest context window (200K) and needs at least 4,096 tokens before a prompt can be cached.

Legacy and retired models

Older models still run on the Claude API at their own prices unless they are marked retired.

Model	Status on October 14, 2026	Input	Output	Cache hit
Claude Fable 5	Legacy, still available	$10	$50	$1
Claude Opus 5	Legacy, still available	$5	$25	$0.50
Claude Opus 4.8, 4.7 and 4.6	Legacy, still available	$5	$25	$0.50
Claude Opus 4.5	Legacy, retirement not sooner than November 24, 2026	$5	$25	$0.50
Claude Sonnet 4.6	Legacy, still available	$3	$15	$0.30
Claude Sonnet 4.5	Deprecated, retires November 30, 2026	$3	$15	$0.30

Retired on the Claude API: Opus 4.1 and Sonnet 4 (Anthropic's pricing page lists them as retired except on Bedrock and Google Cloud), and Opus 4 and Haiku 3.5 (retired except on Google Cloud). Haiku 3.5 was retired on February 19, 2026, so Google Cloud is the only place Anthropic still lists for it.

Claude Mythos is a separate model, not another name for Fable

Claude Mythos 5.1 and Mythos 5 are separate models. They have the same listed token prices as Fable 5.1 and Fable 5, but they are available only to organizations verified through Anthropic's verification programs, such as the Cyber Verification Program. What Claude Mythos costs and how its price changed covers the details.

Same text, more tokens: the tokenizer change

Anthropic's pricing page says Claude 4.7 and later models use a newer tokenizer that produces approximately 30% more tokens for the same text, and that the exact increase depends on the content. Sonnet 4.6 and earlier models use the previous tokenizer, and the Haiku 5.5 overview says the same text counts as about 30% more tokens on Haiku 5.5 than on Haiku 4.5.

So per-token prices overstate the saving when you move from an older model to a newer one. These estimates assume the full 30%; your own content may differ:

Sonnet 4.6 to Sonnet 5.5. The per-token price drops by a third ($3 to $2 input, $15 to $10 output). With 30% more tokens, the same task costs 2 x 1.3 = 2.6 against 3, about 13% less. This is an estimate, not a measurement.
Haiku 4.5 to Haiku 5.5 (prompts up to 100K tokens). 0.10 x 1.3 = 0.13 against 1.00, about 87% less per task. Also an estimate.
Opus 4.6 or 4.5 to Opus 5.5. 4 x 1.3 = 5.2 against 5, about 4% more per task. An estimate again.
Opus 4.7 or 4.8 to Opus 5.5. Both sides use the newer tokenizer, so the same input costs 20% less. Output length still depends on the model and the effort setting.

To get your own number, run a sample of real prompts through the token counting endpoint with each model's ID.

What four common workloads cost on current models

Each scenario uses 30-day months and token counts as the priced model counts them. Output tokens include any thinking tokens.

Scenario 1: customer support chat. 500 input and 200 output tokens per call, 10,000 calls a day.

Haiku 5.5: input is 500 x 10,000 = 5 million tokens x $0.10 = $0.50 a day. Output is 200 x 10,000 = 2 million tokens x $0.50 = $1.00 a day. Total $1.50 a day, $45 a month.
Sonnet 5.5: 5 million x $2 = $10, plus 2 million x $10 = $20. Total $30 a day, $900 a month, 20 times the Haiku 5.5 bill.
If you run this on Haiku 4.5 today, it costs 5 million x $1 = $5 plus 2 million x $5 = $10, so $15 a day or $450 a month. If your 500 and 200 were counted on Haiku 4.5, expect about 650 and 260 on Haiku 5.5 (an estimate): 6.5 million x $0.10 = $0.65 plus 2.6 million x $0.50 = $1.30, so $1.95 a day, about $59 a month.

The price gap does not tell you whether Haiku 5.5 answers your customers well enough. Test it on a sample of your own conversations before you switch.

Scenario 2: code review assistant. 3,000 input and 800 output tokens per call, 1,000 calls a day.

Sonnet 5.5: 3 million x $2 = $6, plus 0.8 million x $10 = $8. Total $14 a day, $420 a month.
Opus 5.5: 3 million x $4 = $12, plus 0.8 million x $20 = $16. Total $28 a day, $840 a month.
Haiku 5.5: 3 million x $0.10 = $0.30, plus 0.8 million x $0.50 = $0.40. Total $0.70 a day, $21 a month.
Coming from Sonnet 4.6, the same counts cost 3 million x $3 = $9 plus 0.8 million x $15 = $12, so $21 a day or $630 a month. With 30% more tokens on Sonnet 5.5 (3,900 and 1,040 per call): 3.9 million x $2 = $7.80 plus 1.04 million x $10 = $10.40, so $18.20 a day or $546 a month. That is about 13% less, not the 33% the per-token prices suggest, and it is an estimate.

Scenario 3: long document analysis. 10,000 input and 2,000 output tokens per call, 100 calls a day.

Opus 5.5: 1 million x $4 = $4, plus 0.2 million x $20 = $4. Total $8 a day, $240 a month. At 1,000 calls a day: $80 a day, $2,400 a month.
Fable 5.1: 1 million x $10 = $10, plus 0.2 million x $50 = $10. Total $20 a day, $600 a month.
If the results can wait for the Batch API: $120 a month on Opus 5.5, $300 on Fable 5.1.

Scenario 4: very long prompts on Haiku 5.5. 150,000 input and 2,000 output tokens per call, 100 calls a day.

Above 100,000 prompt tokens, Haiku 5.5 charges $0.50 and $2.50: 15 million x $0.50 = $7.50, plus 0.2 million x $2.50 = $0.50. Total $8 a day, $240 a month.
At the lower rates the same tokens would cost 15 million x $0.10 = $1.50 plus 0.2 million x $0.50 = $0.10, so $1.60 a day. Crossing the threshold puts the whole request on the higher rates, which are 5 times the lower ones.
Sonnet 5.5 for the same work: 15 million x $2 = $30, plus 0.2 million x $10 = $2. Total $32 a day, $960 a month, so Haiku 5.5 still costs a quarter as much here.

The threshold is sharp. A 99,000-token prompt costs 99,000 x $0.10 / 1 million = $0.0099 of input; a 101,000-token prompt costs 101,000 x $0.50 / 1 million = $0.0505, about 5 times as much for 2% more text. Cache reads and cache writes count toward the 100,000, so caching part of a long prompt does not keep a request under it.

How prompt caching changes the bill

Prompt caching stores a prompt prefix so later requests read it at a fraction of the input price. There are two ways to turn it on. Automatic caching takes a single cache_control field at the top level of the request, and the cache point moves forward on its own as a conversation grows. Explicit breakpoints put cache_control on individual blocks, up to 4 per request.

Cache operation	Price relative to base input	Example per MTok
5-minute cache write	1.25x	Sonnet 5.5: $2.50
1-hour cache write	2x	Sonnet 5.5: $4
Cache read on Fable 5.1 (and Mythos 5.1)	0.025x	$0.25
Cache read on Opus 5.5 and Sonnet 5.5	0.05x	$0.20 and $0.10
Cache read on all other models	0.1x	Haiku 5.5: $0.01

A worked example: a 2,000-token system prompt on Sonnet 5.5, sent with 50,000 calls a day.

Without caching: 2,000 x 50,000 = 100 million tokens x $2 = $200 a day.
With caching: 100 million x $0.10 = $10 a day in cache reads. One cache write costs 2,000 x $2.50 / 1 million = $0.005. At about 35 calls a minute, the 5-minute cache rarely expires, because each read refreshes it at no extra cost.
The saving is about $190 a day, or $5,700 a month, on that part of the input.
The same prompt on Fable 5.1 costs 100 million x $10 = $1,000 a day uncached and 100 million x $0.25 = $25 a day from the cache.

Four rules from the prompt caching docs decide whether this works for you:

Minimum length. The cached prefix must be at least 512 tokens on Fable 5.1, Opus 5.5, Sonnet 5.5 and Haiku 5.5; 1,024 on Sonnet 5, Sonnet 4.6 and Opus 4.8; 2,048 on Opus 4.7; and 4,096 on Haiku 4.5, Opus 4.6 and Opus 4.5. Shorter prefixes are not cached, so a 500-token prompt like the one in Scenario 1 would not qualify.
Exact prefix. The cache covers tools, system prompt and messages, in that order, up to the breakpoint. A timestamp or user ID inside that prefix changes it on every request, and you pay for a fresh write each time.
Timing. The lifetime is counted from the start of the request that writes or reads the entry, not from the end of the response.
Break-even. Anthropic says that at the 0.1x read price, a 5-minute write pays for itself after one cache read and a 1-hour write after two.

The multipliers stack with the Batch API discount and with data residency pricing. For a side-by-side with OpenAI's caching, see prompt caching on OpenAI and Anthropic.

Batch API: half price if you can wait

The Message Batches API charges 50% of the standard price on input and output. Anthropic says most batches finish within an hour. Results are available once every request is done or after 24 hours, whichever comes first, and requests that are not processed within 24 hours expire without charge. One batch holds up to 100,000 requests or 256 MB.

Model	Batch input	Batch output
Claude Fable 5.1	$5	$25
Claude Opus 5.5	$2	$10
Claude Sonnet 5.5	$1	$5
Claude Haiku 5.5, prompts up to 100K tokens	$0.05	$0.25
Claude Haiku 5.5, prompts over 100K tokens	$0.25	$1.25
Claude Sonnet 5 (legacy)	$1	$5
Claude Haiku 4.5 (legacy)	$0.50	$2.50

Batch and caching discounts combine. Because a batch can take longer than 5 minutes, Anthropic suggests the 1-hour cache for context shared across a batch. Fast mode is not available with the Batch API. Which workloads to move to batch goes through the decision.

Costs outside the token table

Item	Price	Conditions
US-only inference (`inference_geo: "us"`)	1.1x every token price	Claude 4.6 and later models; global routing, the default, is standard price
Fast mode on Opus 5.5	$8 input, $40 output per MTok	Research preview, access by request, Claude API only; Opus 5 and Opus 4.8 are $10 and $50
Web search	$10 per 1,000 searches	Plus standard token prices for the results; a search that errors is not billed
Web fetch	No extra charge	You pay for the tokens of the fetched content
Code execution	1,550 free hours per organization per month, then $0.05 per hour per container	Free when the request includes `web_search_20260209` or `web_fetch_20260209` (or later); execution time has a 5-minute minimum
Claude Managed Agents	$0.08 per session-hour	Counted only while a session is running, plus tokens; no batch discount
Tool use system prompt	286 extra input tokens	On Opus 5.5, Sonnet 5.5 and Haiku 5.5 with `tool_choice` auto or none, plus your own tool definitions

What these look like in practice:

US-only inference puts Sonnet 5.5 at $2.20 input and $11 output. It applies to input, output, cache writes and cache reads, and on Haiku 5.5 also to the over-100K rates. Haiku 4.5 does not accept the parameter.
Fast mode gives up to 2.5x higher output tokens per second at twice Opus 5.5's standard price. Scenario 3 on fast mode would cost 1 million x $8 = $8 plus 0.2 million x $40 = $8, so $16 a day instead of $8.
Web search adds up in agents. Three searches per request at 1,000 requests a day is 3,000 searches x $0.01 = $30 a day, before the tokens of the results.
Free credits. Anthropic's pricing FAQ says new users receive a small amount of free credits to test the API. It does not state the amount.

On other platforms: Claude Platform on AWS and Microsoft Foundry bill the same per-token rates through their marketplaces, in Claude Consumption Units at $0.01 each. Amazon Bedrock and Google Cloud set their own prices; for Claude 4.5 models and later, Anthropic's pricing page says their regional and multi-region endpoints cost 10% more than global ones. Claude on AWS Bedrock vs the Anthropic API compares the two.

Claude vs OpenAI at each price point

The OpenAI prices below come from OpenAI's pricing page on October 14, 2026: standard tier, prompts up to 272K input tokens. Models are paired by price, not by quality.

Price point	Claude model	Input / output	Cache read	OpenAI model	Input / output	Cached input
Lowest	Haiku 5.5	$0.10 / $0.50	$0.01	GPT-6 Luna	$0.10 / $0.50	$0.01
Middle	Sonnet 5.5	$2 / $10	$0.10	GPT-6.1 Sol	$2 / $10	$0.10
Upper	Opus 5.5	$4 / $20	$0.20	GPT-5.6 Sol	$4 / $20	$0.40
Top	Fable 5.1	$10 / $50	$0.25	GPT-6 Astra	$10 / $50	$1.00

The list prices match at every level. The differences are elsewhere:

Cache reads. Fable 5.1 reads from cache at $0.25 against GPT-6 Astra's $1.00, and Opus 5.5 at $0.20 against GPT-5.6 Sol's $0.40. OpenAI says GPT-5.6 Sol's price is promotional and available at least through November 21, 2026.
Long prompts. OpenAI charges more above 272K input tokens: GPT-6.1 Sol goes to $4 and $15, GPT-6 Astra to $20 and $75, GPT-6 Luna to $0.20 and $0.75. Fable 5.1, Opus 5.5 and Sonnet 5.5 keep the same price up to 1M tokens. Haiku 5.5 goes the other way: its higher rates start at 100K, so for a prompt between 100K and 272K tokens, GPT-6 Luna costs $0.10 and $0.50 while Haiku 5.5 costs $0.50 and $2.50.
Data residency. OpenAI also adds 10% for regional processing endpoints on models released on or after March 5, 2026.
Tokens are not the same unit. Each vendor has its own tokenizer, so the same text is a different number of tokens on each. Equal per-token prices do not mean equal cost per task. Count tokens on a sample of your own prompts on both sides.

Picking a tier

Price alone does not pick the model. Anthropic suggests starting with Opus 5.5 for most workloads and using Fable 5.1 when your evals on Opus 5.5 at higher effort still fall short, and it describes Haiku 5.5 as built for classification, extraction and routing. Before you pay for a bigger model, try a lower effort setting on the one you have: effort changes how many output tokens every response uses.

A practical test: run 200 to 500 representative inputs through two tiers, score the answers on your own criteria, then apply the prices above. Claude Haiku vs Sonnet: routing guide and the LLM model routing guide cover how to make that call per request instead of once for the whole app.

Where PromptUnit fits

PromptUnit makes that choice per request. Each request is checked: when a cheaper model is just as good for that request, PromptUnit uses it; otherwise the request goes to the model you asked for. If you connected keys for more than one provider, the cheaper model can be at another of those providers. Setup is two settings: point your app's AI API base URL at PromptUnit and add your PromptUnit key (the x-promptunit-key header). Your own Anthropic key stays. The dashboard shows every request: the model asked for, the model that answered, what it cost and what it saved. It is free until it has saved you money, then it takes 20% of what it saves.

The cheapest model per token is not always good enough. In one app the PromptUnit team runs itself (checks up to October 12, 2026, small samples, judged by Claude Sonnet 5, the model the app asked for, so not an independent judge), Claude Haiku 4.5 served the web-research step for five days with no errors and answers that passed the automatic format checks, yet it was judged worse than Sonnet 5 in 2 of 3 checks. PromptUnit stopped moving that step and kept it on Sonnet 5. Claude Haiku 5.5 was judged as good in only 4 of 8 checks on the same step. On the same app's video-prompt step, GPT-5.4 mini was judged as good in 23 of 23 checks at about 73% lower cost.

For a step-by-step plan to act on these numbers, see How to Reduce Claude API Costs: A Practical 5-Step Guide.

FAQ

How much does the Claude API cost?

As of October 14, 2026, Anthropic lists Claude Haiku 5.5 at $0.10 per million input tokens and $0.50 per million output tokens (prompts up to 100,000 tokens), Sonnet 5.5 at $2 and $10, Opus 5.5 at $4 and $20, and Fable 5.1 at $10 and $50. The Batch API halves these prices.

What is the cheapest Claude model?

Claude Haiku 5.5: $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100,000 tokens. A request whose prompt is over 100,000 tokens pays $0.50 and $2.50 instead. Through the Batch API the lower rates are $0.05 and $0.25.

How much does prompt caching save on Claude?

A cache read costs 0.1x the base input price on most models, 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1. Writing to the cache costs 1.25x the input price for a 5-minute cache and 2x for a 1-hour cache. On the current models the cached prefix must be at least 512 tokens.

Does Claude charge more for long prompts?

Not on Fable 5.1, Opus 5.5 or Sonnet 5.5: their 1M-token context window is billed at the standard rate. Haiku 5.5 is the exception: a request whose prompt is over 100,000 tokens pays 5 times the lower rates. The legacy Haiku 4.5 has a 200K-token context window.

Do newer Claude models use more tokens for the same text?

Yes. Anthropic says Claude 4.7 and later models use a newer tokenizer that produces about 30% more tokens for the same text, depending on the content. Sonnet 4.6, Haiku 4.5 and earlier models use the previous tokenizer, so compare costs per task, not only per token.

Is Claude Mythos the same model as Claude Fable?

No. Claude Mythos 5.1 and Mythos 5 are separate models with limited availability, open only to organizations verified through Anthropic's verification programs, such as the Cyber Verification Program. Their listed token prices match Fable 5.1 and Fable 5.

Does Claude's web search cost extra?

Yes. Web search costs $10 per 1,000 searches on the Claude API, plus standard token prices for the search results that enter the context. Web fetch has no extra charge: you pay only for the tokens of the fetched content.

Azure OpenAI Pricing (Oct 2026): GPT-6, Flex, PTU and Costs

scorpion4ik26-lang — Fri, 16 Oct 2026 09:05:53 +0000

I am the founder of PromptUnit. This post first appeared on the PromptUnit blog, where the prices are kept current.

Azure OpenAI and OpenAI's own API charge the same per-token list price for the same model, as long as you use Azure's Global Standard deployment. GPT-6.1 Sol, for example, costs $2.00 per million input tokens and $10.00 per million output tokens on both. What changes your bill is the deployment type you choose (Data Zone costs 10% more in US regions), whether you pay for provisioned throughput by the hour or reserve it, batch discounts, and the Azure services around the model: support, networking and monitoring.

The Azure prices below come from Microsoft's public Azure Retail Prices API (East US 2, USD, list prices). We used the API because the official Azure OpenAI pricing page loads its prices with JavaScript, and on October 12 it said its GPT-6 Sol and Luna prices were still being published. The OpenAI prices come from OpenAI's pricing page. We checked both on October 12, 2026. Microsoft now sells Azure OpenAI inside Microsoft Foundry, so you may see it called Foundry Models. Your own price can differ with an enterprise agreement, another region or another currency, so confirm in the Azure pricing calculator or with Microsoft before you commit.

Azure OpenAI pricing for GPT-6 and GPT-5.6

Standard pay-as-you-go prices per 1 million tokens, input / output, for prompts up to 272K input tokens. Longer prompts cost more on both platforms: GPT-6 Sol, for example, goes to $4.00 / $15.00.

Model	OpenAI direct	Azure Global Standard	Azure Data Zone (US regions)
GPT-6 Astra	$10.00 / $50.00	$10.00 / $50.00	$11.00 / $55.00
GPT-6.1 Sol	$2.00 / $10.00	$2.00 / $10.00	$2.20 / $11.00
GPT-6 Sol	$2.00 / $10.00	$2.00 / $10.00	$2.20 / $11.00
GPT-6 Luna	$0.10 / $0.50	$0.10 / $0.50	$0.11 / $0.55
GPT-5.6 Sol	$4.00 / $20.00	$4.00 / $20.00	$4.40 / $22.00
GPT-5.6 Terra	$2.00 / $12.00	$2.00 / $12.00	$2.20 / $13.20
GPT-5.6 Luna	$0.20 / $1.20	$0.20 / $1.20	$0.22 / $1.32

What the table shows:

Global Standard matches OpenAI's list price on every model above.
Data Zone costs 10% more than Global in every commercial US region in Microsoft's price list (the US Government regions have their own, higher prices). Outside the US it can cost 20% more: for the GPT-6 models in EU regions such as Sweden Central and West Europe (GPT-6 Sol is $2.40 / $12.00 there), and for GPT-5.5 and GPT-5.4 in Asia Pacific regions.
OpenAI calls GPT-5.6 Sol's price promotional and says it is available at least through November 21, 2026. Azure lists the same $4.00 / $20.00 today. Check both again after that date.
OpenAI's own models page suggests GPT-6 Astra for complex reasoning and coding, GPT-6.1 Sol to balance intelligence and cost, and GPT-6 Luna for cost-sensitive, high-volume work.

Flex and priority: half price or double

Both platforms sell the same models at a lower price for work that can wait (Flex) and at a higher price for faster answers (priority). Per 1 million tokens, input / output, prompts up to 272K tokens, from Microsoft's price list (East US 2) and OpenAI's pricing page, checked October 15, 2026:

Model	Standard (both)	Flex (OpenAI and Azure Global)	Priority on OpenAI ("Fast mode")	Priority on Azure Global
GPT-6 Astra	$10.00 / $50.00	$5.00 / $25.00	$20.00 / $100.00	Not listed
GPT-6.1 Sol	$2.00 / $10.00	$1.00 / $5.00	$4.00 / $20.00	Not listed
GPT-6 Sol	$2.00 / $10.00	$1.00 / $5.00	$4.00 / $20.00	$4.00 / $20.00
GPT-6 Luna	$0.10 / $0.50	$0.05 / $0.25	$0.20 / $1.00	Not listed
GPT-5.6 Sol	$4.00 / $20.00	$2.00 / $10.00	$8.00 / $40.00	$8.00 / $40.00
GPT-5.6 Terra	$2.00 / $12.00	$1.00 / $6.00	$4.00 / $24.00	$4.00 / $24.00
GPT-5.6 Luna	$0.20 / $1.20	$0.10 / $0.60	$0.40 / $2.40	$0.40 / $2.40

What the table shows:

Flex is exactly half the standard price on both platforms, and Azure lists it for Global deployments only. Microsoft's list has no Batch prices for these models, so on Azure, Flex is the half-price option for evaluations, enrichment and other background jobs.
Priority is exactly double on both where it is listed. Microsoft lists it for GPT-6 Sol and the GPT-5.6 models; on Data Zone it costs another 10%.
OpenAI renamed priority processing "Fast mode" on July 30, 2026. It also sells an Ultrafast tier for GPT-6 Astra and GPT-6.1 Sol at six times the standard price ($60.00 / $300.00 and $12.00 / $60.00); Microsoft's list has nothing like it.
Cached input follows the same rule: GPT-6.1 Sol's cache reads cost $0.05 per million tokens on Flex against $0.10 on standard.

Cached input and cache writes

On the GPT-6 and GPT-5.6 models, prompt caching is billed in two parts: a cache write when a prompt prefix is first stored, and a much lower cached-input price when a later request reuses it. Azure Global Standard lists the same cache prices as OpenAI for these models, per 1 million tokens:

Model	Input	Cache write	Cached input
GPT-6 Astra	$10.00	$12.50	$1.00
GPT-6.1 Sol	$2.00	$2.50	$0.10
GPT-6 Sol	$2.00	$2.50	$0.20
GPT-6 Luna	$0.10	$0.125	$0.01
GPT-5.6 Sol	$4.00	$5.00	$0.40
GPT-5.6 Terra	$2.00	$2.50	$0.20
GPT-5.6 Luna	$0.20	$0.25	$0.02

OpenAI's prompt caching guide gives the rule behind these numbers for GPT-5.6 and later: a write costs 1.25 times the normal input price, a read costs 0.1 times (0.05 times on GPT-6.1 Sol), and only prefixes of at least 1,024 tokens are cached. A prefix written once and then read nine times costs 2.15 times its normal input price, instead of 10 times without caching. Our prompt caching guide covers how to structure prompts so the cache gets used.

Older models: GPT-5.5, GPT-5.4, GPT-5 and GPT-4o

If you still run one of these models, here are their prices. OpenAI direct and Azure Global Standard charge the same, so they share a column:

Model	OpenAI direct and Azure Global Standard	Azure Data Zone (US regions)	Azure Global Batch
GPT-5.5	$5.00 / $30.00	$5.50 / $33.00	$2.50 / $15.00
GPT-5.4	$2.50 / $15.00	$2.75 / $16.50	$1.25 / $7.50
GPT-5.4 mini	$0.75 / $4.50	$0.825 / $4.95	$0.375 / $2.25
GPT-5	$1.25 / $10.00	$1.375 / $11.00	$0.625 / $5.00
GPT-5 mini	$0.25 / $2.00	$0.275 / $2.20	$0.125 / $1.00
GPT-4o	$2.50 / $10.00	$2.75 / $11.00	$1.25 / $5.00
GPT-4o mini	$0.15 / $0.60	$0.165 / $0.66	$0.075 / $0.30

GPT-5.5 and GPT-5.4 prices are for prompts under 272K tokens. Global Batch is half the Global Standard price on Azure, and OpenAI's Batch API gives the same 50% off these models. Microsoft's price list still has no Batch prices for the GPT-6 and GPT-5.6 models (checked October 15), but it now lists Flex at half price for them (see the Flex section above). On OpenAI, Batch and Flex are both half price, for example $1.00 / $5.00 for GPT-6 Sol.

The deployment types, in plain words

Microsoft's deployment types guide lists the options. The short version:

Deployment type	Where your data is processed	How you pay	Good for
Global Standard	Any Azure region	Per token	Most workloads: lowest price, new models first
Data Zone Standard	Inside the US, EU or APAC data zone	Per token	Teams that must keep processing inside a zone
Standard (regional)	Inside one Azure geography	Per token	Geography rules, low volume
Provisioned (PTU)	Global, Data Zone or regional	Per PTU per hour, or a 1-month or 1-year reservation	Steady high volume, steadier latency
Batch	Global or Data Zone	Per token at 50% off, 24-hour target	Large jobs that can wait

Microsoft's own advice is to start with Global Standard and move to another type only for a specific reason: data residency, reserved throughput or batch jobs. Global Standard also offers Flex processing for work that can wait and priority processing for faster answers, each billed per token at its own rate.

Azure OpenAI pricing calculator: monthly costs at three volumes

Put in your own numbers below: the calculator prices a month of tokens on each Azure deployment type and on OpenAI direct.

There is an interactive Azure OpenAI cost calculator (model, deployment type, monthly tokens, cached share) in the original version of this post.
Microsoft offers an official Azure pricing calculator for whole setups. For the model itself the arithmetic is short:

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

The table applies that formula at Global Standard prices, which are the same as OpenAI direct, to three monthly volumes with five input tokens for every output token:

Tokens per month (input + output)	GPT-6 Luna	GPT-6.1 Sol	GPT-6 Astra
5 million + 1 million	$1.00	$20.00	$100.00
50 million + 10 million	$10.00	$200.00	$1,000.00
500 million + 100 million	$100.00	$2,000.00	$10,000.00

On Data Zone in a US region, add 10% to every cell, so GPT-6.1 Sol at the middle volume becomes $220.00. On Flex, halve every cell: the same volume costs $100.00. For the GPT-6 models on Data Zone in the EU regions above, add 20% ($240.00).

Caching lowers the input side. Take the middle volume on GPT-6.1 Sol: if 30 million of the 50 million input tokens are cache reads and 1 million are cache writes, input costs $38.00 for the 19 million uncached tokens, $2.50 for the writes and $3.00 for the reads. That is $43.50 instead of $100.00, and the month comes to $143.50 instead of $200.00. Output costs 5 times as much as input on GPT-6.1 Sol, so long answers move the bill as much as long prompts. Use the token counts from your own usage dashboard.

Provisioned throughput (PTU): hourly or reserved

With provisioned throughput you pay for reserved capacity whether you use it or not. Microsoft bills it per PTU per hour, or at a lower rate with a 1-month or 1-year Azure reservation. List prices in East US 2 on October 12, 2026:

Deployment type	Hourly, per PTU	1-month reservation, per PTU	1-year reservation, per PTU	Minimum PTUs for GPT-6 Astra, GPT-6.1 Sol, GPT-5.6
Global Provisioned	$1.00	$260	$2,652	15
Data Zone Provisioned	$1.10	$286	$2,916	15
Regional Provisioned	$2.00	$286	$2,916	50

What 15 PTUs, the Global minimum, cost for one month:

How you pay	Cost for 15 PTUs
Hourly, all 730 hours of an average month	$10,950
1-month reservation	$3,900
1-year reservation	$3,315 a month ($39,780 a year)

For a deployment that runs all month, the hourly rate costs about 2.8 times a monthly reservation. Microsoft's PTU billing guide says hourly billing suits short-term use such as benchmarking, and that production deployments should use reservations. It also warns that a reservation does not guarantee capacity, so create the deployment first and buy the reservation after. Other regions cost more: in Sweden Central, Data Zone Provisioned is $1.20 per PTU per hour.

Is PTU worth it? At the yearly rate, 15 PTUs cost $3,315 a month. The same money buys about 830 million input and 165 million output tokens on GPT-6.1 Sol at Global Standard prices. PTU makes sense when steady traffic would cost more than that on pay-as-you-go. Throughput per PTU differs by model (Microsoft lists GPT-6.1 Sol at 3,000 input tokens per minute per PTU and GPT-6 Astra at 600), so size it with Microsoft's PTU sizing guide. PTU also gives guaranteed throughput and steadier latency, which Microsoft says best-effort standard deployments do not. For spiky or growing traffic, per-token pricing usually fits better.

Data residency costs extra on both platforms

If your data must stay in the US or the EU, budget for it on either platform when you use recent models:

Azure: Data Zone Standard is 10% over Global in US regions, and 20% over Global for the GPT-6 models in the EU regions we checked.
OpenAI: its pricing page says regional processing (data residency) endpoints cost 10% more for models released on or after March 5, 2026, and FedRAMP endpoints also cost 10% more. The GPT-6 Sol, GPT-6.1 Sol and GPT-6 Luna model pages each say regional processing adds a 10% premium where available.

So for GPT-6 models with EU residency, OpenAI's list uplift (10%) is lower than Azure's EU Data Zone uplift (20%). Check the models and regions you need, and count only the options that meet your rule.

What else changes the bill

The model price is only part of a production bill. These Azure items have no direct equivalent on OpenAI's API, so price them for your own setup:

Support. Production support on Azure comes from a paid Azure support plan. Microsoft lists Developer at $29 a month for trial and non-production use, Standard at $100 a month for production workloads and Professional Direct at $1,000 a month. Compare it with the support you get from OpenAI at your tier.
Data leaving Azure. Azure bills outbound data transfer per GB after the first 100 GB a month, which is free. Inbound data is free. If your app runs on AWS, Google Cloud or your own servers, every response travels out of Azure and counts.
Private networking. Private endpoints use Azure Private Link, billed per hour and per GB processed. Regulated teams often need it.
Logging. Azure Monitor and Log Analytics bill by the GB ingested and retained.

If you already run on Azure, several of these are costs you pay anyway. If you do not, add them to the comparison. Our Claude on AWS Bedrock vs Anthropic API comparison looks at the same question for another cloud.

When Azure wins, and when it is the only option

You already run on Azure and have credits or a spend commitment. Ask your Microsoft account team whether Azure OpenAI usage counts toward it.
You must keep data in a region or zone and need Azure's options. Data Zone and Regional deployments exist for that. For models released since March 5, 2026, Azure's US uplift matches OpenAI's 10%. For GPT-6 models in the EU, Azure's Data Zone costs more.
A compliance requirement decides it. Microsoft lists the certifications that cover Azure OpenAI on its compliance pages, and OpenAI lists its own on its security pages. Check both against your requirement (HIPAA, FedRAMP, SOC 2 and so on) before you compare prices. If only one of them qualifies, the price comparison no longer matters.
You can wait for new models. New models launch on Global Standard first. Microsoft says Data Zone types follow and geography-based types come last, with no guaranteed date, so a regional deployment may wait longer for a new model.

How to choose

Four questions decide it for most teams:

Do you already run on Azure? If yes, Azure OpenAI is usually simpler: your networking, monitoring and access controls exist, and Global Standard costs the same as OpenAI. If not, OpenAI direct has fewer extra line items.
Must data stay in a region or zone? If yes, budget 10% more for recent models on either platform, and 20% for GPT-6 models on Azure Data Zone in the EU.
Is your traffic steady and high? Compare a PTU reservation with pay-as-you-go using your own numbers, not the hourly PTU rate.
Can some work wait 24 hours? Batch is half price on OpenAI, and on Azure for GPT-5.5 and older models. Our guide to the Batch API's 50% discount covers which work fits.

Cut the bill on either platform

Choosing Azure or OpenAI changes the per-token price by 20% at most in the tables above. The model you pick changes it far more: GPT-6 Astra input costs $10.00 per million tokens and GPT-6 Luna costs $0.10, which is 100 times less. Many requests do not need the most expensive model. Our guides on model routing and cutting an OpenAI bill cover smaller models, caching, output limits and batch work. To compare another provider's prices, see our Claude API pricing guide.

PromptUnit makes that choice for each request. You change two settings in your app: the API base URL, which you point at PromptUnit, and your PromptUnit key, which you add as a header. Your own provider key stays. Each request is checked, and when a cheaper model is just as good for that request, PromptUnit uses it; otherwise the request goes to the model you asked for. It works with your OpenAI, Anthropic, Google, Groq and DeepSeek keys, and with your own OpenRouter key. It is free until it has saved you money, then it takes 20% of what it saves. If it saves nothing, you pay nothing. Start free.

PromptUnit does not connect to Azure OpenAI deployments directly today. OpenRouter can route to your own Azure deployment with its bring-your-own-key feature, and PromptUnit works with your OpenRouter key, but we have not tested the two together. If you need Azure OpenAI, email igal@promptunit.ai and tell us how you would use it.

FAQ

How much does Azure OpenAI cost?

On a Global Standard deployment you pay per token, at the same list price as OpenAI's own API. For example, GPT-6.1 Sol is $2.00 per million input tokens and $10.00 per million output tokens on both, and GPT-6 Luna is $0.10 and $0.50, checked October 15, 2026. Data Zone deployments cost 10% more in US regions, and provisioned throughput starts at $1.00 per PTU per hour.

Is Azure OpenAI cheaper than OpenAI?

Not on the per-token list price: Global Standard matches OpenAI. Azure can work out cheaper if Azure credits or a spend commitment cover it, or if a provisioned throughput reservation fits a steady high volume. Keeping data in a region costs extra on both: Azure Data Zone is 10% over Global in US regions and 20% for the GPT-6 models in the EU regions we checked, while OpenAI adds 10% on data residency endpoints for models released on or after March 5, 2026.

Does Azure OpenAI have a cheaper Flex tier?

Yes. Microsoft's price list now has Flex prices for Global deployments of the GPT-6 and GPT-5.6 models at half the Global Standard price, the same as OpenAI's Flex: GPT-6.1 Sol is $1.00 per million input tokens and $5.00 per million output tokens, GPT-6 Luna $0.05 and $0.25, checked October 15, 2026. Flex suits work that can wait. Microsoft's list has no Batch prices for these models.

Is there an Azure OpenAI pricing calculator?

Microsoft has an official Azure pricing calculator for whole setups. For the model itself the arithmetic is short: input tokens divided by 1,000,000 times the input price, plus output tokens divided by 1,000,000 times the output price. This page has a table of monthly costs for GPT-6 Luna, GPT-6.1 Sol and GPT-6 Astra at three volumes.

What does an Azure OpenAI PTU cost?

In East US 2 on October 12, 2026, Global Provisioned was $1.00 per PTU per hour, $260 per PTU for a 1-month reservation and $2,652 per PTU for a 1-year reservation. GPT-6 Astra, GPT-6.1 Sol and the GPT-5.6 models need at least 15 PTUs per Global or Data Zone deployment. For 15 PTUs that is $10,950 for a 730-hour month at the hourly rate, $3,900 with a monthly reservation and $3,315 a month with a yearly one.

Does OpenAI charge extra for data residency too?

Yes. OpenAI's pricing page says regional processing (data residency) endpoints cost 10% more for models released on or after March 5, 2026, and that FedRAMP endpoints also cost 10% more. So for recent models, keeping data in a region costs extra on both platforms.

Does PromptUnit work with Azure OpenAI?

Not directly. PromptUnit works with your own OpenAI, Anthropic, Google, Groq and DeepSeek keys, and with your own OpenRouter key. OpenRouter can route to your own Azure deployment through its bring-your-own-key feature, but we have not tested that combination. If you need Azure OpenAI, email igal@promptunit.ai and tell us how you would use it.