OpenAI Pricing 2026: What It Actually Costs

On July 30, 2026, OpenAI cut GPT-5.6 Luna by 80% and Terra by 20%. Three weeks later, on August 21, the flagship Sol fell from $5 and $30 per million tokens to $4 and $20. Then on September 3 the company released GPT-6 Astra at $10 and $50, two and a half times what Sol now costs. None of it was announced in advance, and the Sol rate is temporary. Anyone who built a twelve-month forecast before July is now working from numbers that no longer exist.

The rates themselves are published and easy to read. What makes OpenAI pricing hard is that they move without warning, and that a cut can turn into a bigger bill when consumption rises to fill the space the discount opened. A flat invoice after an 80% price cut is not good news. It means usage tripled and nobody noticed.

That gap between what you are charged and what you understand about the charge is what Economize closes. It pulls OpenAI spend into the same dashboards as your AWS, Azure, and GCP costs, allocates it to the teams and features that caused it, and flags when consumption breaks pattern instead of leaving you to find out at month end. For a rough number before connecting anything, our free LLM cost calculator covers 100+ models across 10 providers with no signup.

What follows is what OpenAI charges today, how the charges are calculated, which model to put a workload on, what changes when you buy the same models through Azure, and where the money leaks. Every figure was verified on September 4, 2026 against OpenAI’s published pricing, with sources linked throughout.

The short answer

On the API, GPT-6 Astra costs $10 per million input tokens and $50 per million output tokens. GPT-5.6 Sol costs $4 and $20, Terra $2 and $12, and Luna $0.20 and $1.20. Cached input bills at 10% of the input rate, and the Batch API halves everything.

ChatGPT subscriptions are billed separately from the API and start at $20 a month for Plus. Nothing you spend on seats counts toward API usage, and nothing you spend on the API counts toward a seat.

Why OpenAI pricing keeps changing

OpenAI made eight pricing-relevant changes in eight weeks, all of them dated in the company’s API changelog.

Date	Change
Jul 9	GPT-5.6 family goes GA: Sol, Terra, Luna
Jul 22	Hard spend limits arrive per organization and project. Requests return 429 at the cap
Jul 30	Luna cut 80%, Terra cut 20%. Fast mode replaces Priority Processing at twice the standard rate
Aug 4	Usage and Costs APIs gain an API-key dimension
Aug 13	Ultrafast mode announced for Sol, up to 14x standard speed, limited preview
Aug 21	Sol drops to $4 and $20, promotional at least through November 21
Sep 3	GPT-6 Astra released at $10 and $50 per million tokens, rolling out in stages

Read that as a warning rather than a history, because three of those entries will change somebody’s bill this quarter without anybody touching the code.

The Sol cut is the clearest, because it is explicitly temporary. OpenAI’s wording is that the pricing is “available at least through November 21, 2026,” which is a floor rather than a commitment and says nothing about November 22. If your forecast assumes $4 and $20 holds, you are betting on a promotion. Run a second scenario at $5 and $30 and see whether the plan survives.

The July 30 change is sneakier, because it was a rename. Fast mode replaced Priority Processing, and OpenAI kept the migration backward compatible so nothing broke. Requests still tagged service_tier: “priority” now run as Fast mode at twice the standard rate. If somebody set that flag in the spring to fix a latency complaint, that traffic has been billing at double ever since, and no deprecation notice will tell you.

The two dashboard entries point the other way. The Usage and Costs APIs can now break spend down by API key, and hard spend limits return a 429 at the cap instead of accruing an overage. Both are worth turning on this week.

Astra is the newest entry, and it moves the ceiling rather than the floor. At $10 and $50 it costs two and a half times Sol, and OpenAI’s model page already marks it Default. That is how a routing decision quietly becomes a budget decision.

How OpenAI API pricing works

There is no subscription and no seat on the API. OpenAI pricing here is purely per token, counted in four buckets that carry four different rates.

• Input tokens are everything you send: the prompt, the system message, tool definitions, retrieved documents, and the entire conversation history that gets replayed on every turn.
• Cached input tokens are a repeated prefix that OpenAI already holds in memory, and they bill at 10% of the input rate.
• Cache write tokens are what you pay to put a prefix into the cache in the first place, at 1.25x the input rate on GPT-5.6.
• Output tokens are everything the model generates, priced at 5x to 6x the input rate depending on the tier.

That last bucket is where most estimates fall apart, because output is bigger than it looks. Reasoning tokens bill as output even though they never reach the user, so a response showing somebody 200 words may have burned several thousand tokens working out what to say. Size a reasoning-heavy workload from response length and you will be wrong by a multiple, not a margin.
The four buckets still are not enough, because the same token can bill at five different rates depending on how you send it.

What changes the rate	Effect
Batch	0.5x
Flex	0.5x
Fast mode	2.0x on the API, 2.5x inside Codex and ChatGPT Work
Long context, above 272K input tokens	2x input and 1.5x output, applied to the whole request
Regional processing for data residency	1.1x

Fast mode is worth flagging twice, because the same feature name carries a different multiplier on the API than it does inside Codex and ChatGPT Work. Two other rows deserve a closer look. Batch and Flex both halve your token rates, and most teams have more asynchronous-tolerant work than they think. The long-context multiplier is the one nobody plans for, because per OpenAI’s Sol model card it reprices the entire request rather than the tokens above the line. An agent accumulating retrieved documents and tool results across a session can wander over 272K without anybody choosing to.

Tool calls sit outside the token model and bill on top of it. Web search costs $10 per 1,000 calls plus the content tokens it returns, and container sessions run $0.03 for 1 GB up to $1.92 for 64 GB, billed per minute with a five-minute floor. One voice agent doing retrieval can touch five meters in a single turn, only one of which shows up in a per-token comparison.

How to calculate OpenAI API costs

The arithmetic behind OpenAI pricing is not the hard part. Here is the whole formula:

Monthly cost = requests x [
    (uncached input tokens x input rate)
  + (cached input tokens x input rate x 0.10)
  + (output tokens x output rate)
] / 1,000,000

Then apply your service-tier multiplier, and the long-context multiplier if any request crosses 272K.

The hard part is getting honest numbers into it, and there are four places people go wrong.

2. Count the whole prompt on every turn. History gets resent with each request, so a twenty-turn chat pays for turn one twenty times unless that prefix is cached or compacted.

3. Measure reasoning tokens on real traffic. Read reasoning_tokens from an actual response instead of inferring output volume from what the user sees.

4. Add the waste. A retried request bills in full, and so does a generation you discard.

To make that concrete, take a support assistant handling 300,000 requests a month. Each request sends 4,000 input tokens, 3,000 of which are a stable system prompt that stays cached, and returns 600 output tokens. That works out to 300M uncached input tokens, 900M cached input tokens, and 180M output tokens a month. Here is what the same workload costs on each of the three GPT-5.6 tiers:

Component	Sol	Terra	Luna
Uncached input	$1,200	$600	$60
Cached input	$360	$180	$18
Output	$3,600	$2,160	$216
Monthly total	$5,160	$2,940	$294

The same traffic costs 17 times more on the top tier than the bottom, and the only thing that changes is one string in a config file. Run it on Astra instead and the month costs $12,900, two and a half times Sol and forty-four times Luna.

The same workload shows what the other levers are worth. On Terra without caching it costs $4,560, so the cache saves $1,620 a month, 36% of the bill. On Batch it halves again to $1,470. With a stale priority flag it doubles to $5,880. Three decisions on identical traffic produce a spread of $1,470 to $5,880.

OpenAI pricing by model: which one to actually use

GPT-6 Astra is now OpenAI’s most capable model, and GPT-5.6 is still where most production workloads sit. Sol is the 5.6 flagship, Terra the everyday tier, Luna the high-volume tier, and the gpt-5.6 alias routes to Sol. Prices below are USD per million tokens on the Standard tier with short context, from OpenAI’s API pricing page.

Model	Input	Cached input	Output
GPT-6 Astra	$10.00	$1.00	$50.00
GPT-5.6 Sol	$4.00	$0.40	$20.00
GPT-5.6 Terra	$2.00	$0.20	$12.00
GPT-5.6 Luna	$0.20	$0.02	$1.20
GPT-5.5	$5.00	$0.50	$30.00
GPT-5.3-Codex	$1.75	$0.175	$14.00
GPT-5.6 Cyber	$12.50	$1.25	$75.00
chat-latest	$5.00	$0.50	$30.0

The most useful row is GPT-5.5. Sol is now cheaper than the model it replaced, so any workload still pointed at GPT-5.5 pays 25% more on input and 50% more on output for an older model. That migration is worth doing this month.

The second is the spread. Inside GPT-5.6 it is 20x on input, and from Astra down to Luna it is 50x. Classification, routing, extraction, and summarization rarely need a flagship, and moving those jobs down a tier is the largest single lever in OpenAI pricing. Make that call by running an evaluation on your own traffic to find the cheapest tier that clears your quality bar, not from benchmark scores.

Astra is the row to be careful with, because the rate is published but the access is staged. As of September 4 its model page had it live only for enterprises in the Trusted Access Program, with the API, Azure, Bedrock, and the paid ChatGPT plans following over the days after launch. Rather than trusting any date, check whether gpt-6-astra is actually exposed in your own account: the Free tier is excluded outright, and Enterprise workspaces have Astra switched off until an admin enables it. Astra also drops things you may depend on, including none reasoning effort, custom temperature and top_p, and log probabilities, and its tool calling runs only through the Responses API. Misalignment monitoring can pause or stop an agent run for review. Judge it on finished tasks rather than tokens, because the case for $10 and $50 rests on Astra needing fewer steps to get there, and that is a claim only your own workload can settle.

One clarification, since it comes up constantly: there is no separate ChatGPT API. The chat-latest snapshot points at whichever model currently serves ChatGPT Plus and Pro, prices like GPT-5.5, and OpenAI recommends Sol for production instead.

Azure OpenAI pricing: the same model, a different bill

Everything above assumes you buy directly from OpenAI, and plenty of teams do not. That changes the OpenAI pricing you actually pay. If you are already on Azure, Microsoft Foundry is the natural route to these models, and Microsoft commits to matching OpenAI’s token rates. That commitment holds on the rates but not on the timing, and the gap is worth real money.

Microsoft’s Foundry announcement lists Sol at $5 input and $30 output on Standard Global, footnoting that the cut to $4 and $20 runs from September 1, 2026 through at least November 30. OpenAI’s own cut took effect August 21 and runs through at least November 21.

Model	Azure Standard Global Input	Azure output
GPT-5.6 Sol	$5.00, falling to $4.00 on Sep 1	$30.00, falling to $20.00
GPT-5.6 Terra	$2.00	$12.00
GPT-5.6 Luna	$0.20	$1.20

So the identical model, in the same week, costs different amounts depending on which invoice it lands on. Between August 21 and September 1, an Azure customer pays 25% more on input and 50% more on output than someone calling OpenAI directly, and Azure’s window then runs nine days longer at the other end. Expect the same pattern with Astra, which OpenAI says will reach Azure and Bedrock as the rollout continues, on whatever schedule each platform sets.

Three more Azure mechanics change the math. Deployment type affects the rate, since Global, Data Zone, and Regional are priced differently and Microsoft sends Data Zone and Priority Processing pricing to a sales conversation. Provisioned Throughput is a commitment rather than a discount, because PTUs bill per reserved capacity hour whether you use them or not, and every token price cut moves that break-even against a reservation you already signed. And the token rate is the floor of an Azure OpenAI bill rather than the estimate, because Private Link, Log Analytics, egress, and support plans land on the same invoice.

How to reduce OpenAI costs

Eight levers do most of the work in OpenAI pricing, ordered here by effort against return. The first three cost almost nothing to try.

• Audit your service-tier flags. Anything still tagged priority is running at 2x. This is one line of code and an immediate 50% cut on that traffic.
• Re-tier by measured quality gap. The input spread inside GPT-5.6 is 20x. Run an evaluation on your own traffic and move every job that clears the bar on a cheaper tier.
• Move anything asynchronous to Batch or Flex. Both halve token rates. Evaluation runs, backfills, nightly enrichment, and report generation almost always qualify.
• Restructure prompts for the cache. Put stable instructions and tool definitions first, add an explicit breakpoint after them, and set a consistent prompt_cache_key. Then confirm the hit rate on OpenAI’s caching dashboard rather than assuming it worked.
• Cap the context. Compact conversation history and trim retrieval payloads before requests cross 272K, where input doubles and output rises by half.
• Kill the silent waste. Retries billed in full, abandoned generations, oversized max_tokens values, and reasoning effort set higher than the task requires.
• Set hard spend limits per project. A 429 at the cap is easier to explain than an overage after the fact.
• Split spend by API key and project. The Usage and Costs APIs support that dimension, and the same gap exists on the infrastructure side, covered in the AWS costs you cannot tag. Without it, every step above is guesswork about which team or feature moved the number.

How Economize turns OpenAI spend into decisions

Seven of those levers your team can ship in a sprint. The eighth is the one OpenAI’s own tooling cannot finish for you, and it is what makes the other seven repeatable.

OpenAI groups spend by API key, and an API key is not a customer, a feature, or an agent. No provider offers a session or an agent API either, so the two units an AI bill actually moves in exist nowhere in the data you are handed. Reporting also stops at the OpenAI boundary, so the same models bought through Azure or Bedrock arrive on separate invoices in separate formats.

Economize’s AI Costs dashboard starts from those missing units:

• Unit costs you can budget against: total AI cost, cost per 1M tokens, cost per inference, cost per session, and cost per agent run. Economize derives the last two, since no provider computes them. A session is calls from the same user, key, or agent less than thirty minutes apart, and an agent run is one session on a key marked as an agent.
• One breakdown table, three toggles: Provider, Agent, and Model. The difference between “our OpenAI bill went up” and “the ticket triage agent moved from Luna to Sol.”
• A per-call log: tokens in and out, cached tokens, status, latency, and cost per request. Where the requests crossing 272K show up, and where you learn whether your prompt cache works as well as you assumed.
• Five providers in one view: OpenAI, Anthropic, Amazon Bedrock, Google Vertex, and Azure OpenAI, sitting beside the AWS and GCP spend competing for the same budget.
• Two lines of code to connect OpenAI: a project key, store: true, and a metadata tag. Prompt text stays off by default, because ingestion begins as metadata only.
• An AI FinOps agent on the same data: the engineer who suspects their feature caused last week’s jump can just ask.
  

Cost per 1M tokens is the one that answers the question this article opened with. When Sol drops 20% and your total holds steady the invoice tells you nothing, but a falling cost per token against rising volume tells you the rate moved and consumption moved with it. That is a week’s notice on the next rate change instead of a surprise at month end, which on this year’s form is worth having before November.

Frequently asked questions

OpenAI pricing will move again before November. Connect your accounts to Economize and see your AI and cloud spend in one place before it does.