OpenAI API Cost Planning: Caching, Batch, Flex and Budgets
Calculate task costs, choose processing modes and evaluate caching. For the full model catalogue and rates, use the OpenAI API pricing owner.
Quick answer: GPT-6 Luna is the lowest-cost GPT-6 option at $0.10 input and $0.50 output per million tokens. GPT-6.1 Sol costs $2 input and $10 output. GPT-6 Astra costs $10 input and $50 output. Rates below 272K input are shown unless a long-context row says otherwise.
Rates used in the workload examples
| Model | Input | Cached input | Cache write | Output |
|---|---|---|---|---|
| GPT-6 Astra | $10.00 | $1.00 | $12.50 | $50.00 |
| GPT-6.1 Sol | $2.00 | $0.10 | $2.50 | $10.00 |
| GPT-6 Luna | $0.10 | $0.01 | $0.125 | $0.50 |
Prices are USD per one million tokens. Output prices include reasoning tokens where the provider documents them as output tokens. Tool calls can also create additional model input and output, so a low visible message count does not guarantee a low bill.
Choose a workload baseline, not just the lowest token price
GPT-6 Luna is the cheapest current GPT-6 model in the central APIpulse dataset. It is suited to focused, high-volume work where cost and latency matter more than maximum capability. GPT-6.1 Sol is the middle option for coding, tool use and agentic workflows. GPT-6 Astra is the premium choice for the hardest tasks, but it costs 100 times Luna's standard input rate and 100 times its output rate.
The correct choice depends on total task cost, not token price alone. A cheaper model that needs repeated retries can cost more than a stronger model that succeeds once. Evaluate quality, latency and tool-call reliability on a representative workload before routing production traffic.
Long-context pricing above 272K input tokens
For GPT-6 requests above 272,000 input tokens, OpenAI applies higher rates to the full request rather than only the tokens above the threshold.
| Model | Long input | Long cached input | Long cache write | Long output |
|---|---|---|---|---|
| GPT-6 Astra | $20.00 | $2.00 | $25.00 | $75.00 |
| GPT-6.1 Sol | $4.00 | $0.40 | $5.00 | $15.00 |
| GPT-6 Luna | $0.20 | $0.02 | $0.25 | $0.75 |
This threshold makes prompt discipline important. Long conversation histories, retrieved documents and tool results can push an otherwise ordinary request into the higher tier. Measure the complete serialized input after retrieval and before sending it.
Batch, Flex and Fast processing
Processing mode changes both price and delivery characteristics. Batch and Flex are priced at 50 percent of Standard for the GPT-6 family in the current published schedule. Fast is priced at twice Standard. Batch suits asynchronous jobs. Flex trades predictable latency for lower cost and capacity availability. Fast is for latency-sensitive workloads that justify a premium.
| Model | Batch/Flex input | Batch/Flex output | Fast input | Fast output |
|---|---|---|---|---|
| GPT-6 Astra | $5.00 | $25.00 | $20.00 | $100.00 |
| GPT-6.1 Sol | $1.00 | $5.00 | $4.00 | $20.00 |
| GPT-6 Luna | $0.05 | $0.25 | $0.20 | $1.00 |
Do not assume that every endpoint, region or account has every processing mode. Availability and service-level behavior can differ. EU regional processing is limited to supported Standard paths and regional processing can carry an additional charge.
Cached input and cache writes
Cached input is much cheaper than fresh input when a stable prefix can be reused. Cache-write rates are higher than normal input because they create the reusable cache entry. Caching works best for large system instructions, policies or reference context reused across many requests. It is less useful when the prompt prefix changes on every call or the reuse window is too short.
Estimate a cache strategy with three numbers: the initial write cost, expected read count and uncached input avoided. Include invalidation and versioning so an old policy or tool schema is not silently reused.
Cost examples
A request with 100,000 fresh input tokens and 10,000 output tokens costs about $0.30 on Sol at standard short-context rates: $0.20 for input and $0.10 for output. The same request costs about $1.50 on Astra and $0.015 on Luna. These examples exclude tool-side fees, image or audio units, storage and retries.
If that Sol request crosses the long-context threshold, the full request uses the long rate. A 300,000-token input and 20,000-token output request would cost about $1.50 on Sol: $1.20 input plus $0.30 output. The threshold effect is why trimming retrieved context can produce a disproportionate saving.
How to choose a processing plan
- Start with Luna for classification, extraction and other bounded tasks.
- Benchmark Sol for coding, agents and work that needs stronger reasoning.
- Reserve Astra for cases where evaluation data demonstrates a meaningful quality gain.
- Move asynchronous evaluation, enrichment and back-office work to Batch or Flex.
- Use caching only after measuring prefix reuse.
- Set alerts around long-context thresholds and retry loops.
OpenAI pricing pages and ownership
The OpenAI provider pricing catalogue owns the model ladder. This supporting guide owns workload budgeting, cache economics and processing choices. For workload planning, use the AI API cost calculator. For cross-provider decisions, use the model comparison tool and the API pricing comparison.
Source of truth: values displayed with model data attributes are synchronized from pricing-data.js. Pricing and availability can change after publication, so verify the provider's current pricing page before signing a contract or launching a high-volume workload.
FAQ
How much does the OpenAI API cost?
For the current GPT-6 family, standard short-context rates range from $0.10 input and $0.50 output per million tokens for Luna to $10 input and $50 output for Astra. Sol sits between them at $2 input and $10 output.
When does long-context pricing apply?
For these GPT-6 models, requests above 272K input tokens use the published long-context rates for the full request.
Is Batch cheaper than Standard?
Yes. Current GPT-6 Batch pricing is 50 percent of Standard, but it is intended for asynchronous work rather than interactive responses.
Does cached input reduce output cost?
No. Cached-input pricing applies to reused input tokens. Output tokens retain the processing mode's output rate.