GPT-5.6 API Costs: What I’d Budget Beyond the Token Price

Start with the route, not the family name

The first thing I’d check in a GPT-5.6 integration is the model ID. According to OpenAI’s model guidance, gpt-5.6 routes to gpt-5.6-sol. It does not automatically select the cheapest tier that can handle a request.

If I want Terra or Luna pricing, I’d use gpt-5.6-terra or gpt-5.6-luna explicitly.

The July 30, 2026 pricing update reduced Terra rates by 20% and Luna rates by 80%, while leaving Sol unchanged. Here are the updated Standard rates for requests with at most 272,000 input tokens.

All token prices below are USD per 1 million tokens.

Model	Input	Cached input	Cache write	Output
gpt-5.6-sol	$5.00	$0.50	$6.25	$30.00
gpt-5.6-terra	$2.00	$0.20	$2.50	$12.00
gpt-5.6-luna	$0.20	$0.02	$0.25	$1.20

Source: OpenAI API pricing.

OpenAI positions Sol as the flagship, Terra as the balanced option, and Luna as the low-cost tier for high-volume work. I’d treat those descriptions as evaluation starting points, not routing rules.

The number that matters most for ordinary short-context traffic: output costs 6× as much as uncached input across all three tiers. Trimming unnecessary response text can matter more than shaving a few tokens off a system prompt.

Put the rates through an actual workload

A rate table is useful, but I prefer turning it into request costs immediately. The examples here use the updated July rates consistently, without caching, tools, retries, or regional adjustments.

A 1,000-input, 500-output request

For Sol:

Input:  1,000 / 1,000,000 × $5  = $0.005
Output:   500 / 1,000,000 × $30 = $0.015
Total:                           $0.020

Applying the same request shape to each model:

Model	Input cost	Output cost	Total per request
Sol	$0.005	$0.015	$0.020
Terra	$0.002	$0.006	$0.008
Luna	$0.0002	$0.0006	$0.0008

Output accounts for 75% of the token bill even though the request contains twice as many input tokens as output tokens.

For chat, code generation, and agents, I’d look for unnecessary verbosity before spending much time optimizing a small prompt.

One million requests per month

Now change the workload to:

• 1 million requests per month
• 2,000 input tokens per request
• 500 output tokens per request

That produces 2 billion input tokens and 500 million output tokens monthly.

Model	Monthly input	Monthly output	Monthly total
Sol	$10,000	$15,000	$25,000
Terra	$4,000	$6,000	$10,000
Luna	$400	$600	$1,000

For this workload, the price cuts move Terra from $12,500 to $10,000 and Luna from $5,000 to $1,000.

Those differences justify routing experiments. They do not prove that Luna is the cheapest way to complete the work. More retries, failed tool calls, or manual review can consume the apparent savings.

My preferred metric is:

Cost per successful task = total workflow cost / successful tasks

I’d track human review alongside that metric, rather than pretending it disappears because it is absent from the API invoice.

Treat 272K input tokens as a billing boundary

GPT-5.6 supports a 1.05M-token context window, but context capacity and short-context pricing are different limits.

When input exceeds 272,000 tokens, the higher rates apply to the entire request, not just the excess tokens:

• Input: 2×
• Cached input: 2×
• Cache writes: 2×
• Output: 1.5×

Model	Long input	Long cached input	Long cache write	Long output
Sol	$10.00	$1.00	$12.50	$45.00
Terra	$4.00	$0.40	$5.00	$18.00
Luna	$0.40	$0.04	$0.50	$1.80

This is a pricing cliff, not a gradual overage charge. It also means the 6× output-to-input ratio applies to short-context Standard pricing; long-context pricing has a different ratio because the multipliers differ.

Near the boundary, I’d inspect:

• Duplicate retrieval chunks
• Stale conversation history
• Repository files unrelated to the task
• Tool output that could be reduced before the next model call

That cleanup can do more than reduce token count: it can keep the whole request in the lower pricing band. OpenAI’s cost optimization guide covers additional approaches.

Choose a processing tier separately from the model

Model selection is only one pricing decision. Eligible GPT-5.6 text workloads also have different processing options.

These are short-context input/output rates per 1 million tokens:

Processing option	Sol	Terra	Luna	Where I’d consider it
Standard	$5 / $30	$2 / $12	$0.20 / $1.20	Normal synchronous traffic
Batch	$2.50 / $15	$1 / $6	$0.10 / $0.60	Offline asynchronous jobs
Flex	$2.50 / $15	$1 / $6	$0.10 / $0.60	Work that tolerates slower processing
Fast mode	$10 / $60	$4 / $24	$0.40 / $2.40	Latency-sensitive traffic

The listed Batch and Flex rates are 50% below Standard. I’d check their operational constraints before moving any production workload, rather than treating them as interchangeable discounts.

Priority Processing was renamed Fast mode on July 30, 2026. Existing requests using service_tier: "priority" remain compatible.

For Sol, Fast mode offers up to 2.5× faster processing at 2× the Standard token price, without changing model intelligence. That is a latency trade-off, not a quality upgrade. I’d pay for it only where the user-facing benefit justifies the premium.

Cache reuse, not merely long prompts

Cache writes cost 1.25× normal input, while matching cached reads use the discounted cached-input rate.

For a reusable 100,000-token prefix on short-context Sol:

Operation	Prefix input cost
One uncached use	$0.50
One cache write	$0.625, approximately $0.63
One matching cached read	$0.05

Two uncached uses cost $1.00. A cache write followed by one matching read costs $0.675, saving $0.325.

That comparison covers only the reusable prefix. It excludes output, other uncached input, tools, and retries.

The practical distinction is between a long prefix and a long, stable, reused prefix. A write that never gets reused costs more than ordinary input processing.

I’d measure actual cache hits and read the prompt caching documentation for matching requirements, explicit breakpoints, and TTL behavior before building savings into a forecast.

Budget for tokens you don’t see and calls outside the model

Reasoning is billed output

Reasoning tokens are charged as output tokens even when they do not appear in the visible response. A concise answer does not necessarily imply a small output-token bill.

Where supported, reasoning.mode = "pro" is a setting I’d benchmark rather than enable by default. OpenAI does not list a separate fixed Pro surcharge; its cost impact comes from resulting token usage.

The comparison should include task success, total output tokens, latency, and retries—not just whether one response looks better.

Search has its own bill

Standard web search is listed at $10 per 1,000 calls, plus search-content tokens billed at the selected model rate.

At that price, two searches can cost more than the model tokens for a small Luna request.

There is also a separate web search preview rate for non-reasoning models: $25 per 1,000 calls, with search-content tokens free. I would not apply one search rate across every tool and endpoint. Check the exact combination on the pricing page.

Residency can add an uplift

Eligible regional processing or data-residency endpoints for models released on or after March 5, 2026 carry a 10% uplift.

If residency is a requirement, that belongs in the initial estimate—not in an explanation for why the first invoice exceeded it.

Keep the older models in the comparison

A new family does not make previous routes irrelevant. These are the listed Standard short-context rates for several other OpenAI text models:

Model	Input	Cached input	Output
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.075	$4.50
gpt-5.4-nano	$0.20	$0.02	$1.25

Luna now matches GPT-5.4 nano’s $0.20 input rate, with slightly cheaper output: $1.20 versus $1.25.

That is a useful pricing comparison, not evidence that the models behave identically. I’d keep existing routes in the evaluation set until the replacement earns its place.

Also, ChatGPT subscriptions and API billing are separate products. “ChatGPT API pricing” does not identify a rate; the model and usage type do.

My production cost checklist

For a basic uncached request, the arithmetic is:

Token cost =
    (input tokens / 1,000,000 × input rate)
  + (output tokens / 1,000,000 × output rate)

For production, I’d expand that into a workflow estimate covering uncached input, cached reads, cache writes, output and reasoning tokens, tool fees, applicable processing-tier rates, regional uplift, retries, and fallbacks.

Then I’d run the same representative tasks through candidate routes:

1. Use explicit model IDs. Avoid paying Sol rates accidentally through gpt-5.6.
2. Start with the cheapest plausible model. Promote difficult tasks based on measured results.
3. Record billed output, not just visible text. Include reasoning usage.
4. Monitor the 272K boundary. Aggregate averages can hide expensive individual requests.
5. Test Batch or Flex for non-urgent work. Verify operational fit.
6. Measure cache reuse, tool calls, and retries. Do not assume their costs cancel out.
7. Compare cost per successful task against latency and reliability.

For cross-provider evaluations, a unified API such as CometAPI can be useful for running the same workload through multiple OpenAI-compatible routes.

The cheapest token rate is a starting hypothesis. The route I’d ship is the one that meets the quality and latency requirements at the lowest measured workflow cost.

---

Originally published at cometapi.com