We use cookies for analytics and personalized ads. We use cookies for basic analytics and, where we show ads, to personalize them. Privacy PolicyRead our Privacy Policy.
Compare the GPT-5.6 family, estimate one request or a full month of traffic, and see exactly which part of a prompt reaches your bill.
In short: pick a model, run the free calculator below to price your requests, then use the usage guide and routing tips further down to keep that estimate accurate as your traffic grows.
Count Tokens LocallySol is for your hardest reasoning and coding work. Terra is the balanced, everyday default. Luna is the budget option for simple, repeatable jobs at volume. Run the same test set against all three before picking one — the cheapest model on paper is only a good deal if it still gets the job done reliably.
Same large context window, three very different budgets.
Balanced production default
1.05M / 128K context / output
Hard reasoning & coding
1.05M / 128K context / output
Newest flagship, rolling out
1.05M / 128K context / output
Enter a request pattern, or start from an example workload below.
This OpenAI token calculator doubles as a GPT token cost calculator and monthly API cost estimator — switch currencies, share a saved estimate, or let the recommendation engine suggest a model based on your numbers.
Prices convert live in your chosen currency (approximate FX). The share button copies a link that reopens this exact estimate for anyone you send it to.
Using Terra as a baseline for this request pattern: switching simple, repeatable requests to Luna would cut this workload's monthly cost by about 90% — worth testing if your task doesn't need Terra's extra reasoning. Escalating to Sol instead would add roughly 79% to the bill — only worth it if Terra's answers are genuinely falling short on quality.
| Model | Context | Input | Cache | Output | Per request | Per month |
|---|---|---|---|---|---|---|
| GPT-5.5 Pro | 1.05M / 128K | $30.00 | — | $180.00 | $0.0990 | $1,485 |
| GPT-5.4 Pro | 1.05M / 128K | $30.00 | — | $180.00 | $0.0990 | $1,485 |
| GPT-5 Pro | 1.05M / 128K | $15.00 | — | $120.00 | $0.0600 | $900.00 |
| GPT-5.6 Cyber | 1.05M / 128K | $12.50 | $1.250 | $75.00 | $0.0420 | $630.00 |
| GPT-6 Astra | 1.05M / 128K | $10.00 | $1.000 | $50.00 | $0.0301 | $451.50 |
| GPT-5.5 | 1.05M / 128K | $5.00 | $0.500 | $30.00 | $0.0168 | $252.00 |
| GPT-5.6 Sol | 1.05M / 128K | $4.00 | $0.400 | $20.00 | $0.0120 | $180.60 |
| GPT-5.4 | 1.05M / 128K | $2.50 | $0.250 | $15.00 | $0.0084 | $126.00 |
| GPT-5.6 Terra | 1.05M / 128K | $2.00 | $0.200 | $12.00 | $0.0067 | $100.80 |
| GPT-5-Codex | 1.05M / 128K | $1.25 | $0.130 | $10.00 | $0.0051 | $76.17 |
| GPT-5.4 Mini | 400K / 128K | $0.75 | $0.075 | $4.50 | $0.0025 | $37.80 |
| GPT-5.4 Nano | 400K / 128K | $0.20 | $0.020 | $1.25 | $0.0007 | $10.34 |
| GPT-5.6 Luna | 1.05M / 128K | $0.20 | $0.020 | $1.20 | $0.0007 | $10.08 |
A pricing table only tells you the rate per million tokens. It doesn't tell you what your app will cost this month, or which model still gets the job done once you switch to the cheaper one. That's the gap this tool closes — here's exactly when to reach for it and how to get a number you can actually trust.
Click Support reply, Coding review, or Document extraction above the calculator to load realistic token counts, then tweak them to match your actual prompt and response lengths.
A per-request cost that looks tiny can still add up to a real monthly bill once you multiply it by your expected volume — always check both figures before deciding a model is "cheap enough."
The panel above the table converts the Luna/Sol difference into a percentage of your Terra baseline, so you're comparing against your own workload instead of a generic example.
The "Share this estimate" button encodes your exact inputs into a link. Send it to a teammate, a client, or your future self — it reopens with the same numbers already filled in.
A pre-launch estimate is a forecast. Once your feature is live, pull real numbers from the API response (see below) and plug those back into the calculator to correct your monthly projection.
This calculator is a planning tool — the number that actually determines your bill is the usage object OpenAI returns with every API response. Once your feature is live, pull that field and compare it to what you assumed here.
# one-time setup
pip install openai python-dotenv
# in your app
from openai import OpenAI
client = OpenAI() # reads OPENAI_API_KEY from your environment
response = client.chat.completions.create(
model="your-model-name",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.usage)
# -> prompt_tokens, cached_tokens, completion_tokens, total_tokensFeed those real prompt_tokens, cached_tokens, and completion_tokens figures back into the input, cached, and output fields above — that turns this from a rough forecast into an estimate grounded in your own traffic.
This is the single most common mix-up people searching for "Codex pricing" run into, because OpenAI sells Codex access two different ways:
If you're a developer wiring Codex into your own coding agent or CI pipeline, use the calculator above. If you're an individual using the Codex CLI or IDE extension under a personal ChatGPT plan, check your subscription's usage limits instead — the current plan tiers and included usage are listed on OpenAI's official pricing page linked at the bottom of this guide.
Running these models through Azure OpenAI instead of OpenAI's own API? Rates are set separately by Microsoft and don't always match the numbers above — treat this calculator as your OpenAI-direct baseline, then confirm the Azure rate for your region and deployment before budgeting an Azure-hosted rollout.
Most people estimate cost by looking at the message they typed. That's usually the smallest piece of what actually gets billed. An API request is built up in layers, mostly invisible to the person using the app, and every layer costs something. Understanding those layers — not just the pricing table — is what actually lets you predict a bill before it arrives.
Any new text the model hasn't seen cached — the user's message, freshly retrieved documents, or anything that changes request to request.
The trap: people estimate cost from the user's visible message and forget everything the app quietly attaches behind the scenes.
A stable prefix — like a long system prompt or few-shot examples — that stays identical across requests can qualify for a cheaper cached rate.
The trap: caching needs an exact, unchanged prefix. Adding a timestamp or a small variable at the start of your system prompt can silently break the match and put you back on full-price input.
What the model writes back. This is usually priced higher than input, so a longer or less-constrained response costs more than a longer prompt would.
The trap: output is the most expensive token type per unit, but it's also the easiest to control — a tighter format instruction often saves more money than trimming the prompt.
Some models switch to a higher rate once a request crosses a long-context threshold (often measured in the hundreds of thousands of tokens). Separately, features like tool calls, web search, image or audio input, and cache writes are billed on top of plain text and aren't included in a simple text estimate.
The trap: a text-only calculator (including this one) won't show these charges. Treat it as your floor, not your ceiling, once tools or large attachments are involved.
Say you're running a customer-support chatbot. A user types: "Can I get a refund on order #4471?" — eleven words. Here's everything that actually goes into the request the model receives:
The eleven-word question is almost free on its own. The system prompt, conversation history, and retrieved policy text are what actually determine the bill — and they're invisible to the user and easy for a developer to forget when estimating cost from "how long is the prompt."
Beyond the general-purpose Sol / Terra / Luna lineup, a few purpose-built variants fit specific jobs.
Regular chat models answer one question at a time. Codex is tuned for the opposite: it's meant to sit inside a coding agent (think Cursor or a CI pipeline) that reads your repository, plans a multi-file change, runs commands, checks the output, and fixes its own mistakes — all in one continuous session.
This is the model OpenAI points to when a task genuinely needs the most careful, thorough reasoning available — the kind of problem where a wrong answer is expensive and a slower, more expensive model is worth it.
A variant aimed at teams in security, compliance, or other regulated environments where the model needs to run under stricter data-handling and audit requirements than the standard consumer-facing models.
How to actually decide which model handles which request.
Build a small set of real examples from your own use case and see how it performs — this becomes your quality baseline.
Re-run the simple, repeatable requests (classification, short extraction) on Luna. If the results hold up, route those there permanently.
Only send the requests that genuinely need deeper reasoning to Sol — not everything, just the cases where Terra's answers fall short.
Your forecast should include system instructions, retrieved context, and expected output length — not only the text box the user sees.