TL;DR
Base pricing: GPT-5.6 Standard short-context rates are $5 input / $30 output for Sol, $2.50 / $15 for Terra, and $1 / $6 for Luna per 1 million tokens.
Watch the hidden cost drivers: the generic gpt-5.6 alias routes to Sol, requests above 272K input tokens use higher long-context rates, and output tokens cost 6ร more than input tokens across all three GPT-5.6 tiers.
For production: compare cost per successful task, not token price alone. Accuracy, retries, tool calls, latency, caching, and human review can change the real cost.
OpenAI API Pricing at a Glance
For users searching broadly for OpenAI API pricing, the first question is usually: which current model am I actually paying for? The table below gives a compact view of several current OpenAI text models before we look more closely at GPT-5.6.
| Model | Input / 1M tokens | Cached input | Output / 1M tokens |
|---|---|---|---|
| gpt-5.6-sol | $5.00 | $0.50 | $30.00 |
| gpt-5.6-terra | $2.50 | $0.25 | $15.00 |
| gpt-5.6-luna | $1.00 | $0.10 | $6.00 |
| gpt-5.5 | $5.00 | $0.50 | $30.00 |
| gpt-5.4 | $2.50 | $0.25 | $15.00 |
| gpt-5.4-mini | $0.75 | $0.08 | $4.50 |
| gpt-5.4-nano | $0.20 | $0.02 | $1.25 |
Source*:* OpenAI API pricing
The most important pattern is easy to miss: GPT-5.6 output tokens cost 6ร as much as input tokens across Sol, Terra, and Luna. Long answers, verbose agents, and reasoning-heavy workflows can therefore raise costs faster than small changes in prompt length.
For a broader overview of the GPT-5.6 familyโincluding model capabilities, positioning, benchmarks, API access, and key launch featuresโsee OpenAI's GPT-5.6 announcement or CometAPI's GPT-5.6 guide. This article focuses specifically on pricing, cost calculations, and the factors that can affect your real API bill.
GPT-5.6 Pricing: Sol vs Terra vs Luna
GPT-5.6 introduces three pricing tiers. OpenAI positions Sol as the flagship route, Terra as the balanced option, and Luna as the lower-cost tier for high-volume workloads.
For a deeper look at the capabilities, how to access to GPT-5.6 API, and use cases of each model,details to see the here about GPT-5.6 model .
GPT-5.6 Standard pricing for requests with โค272K input tokens
| Model | Short input | Cached input | Cache write | Short output | Long input | Long cached input | Long cache write | Long output |
|---|---|---|---|---|---|---|---|---|
| gpt-5.6-sol | $5.00 | $0.50 | $6.25 | $30.00 | $10.00 | $1.00 | $12.50 | $45.00 |
| gpt-5.6-terra | $2.50 | $0.25 | $3.13 | $15.00 | $5.00 | $0.50 | $6.25 | $22.50 |
| gpt-5.6-luna | $1.00 | $0.10 | $1.25 | $6.00 | $2.00 | $0.20 | $2.50 | $9.00 |
Source*:* OpenAI API pricing
Long-context pricing: Requests with more than 272K input tokens use higher rates. Input, cached input, and cache writes are billed at 2ร the standard rate, while output is billed at 1.5ร. The higher rates apply to the entire request.
A reasonable starting point is to test Luna for simpler, high-volume tasks, Terra for balanced application workloads, and Sol for the most difficult or high-impact tasks. These are not universal recommendations: accuracy, retries, tool behavior, and human review can outweigh the difference in list price.
One important alias detail
OpenAI's model guidance states that the generic gpt-5.6 alias routes to gpt-5.6-sol.
That means a request sent to gpt-5.6 uses the Sol price tier. If your workload performs well on Terra or Luna, use the explicit model ID rather than assuming the generic alias selects the cheapest suitable tier.
Example 1: A Typical API Request
Start with a common request shape:
- 1,000 input tokens
- 500 output tokens
| Model | Cost per request | Cost per 1,000 requests |
|---|---|---|
| gpt-5.6-sol | $0.02 | $20 |
| gpt-5.6-terra | $0.01 | $10 |
| gpt-5.6-luna | $0.00 | $4 |
Calculation for Sol:
(1,000 / 1,000,000 ร $5) + (500 / 1,000,000 ร $30) = $0.020
This example also shows why output length matters. Even though the request contains twice as many input tokens as output tokens, the output portion represents 75% of the Sol token cost because output is priced at six times the input rate.
For chat, agents, and code generation, controlling unnecessary verbosity can sometimes save more than trimming a small system prompt.
Example 2: Monthly Cost at Scale
Now assume an application handles 1 million requests per month, averaging:
- 2,000 input tokens per request
- 500 output tokens per request
That equals 2 billion input tokens and 500 million output tokens per month.
| Model | Monthly input cost | Monthly output cost | Total |
|---|---|---|---|
| gpt-5.6-sol | $10,000 | $15,000 | $25,000 |
| gpt-5.6-terra | $5,000 | $7,500 | $12,500 |
| gpt-5.6-luna | $2,000 | $3,000 | $5,000 |
The gap is large enough to justify routing tests, but the lowest row is not automatically the best production choice. If a cheaper model causes more retries, failed tasks, or manual review, the total workflow cost may be higher.
Long-Context Pricing: What Happens Above 272K Tokens?
GPT-5.6 models support a 1.05M-token context window, but OpenAI applies higher rates when a request contains more than 272,000 input tokens.
For these long-context requests:
- input is charged at 2ร the short-context rate
- cached input and cache writes are also charged at 2ร
- output is charged at 1.5ร
- The higher rates apply to the full request, not only the tokens above 272K
For Sol, that changes input from $5 to $10 per 1M tokens and output from $30 to $45. The same multiplier structure applies to Terra and Luna.
This creates a coastal cliff near 272K. For workloads close to the threshold, reduce duplicate retrieval chunks, stale conversation history, unnecessary repository files, or verbose tool output before sending the request. See OpenAI's cost optimization guide for additional token-reduction guidance.
Standard, Batch, Flex, and Priority Pricing
For eligible GPT-5.6 text workloads, OpenAI offers multiple processing tiers.
| Tier | Sol input/output | Terra input/output | Luna input/output | Typical use |
|---|---|---|---|---|
| Standard | $5 / $30 | $2.50 / $15 | $1 / $6 | Normal synchronous traffic |
| Batch | $2.50 / $15 | $1.25 / $7.50 | $0.50 / $3 | Offline asynchronous jobs |
| Flex | $2.50 / $15 | $1.25 / $7.50 | $0.50 / $3 | Cost-sensitive work that can tolerate slower or less predictable processing |
| Priority | $10 / $60 | $5 / $30 | $2 / $12 | Latency-sensitive short-context traffic |
Batch and Flex are approximately 50% of Standard token rates for GPT-5.6. Priority is 2ร Standard for the listed short-context rates. OpenAI currently lists priority only for short-context processing, so do not extrapolate those rates to long-context requests.
See the official Batch, Flex, and Priority documentation before choosing a tier.
Prompt Caching: When Does It Save Money for GPT-5.6 ?
For GPT-5.6, cache writes cost 1.25ร the normal input rate, while cached reads receive the lower cached-input price.
Consider a reusable 100,000-token prefix on Sol:
| Action | Cost |
|---|---|
| Process once as normal uncached input | $0.50 |
| Write the prefix to cache | $0.63 |
| Read the cached prefix later | $0.05 |
Two uncached uses cost $1.00. One cache write plus one matching cached read costs $0.675, saving $0.325 in this simplified example.
Boundary of this example: This calculation compares only the reusable prefix's input cost. It does not include output tokens, other uncached input, tools, or retries. Real savings depend on whether the prefix matches the cache requirements and how often it is actually reused.
Caching is therefore most useful for long, stable prompt prefixes that receive repeated matching requests. A cache write that is never reused adds cost rather than reducing it.
OpenAI's prompt caching guide documents cache-write pricing, cached reads, explicit breakpoints, and TTL behavior.
Other Costs That Can Change Your OpenAI API Bill
Reasoning tokens and Pro mode
Reasoning tokens are billed as output tokens even when they are not shown as visible response text. Higher reasoning settings can therefore increase total output-token usage and latency.
Where supported, reasoning.mode = "pro" is better treated as a configuration to benchmark, not a default cost-saving or quality rule. OpenAI does not list a separate fixed Pro surcharge for this mode; the cost impact comes from the resulting token usage. A reasonable baseline is to test Standard and Pro on representative tasks and compare task success, total output tokens, latency, and retries.
Web search and other tools
OpenAI currently lists standard web search at $10 per 1,000 calls, plus search-content tokens billed at the selected model rate. Two web searches on a small Luna request can therefore cost more than the request's model tokens.
OpenAI also lists a separate web search preview price for non-reasoning models at $25 per 1,000 calls, with search-content tokens free. Check the exact tool and model combination on the official pricing page rather than applying one web-search rate to every endpoint.
Regional processing
Eligible regional processing or data-residency endpoints for models released on or after March 5, 2026 carry a 10% uplift according to OpenAI's pricing page. Enterprise teams with residency requirements should include that factor in budget estimates.
How to Calculate OpenAI API Cost
For a basic request:
Token cost =
(input tokens / 1M ร input rate)
- (output tokens / 1M ร output rate)
For production planning, expand it to include:
Total workflow cost =
uncached input
- cached input
- cache writes
- output and reasoning tokens
- tool fees
- service-tier adjustments
- regional uplift, if applicable
- retries and fallback requests
The most useful KPI is often:
Cost per successful task = total workflow cost / successful tasks
This prevents a cheaper token rate from looking artificially attractive when it also produces more failures or review work.
How to Choose the Right Model Without Overpaying
Use the price table as a starting point, then test on real tasks.
- Start with the lowest-cost model that appears capable of the task. Luna can be a sensible first test for simple, high-volume work, but do not assume it will be best for every extraction or summarization workload.
- Measure output length. GPT-5.6 output tokens cost 6ร input tokens, so verbose responses deserve attention.
- Watch the 272K threshold. Crossing it changes rates for the full request.
- Use Batch or Flex for eligible non-urgent work. Test operational constraints before moving production traffic.
- Cache only reusable prefixes. Measure actual cache hits rather than assuming a long prompt should be cached.
- Track tools and retries. They can erase savings from a cheaper model.
For teams comparing routes across providers, CometAPI pricing provides a live cross-model view. The CometAPI Quickstart and Cookbook can be used to run the same test set across multiple OpenAI-compatible routes.
FAQ
How much does the GPT-5.6 cost in 2026?
Pricing depends on the model. GPT-5.6 Standard short-context rates range from $1 input / $6 output per 1M tokens for Luna to $5 / $30 for Sol. Lower-cost models such as GPT-5.4 mini and nano are also available. Check the exact model on OpenAI's live pricing page.
Is ChatGPT API pricing the same as GPT-5.6 pricing?
โChatGPT API pricingโ is often used informally to mean OpenAI API pricing for chat-capable models, but ChatGPT subscriptions and API billing are separate products. API usage is priced by the specific model and usage type.
Which GPT-5.6 model is cheapest?
gpt-5.6-luna has the lowest GPT-5.6 Standard list price. It is a sensible model to test for cost-sensitive workloads, but the best production choice depends on accuracy, retries, latency, and review cost.
What model does gpt-5.6 use?
OpenAI's model guidance states that the gpt-5.6 alias routes to gpt-5.6-sol. Use explicit Terra or Luna model IDs when you want those tiers.
When does GPT-5.6 long-context pricing apply?
When input exceeds 272,000 tokens, GPT-5.6 uses higher long-context rates for the full request: 2ร input-related rates and 1.5ร output rates.
Are Batch and Flex cheaper than Standard for GPT-5.6?
For eligible GPT-5.6 workloads, the listed Batch and Flex token rates are about 50% lower than Standard. They have different processing characteristics, so confirm that the workload can tolerate those constraints.
Do cache writes cost extra for GPT-5.6?
Yes. GPT-5.6 cache writes are priced at 1.25ร normal input, while matching cached reads use the discounted cached-input rate. Savings depend on actual reuse.
Compare GPT-5.6 Costs on Your Own Workload
Pricing tables are a starting point. Your real cost depends on prompts, output length, cache hit rate, tools, retries, and task success.
With CometAPI, you can test GPT-5.6 Sol, Terra, Luna, and other models through one OpenAI-compatible API using the same workload.
Next steps: compare current model pricing, follow the CometAPI Quickstart, or use the CometAPI Cookbook to build repeatable model evaluations.
Choose the lowest-cost route that still meets your quality, latency, and reliability requirements.