OpenAI API pricing: what a request costs, not what a token costs

OpenAI's API charges these prices per million tokens: GPT-6.1 Sol $2 for input and $10 for output, GPT-6 Luna $0.10 and $0.50, and GPT-6 Astra $10 and $50. Cached input costs a tenth of the input price (a twentieth on 6.1 Sol), Batch and Flex cut everything in half, and any request over 272K input tokens is billed at long-context rates.

OpenAI API pricing, as of October 2026

Batch (results within 24 hours) and Flex (slower, and sometimes turned away when OpenAI is busy) cost half. Fast mode costs double. If you're still on gpt-5.6-sol, its promotional rate is only promised through November 21, and 6.1 Sol already costs half as much. The same price list seems to set how fast Codex drains a ChatGPT plan, though Fast mode counts 2.5 times there instead of double. I looked at that in Codex usage limits.

Those price rows tell you less than they used to. Sol's is identical to Claude Sonnet 5.5's, and Luna's to Claude Haiku 5.5's, down to the cache prices. What sets your bill is how many tokens each request burns, and four things decide that: hidden reasoning, a cache-write fee that's on by default, the 272K line and the tokenizer. I ran the same requests through all three models at three effort levels to see how much hidden reasoning moves the number.

Hidden reasoning is billed as output, and effort decides how much

Sol and Astra always think before they answer, and Luna does too unless you set its effort to none. That thinking is text the model writes and then hides: the API tells you how many tokens it was and never shows the words, but bills each one at the output rate. The reasoning effort setting, which defaults to medium, controls how much room it gets.

I sent four requests to each model at each effort level: rewrite a stiff customer email, pull the final order out of a five-message email thread, write a small duration parser that has to pass 20 tests, and solve a counting puzzle. At high effort, about three quarters of the output tokens were thinking. Going from low to high raised the cost of an answer by about 2 to 2.5 times on every model.

Astra gave the same answers as Sol on all four and cost about five times as much per answer at every effort level. That's just the price ratio showing through, since it thought about as much as Sol did. I only tested single requests, so long agent runs are untested, but for ordinary API calls I'd treat Astra as Sol with a 5x surcharge.

Luna's sticker misleads. Its tokens cost a twentieth of Sol's, but it thought about twice as long on the same requests, so per answer it came out 12 to 14 times cheaper than Sol instead of 20. In one run each, it also got the counting puzzle wrong at low and medium effort, where Sol was right at every setting.

The saving can shrink further on harder problems. On a tougher counting puzzle, one run per model, Luna was about four times cheaper than Sol at low effort and about twice as cheap at medium. At high effort it thought for 12,762 tokens to Sol's 382 and cost slightly more for the same answer. A scheduling puzzle I tried didn't do that, and Luna stayed at least four times cheaper at every effort level, so read this as how it can go wrong rather than what usually happens.

So Luna is the right call when the job needs little thought, like extraction or short rewrites at low effort, where it got both right at more than ten times less per answer than Sol. Turn the effort up on a hard problem and the saving can disappear.

Caching is on by default, and a prompt you send once costs 25% more

OpenAI caches prompts without being asked. Each request over 1,024 tokens stores its prompt for at least 30 minutes, and a later request that starts with the same tokens reads them at a tenth of the input price, or a twentieth on 6.1 Sol. The catch, new since GPT-5.6, is the write: storing the prompt is billed at 1.25 times the normal input price.

For anything you repeat, that trade is excellent. A 16,800-token prompt, a long changelog plus one question, cost $42.33 per 1,000 calls on Sol the first time. At list prices a repeat costs about $2 per 1,000. A prompt you send exactly once, like a batch of different documents, pays 25% over list for a cache nobody reads.

Which fix you want depends on whether the prompt repeats. If it does, put whatever doesn't change, like the instructions and the document, at the front and the question last, because only an identical prefix gets the discount. If it never repeats, switch the request to explicit caching and leave out the breakpoints; with nothing marked, nothing gets written.

Past 272K input tokens, the whole request costs more

OpenAI's long-context rate applies to the entire request. Once a request carries more than 272K input tokens, every token in it is billed at the higher rate, double for input and 1.5 times for output, including the first 272K. On Sol, a 270K-token prompt costs about 54 cents to send at the plain input rate, and a 273K one costs about $1.09.

This is where the matching price rows stop matching. Claude Sonnet 5.5 bills a 900K-token request at the same rate as a 9K one, while Haiku 5.5 charges five times as much once a prompt passes 100K.

Agents hit this hardest, because their context grows every turn and each turn sends all of it again. Compact or trim the context before it crosses 272K.

The same text is a different number of tokens at each lab

A price per token only means something next to a tokenizer, the part that chops text into tokens. Every lab has its own, so the same text comes out as a different count.

On English the others land within a token of OpenAI's, and OpenAI's is the leanest on code and JSON. All of them beat it on Chinese. Hindi shows the biggest spread: DeepSeek needs 246 tokens for a paragraph OpenAI fits in 133, so a lower price per token can still cost more if your users don't write in English.

Claude is the one that differs even on English. Sonnet 5.5 shares Sol's price row, but over a full page of English its tokenizer produced about 1.4 times as many tokens as OpenAI's, which we measured in our post on how LLMs work. On the input side, identical rates mean a bill about 40% higher for the same text, and no price list shows it.

Price a request by running it

I'd default to Sol at low or medium effort and raise it only after you've watched medium get something wrong. Use Luna at low effort for high-volume, simple jobs, and be careful with it on hard reasoning, where its thinking can eat the saving. Reach for Astra only when Sol fails.

Our token price calculator counts a prompt and prices it across models, which covers the input side of an estimate. For the rest, send ten real requests and read the usage object. The reasoning and cache counts are all in there, and they explain most of the distance between the price page and the invoice.