OpenAI API cost calculator

gpt-5.6-terra lists input at USD 2 per 1M tokens and output at USD 12 per 1M tokens (snapshot 2026-08-29). So a month of one million input tokens and one million output tokens on that model costs the sum of those two figures before any modifier. Your bill is input tokens times the input rate, plus output tokens times the output rate, and then the adjustments an OpenAI invoice actually carries. The calculator below does that arithmetic for each model in the rate table and itemizes every adjustment you switch on.

Cached reads get priced at the cached-input rate. Cache writes on the gpt-5.6 models get their own rate. The batch toggle halves the total. And once a prompt crosses 272000 input tokens, the long-context rates take over on the models that publish one. The flat rate is the number you pay only if you never cache, never batch and never send a long prompt, and a calculator that stops there answers a narrower question than your invoice does.

Estimate your monthly OpenAI bill

Enter a month of traffic. The cache, write and batch controls all start off, so the first figure you see is the plain uncached, synchronous, short-context rate, and each modifier you switch on shows up in its own column.

What each control applies

• Cached share. OpenAI bills reused cached-input tokens at the model's reduced cached-input rate, discounted up to 90%. The calculator prices that share of your input tokens at the model's cached-input cell and the rest at the input cell. The minimum cacheable prompt length is 1,024 tokens for GPT-5.6 and later and 2,048 tokens for OpenAI models older than GPT-5.6. When your input tokens per request sit under a model's floor, the cached share is ignored for that model and a note says so, because no cache read can happen there.
• Cache writes. For GPT-5.6 and later, OpenAI cache writes cost 1.25× the standard uncached input-token rate and subsequent cache reads cost 0.1× that rate. The write field prices tokens on gpt-5.6-terra and gpt-5.6-luna only, the rows that carry a write rate in the table below. Other models leave the write column unpriced rather than silently treating it as zero.
• Batch. OpenAI's Batch API gives a 50% cost discount compared to synchronous APIs. The toggle halves the subtotal. If you turn on both the cached share and the batch toggle, the halving is applied after the cache pricing, and this page makes no claim about how the two combine on an actual invoice.
• Long context. When input tokens per request exceed 272000, the calculator switches to the long-context rates for the whole request on gpt-5.6-terra, gpt-5.6-luna, gpt-5.5 and gpt-5.4, and names the tier in the second column. Models without a long-context row keep their standard rates and get flagged.

Worked example with the default inputs

The defaults are one thousand requests a month, one thousand input tokens and one thousand output tokens each, so a million of each, uncached, not batched, short context. At those inputs the monthly bill per model is the input cell plus the output cell of the rate table, and the totals column below shows the sum.

Need a given token count priced across vendors rather than a monthly OpenAI workload? The token cost calculator does that, and the LLM cost calculator projects generic monthly spend across providers. For Anthropic rates the Claude API pricing page carries the equivalent table.

OpenAI rates by model, short and long context

Rates below cover the OpenAI models this calculator prices, in USD per 1M tokens, snapshot 2026-08-29. gpt-5.6-sol and the pro tier variants are not in the table. The two public sources this page prices from disagreed on their rates at the snapshot, so those rates are withheld rather than guessed; the split readings are documented on the price source disagreement page.

Embedding, audio, realtime and image models are outside this calculator's scope. For a rate lookup without the calculator, the GPT-4 and GPT-4o pricing page states the same list prices per million tokens.

A cache-write cell reading "not listed here" means no write rate for that model appears on this page, and the calculator leaves that column unpriced for it. Output rates sit above input rates in every row of the table, so trimming output tokens moves the bill more than trimming the prompt by the same count.

How cached reads change the bill

OpenAI prompt caching is enabled by default for supported OpenAI models. OpenAI prompt caching reuses work when requests share the same prompt prefix. The discount is only half of the story. OpenAI prompt caching also reduces the time spent processing input before the response starts.

The economics on the current generation are simple to state. On GPT-5.6 and later, writing a prefix once and fully reusing it once costs 1.35× its ordinary input cost versus 2× uncached, and across ten requests one write plus nine full reads costs 2.15× versus 10× without caching. On this page that plays out in the gpt-5.6-terra row, where a cached read is priced at USD 0.2 against USD 2 uncached and a write at USD 2.5 per 1M tokens (snapshot 2026-08-29).

To see how many reuses pay back a write on your own prompt size, the prompt caching break-even calculator plots that curve.

The cached-read ratio splits by model generation. Dividing the cached-input cell by the input cell in the rate table shows the gpt-5.6, gpt-5.5 and gpt-5.4 rows sitting at a tenth, and the gpt-4o and gpt-4o-mini rows at a different, higher share. A discount learned on gpt-4o misprices the newer rows badly, so the table below computes the ratio per row from the rates above.

Getting a hit in the first place

OpenAI advises putting stable developer instructions and shared reference material first, and placing timestamps, user-specific content or other dynamic content at the end or in later conversation messages. OpenAI advises appending new messages rather than rewriting earlier turns, because summarization, compaction, or context truncation can change the prefix and reset cache reuse. Chat products should notice the next one. In multi-turn applications, reusing the growing conversation history can save more input tokens than caching only the initial instructions.

A prompt under the floor is one reason a cached share never materializes. If a shared OpenAI prefix falls below the model's minimum cacheable length, OpenAI suggests shortening it or expanding it with useful, stable instructions, examples, or reference material. OpenAI states that short prefix lengths can cost more uncached than expanding to the minimum cacheable token length. The guide even works the crossover.

With a 1,024-token minimum, 0.1 read multiplier and 1.25 write multiplier, OpenAI's worked example shows that across 10 requests expanding an original prefix of at least 221 tokens to 1,024 tokens is cheaper, and the crossover approaches 102.4 tokens as reuse grows.

Lifetime and routing decide whether the second request finds the first one's cache.

OpenAI's prompt_cache_options.ttl has only one supported value, 30m, which is also the default, and a cached prefix remains eligible for reuse for 30 minutes after its most recent write or reuse. Reusing a cached OpenAI prefix refreshes its lifetime without another cache-write charge.

OpenAI's prompt_cache_retention value 24h typically keeps entries available for around 30 minutes and can retain them for up to 24 hours. OpenAI cached states live on individual machines, and traffic above 15 requests per minute can lead to overflow routing. Setting prompt_cache_key helps OpenAI requests with the same prefix reach the same cache; keys influence routing but do not guarantee a cache read hit.

Whatever share you type into the calculator, check it against the real counters after a week. OpenAI advises tracking usage.input_tokens_details.cached_tokens and usage.input_tokens_details.cache_write_tokens to measure actual cache performance. OpenAI defines the token cache-hit rate as total cached tokens divided by total input tokens. That measured rate is the number to put back into the cached-share field. One more detail worth knowing on the models that charge for writes. In OpenAI explicit-only caching mode, content after the last selected breakpoint is processed at the uncached input-token rate without a cache-write charge.

The long-context tier

The rate table carries a second set of rates for gpt-5.6-terra, gpt-5.6-luna, gpt-5.5 and gpt-5.4 that applies above 272000 input tokens (snapshot 2026-08-29). On gpt-5.6-terra, input moves from USD 2 to USD 4 per 1M tokens and output from USD 12 to USD 18. Cached reads and cache writes move too, which the long cached input and long cache write columns show. A flat calculator prices a document-heavy workload at the short rate and understates the bill by the gap between those columns.

The calculator applies the switch for you. Type the real input tokens per request, and once that figure is above the threshold every model with a long-context row is priced on it and the tier column says long context. The other models keep their standard rates and are flagged in the notes, so you can't mistake a flat figure for a priced tier. Pasting the actual document into the estimator is the quickest way to find out which side of the line a request lands on.

Batch, half price for work that can wait

OpenAI's Batch API gives a 50% cost discount compared to synchronous APIs. Each OpenAI batch completes within 24 hours and often more quickly. OpenAI's Batch API has substantially more rate-limit headroom than the synchronous APIs. Those facts are why the toggle exists. Flip it on with your real monthly volume and the batch adjustment column shows what the discount is worth to you in dollars, per model, before you write a line of code.

The mechanics in brief. OpenAI batches start with a .jsonl file where each line contains the details of an individual request. Each OpenAI batch request must include a unique custom_id used to reference results after completion. An OpenAI batch input file can only include requests to a single model.

A single OpenAI batch may include up to 50,000 requests and a batch input file can be up to 200 MB. OpenAI's batch completion window can currently only be set to 24h. The full lifecycle, from upload through polling to the output and error files, lives on the OpenAI Batch API page, and the batch API savings calculator compares the discount against sync pricing across vendors.

A couple of billing details matter for planning. When an OpenAI batch expires, unfinished requests are cancelled, completed responses are made available in the output file, and tokens consumed by completed requests are charged. Using OpenAI's Batch API does not consume tokens from standard per-model rate limits. OpenAI Batch API queue limits are calculated from the total input tokens queued for a model, and a completed batch's tokens no longer count against that limit. And a scope note before you assume every row qualifies.

OpenAI's Batch API is widely available across most but not all of its models.

Flex processing

OpenAI Flex processing provides lower costs for Responses or Chat Completions requests in exchange for slower response times and occasional resource unavailability. Under OpenAI Flex processing, tokens are priced at Batch API rates with additional discounts from prompt caching. OpenAI Flex processing is enabled by setting the service_tier parameter to flex. OpenAI Flex processing is in beta with limited model availability. When OpenAI Flex processing lacks resources it returns a 429 Resource Unavailable error and the request is not charged.

No flex rate is printed on this page. Only one of the public price sources our method reads carries flex prices, so under the agreement rule described below none are shown, and the calculator has no flex toggle. The official flex processing guide is the reference for that tier.

Output tokens and reasoning effort

Every row of the rate table prices an output token above an input token, so the output column is where the bill is most sensitive. OpenAI states that generating tokens is almost always the highest latency step and, as a general heuristic, cutting 50% of output tokens may cut about 50% of latency. OpenAI states that cost and latency are typically interconnected and that reducing tokens and requests generally leads to faster processing.

Reasoning tokens count against the output bound on the Responses API, so plan for them in the output field of the calculator.

In the OpenAI Responses API, max_output_tokens is an upper bound on tokens generated for a response, including visible output tokens and reasoning tokens. The OpenAI Responses API reasoning effort parameter supports the values none, minimal, low, medium, high, xhigh, and max. Reducing OpenAI reasoning effort can result in faster responses and fewer tokens used on reasoning. The OpenAI Responses API verbosity parameter supports the values low, medium, and high.

The rest of OpenAI's own cost guidance maps onto the calculator's fields directly. OpenAI's cost guidance is to lower the number of input tokens and aim for shorter model outputs. OpenAI's cost guidance is to limit the number of necessary requests to complete tasks. OpenAI notes max_tokens or stop_tokens can be used to end generation early. For structured output, OpenAI advises minimizing output syntax by shortening function names, omitting named arguments and coalescing parameters. Then there's the model row itself.

OpenAI's cost guidance is to select a smaller model that balances reduced costs and latency with maintained accuracy. OpenAI suggests swapping to a smaller, cheaper model and testing whether it maintains accuracy at the lower cost and latency point. OpenAI states that smaller models usually run faster and cheaper and, when used correctly, can even outperform larger models. Since the results table sorts by total, moving your workload from one row to the next is one glance.

Common questions

How much does the OpenAI API cost per month?

Multiply monthly input tokens by the input rate and monthly output tokens by the output rate, then apply the modifiers. On gpt-5.6-luna, one million input tokens cost USD 0.2 and one million output tokens USD 1.2 (snapshot 2026-08-29). The calculator above does this for each model at once.

Does prompt caching cost extra on OpenAI?

On the current generation, a write is charged and a read is discounted. For GPT-5.6 and later, OpenAI cache writes cost 1.25× the standard uncached input-token rate and subsequent cache reads cost 0.1× that rate. The rate table prints both figures for gpt-5.6-terra and gpt-5.6-luna, and the calculator's write field prices them.

Why did the calculator ignore my cached share?

Because the input tokens per request you entered sit under that model's floor. The minimum cacheable prompt length is 1,024 tokens for GPT-5.6 and later and 2,048 tokens for OpenAI models older than GPT-5.6. Raise the prompt size above the floor, or expand a stable prefix as OpenAI's guide suggests, and the cached column fills in.

How long does a batch job take, and what if it doesn't finish?

Each OpenAI batch completes within 24 hours and often more quickly. When an OpenAI batch expires, unfinished requests are cancelled, completed responses are made available in the output file, and tokens consumed by completed requests are charged. So you pay for the work that finished, at the batch rate, and resubmit the rest.

Does long context change the output price or only the input price?

Both. On gpt-5.6-terra the output rate moves from USD 12 to USD 18 per 1M tokens in the long tier, alongside the input change (snapshot 2026-08-29). The calculator prices all four kinds on the long row once a request crosses the threshold.

How accurate is the paste estimator?

Rough. For Gemini models, 100 tokens is equal to about 60-80 English words. That rule of thumb is Google's and OpenAI's tokenizers aren't the same, so the estimate exists to get you in range. The token counter gives an exact count when the request is close to a cache floor or the long-context threshold.

Can I cut the bill without switching models?

Yes, and the guidance is OpenAI's own. OpenAI names its Batch API and flex processing as additional ways to lower costs. OpenAI's model-selection guidance is to get accuracy right first, then maintain accuracy with the cheapest, fastest model possible. On this page that means turning on the batch toggle, entering a measured cached share, and trimming the output tokens per request, and the results table shows which one moves your total most.

How we measured this

Our method reads both of these public price sources in the same run, seconds apart: the OpenRouter models API at openrouter.ai/api/v1/models and the LiteLLM price registry at github.com/BerriAI/litellm.

A rate is printed only when both sources agree within 1 percent on every kind declared for the model, and a kind that only one source publishes is not declared at all, which is why some cache-write and long-context cells read as not listed.

Each value is also checked against a sane range for its kind, and anything outside that range is held rather than printed. Per-token rates are converted to USD per 1M tokens by multiplying by 1,000,000. The build date stamped on this page is 2026-08-29, and re-running the same two fetches on that date returns the same figures.

Every dollar figure above is computed in code from those rates at build time, and the calculator recomputes in your browser from the same constants. I run Chrome extensions under the Zovo network that call paid LLM APIs in production, and that operating experience is why this calculator itemizes each modifier instead of stopping at the flat rate. The prompt caching guide, the batch guide, the flex processing guide and the Responses API reference are the sources for every rule the prose states.