OpenAI Cost Calculator

Estimate your monthly OpenAI API costs. Adjust your usage pattern and see how GPT models compare to alternatives.

OpenAI cheapest option: GPT-5.6 Luna at U$ 13.00/mo — overall cheapest is Llama 4 Maverick (U$ 7.00/mo)

OpenAI Models

ModelPer RequestMonthly Total
bestGPT-5.6 LunaU$ 0.0013U$ 13.00
GPT-5.6 TerraU$ 0.0130U$ 130
GPT-5.6 SolU$ 0.0325U$ 325

All Models (Comparison)

ModelPer RequestMonthly Total
bestLlama 4 MaverickU$ 0.000700U$ 7.00
GPT-5.6 LunaU$ 0.0013U$ 13.00
Nemotron 3 UltraU$ 0.0024U$ 24.50
Gemini 2.5 FlashU$ 0.0027U$ 26.50
GLM-5.2U$ 0.0051U$ 51.00
Claude Haiku 4.5U$ 0.0055U$ 55.00
Gemini 2.5 ProU$ 0.0106U$ 106.25
GPT-5.6 TerraU$ 0.0130U$ 130
Claude Sonnet 5U$ 0.0165U$ 165
Kimi K3U$ 0.0165U$ 165
Claude Opus 4.8U$ 0.0275U$ 275
GPT-5.6 SolU$ 0.0325U$ 325

How OpenAI API pricing works

OpenAI charges separately for input and output tokens, and the rate depends on which model you use. Input tokens are what you send to the API — your prompt, system instructions, and any context you provide — while output tokens are what the model generates in response, and are typically priced higher because generating text costs more compute than reading it. This calculator multiplies your average input and output tokens per request by OpenAI's per-model rates, then multiplies by your expected requests per month to estimate total spend. OpenAI also offers a cheaper cached-input rate for repeated prompt prefixes and a batch discount for asynchronous workloads — neither is applied here, so your real bill may end up lower if you use those features.

What a real workload costs on the OpenAI API

The fastest way to understand OpenAI pricing is to run a concrete scenario. Take a customer-support chatbot handling 10,000 conversations a month, with about eight exchanges per conversation. Each request carries roughly 1,500 input tokens — the system prompt plus the running conversation history — and produces around 200 output tokens. That adds up to 80,000 requests, or about 120 million input and 16 million output tokens per month.

On GPT-5.6 Luna, at the rates shown in the calculator above, that workload lands in the low hundreds of dollars per month. Run the exact same traffic through the flagship Sol tier and the bill roughly quintuples, well past a thousand dollars. Nothing about the product changed — only the model did. Model choice, not traffic volume, is usually the single biggest lever on an OpenAI invoice.

Document pipelines behave differently: summarization jobs are input-heavy — long documents in, short summaries out — so they favor models with cheap input rates and benefit disproportionately from batch discounts. For the full scenario math on chat workloads, see how much a chatbot really costs to run; if you're weighing the API against a ChatGPT Plus seat, the breakeven is worked out in API vs subscription.

Billing gotchas that quietly inflate your invoice

Chat applications resend the entire conversation history with every turn, so input usage grows with the square of conversation length: turn ten costs far more than turn two, even though the user typed a similar message. Long system prompts compound the same way — a 700-token system prompt is billed on every single request, which across a million requests means 700 million input tokens spent before any user text is even processed.

Verbose outputs are the other silent cost: models default to polite preambles and richly formatted JSON unless you instruct otherwise, and every one of those tokens is billed at the higher output rate. On the flip side, OpenAI discounts cached input for repeated prompt prefixes and charges roughly half price through the Batch API for jobs that can wait — leaving those unused is a real loss.

How to cut the bill without changing your product

Most teams over-buy intelligence. A practical pattern is model routing: send easy, high-volume requests to a small model and escalate only ambiguous cases to a larger one. Combine that with three habits — trim the system prompt to what the model actually needs, cap or summarize conversation history after a few turns, and set explicit limits on response length.

Before committing, measure instead of guessing: paste a representative prompt into the token calculator to see what it really costs across models, and use the GPT vs Claude comparison to check whether an equivalent Anthropic model prices better for your input/output mix.

How the OpenAI tiers price against the rest of the market

List prices only mean something next to the alternatives, so here is the August 2026 table the calculator uses, per million tokens (input / output). OpenAI runs three tiers on the same 1.05M-token context: GPT-5.6 Sol at $5.00 / $30.00, Terra at $2.00 / $12.00 and Luna at $0.20 / $1.20. Terra and Luna were repriced on 30 July 2026 — Luna by 80% and Terra by 20% — so any quote you took in July is now too high. Anthropic's line-up sits close to Sol on input and cheaper on output — Claude Opus 4.8 $5.00 / $25.00, Sonnet 5 $3.00 / $15.00 and Haiku 4.5 $1.00 / $5.00 — but with a 200k window instead of a million.

That repricing moved Luna into territory that used to belong to the open-weight models. Gemini 2.5 Flash costs $0.30 / $2.50, Nemotron 3 Ultra $0.50 / $2.20, and Llama 4 Maverick $0.20 / $0.60 — Maverick is still the floor, but Luna now undercuts Flash and Nemotron on both sides of the meter while carrying a frontier-family name. Against Sol, Luna is 25× cheaper on output for the same context window. Whether the capability trade is worth it depends entirely on the task; the honest way to find out is to price the same workload on both and then run your own evaluation. Our GPT vs Claude comparison does the head-to-head, and the cheapest LLM API guide covers the budget end.

Frequently asked questions

Why are output tokens more expensive than input tokens?

Generating a token requires a full forward pass through the model for every token produced, while reading input can be processed more efficiently. That extra compute cost is passed on in OpenAI's pricing, where output tokens are usually priced several times higher than input tokens.

Does this include free trial credits?

No. This calculator assumes standard pay-as-you-go pricing. If you're using free trial credits, your actual bill will be lower until those credits run out.

How accurate is the estimate?

We use published per-model pricing pulled from OpenRouter's live pricing feed, with a hardcoded fallback. Actual token counts depend on your specific prompt, so treat this as a planning estimate rather than an exact invoice prediction.

Which OpenAI model should a cost-sensitive chatbot start with?

Start with GPT-5.6 Luna and escalate only when quality measurably falls short. For most support and FAQ-style traffic, small models answer the majority of requests well, and routing the hard 10% to GPT-5.6 Terra keeps quality without paying the large-model rate on every message.

Do I pay for failed or abandoned requests?

Requests that reach the model and generate tokens are billed, even if your application discards the answer or the user closes the tab mid-stream. Client-side retries can silently double usage, so make retry logic idempotent and log token usage per request to catch surprises early.

Are these the live OpenAI prices or a stored table?

The calculator tries a live rate first: a cached route queries OpenRouter's catalogue and falls back to our own verified table if the request fails or a model is missing. The fallback figures were checked against OpenAI's published pricing page in July 2026. Either way, treat the result as an estimate and confirm the current rate on the provider's own pricing page before committing a budget.

Do the three GPT-5.6 tiers charge the same for the context window?

They share the same 1.05M-token window, but you pay for the tokens you actually send, not for the window size. A 1M-token prompt costs $5.00 on Sol and $0.20 on Luna at August 2026 list prices — a 25× gap on identical input. What changes between tiers is capability, not the ceiling, so a long-context job that a cheaper tier handles well is one of the easiest savings available.

Why is my real invoice higher than the estimate here?

The usual culprits are retries, system prompts resent on every call, conversation history that grows with each turn, and reasoning tokens billed as output on models that produce them. This calculator prices one call with the token counts you enter, so multiply by your real call volume and add a margin for retries. The billing-gotchas section above walks through each of these.

Curious where these numbers come from? Read our pricing methodology.