How much does the OpenAI API cost? In October 2026, GPT-6 Astra is $10 per million input tokens and $50 per million output tokens, GPT-6 Sol is $2 and $10, and GPT-6 Luna is $0.10 and $0.50, at the standard tier for requests up to 272K input tokens1. Everything else on the rate card modifies those numbers: cached input costs less to read, cache writes cost a little more, long requests cost more, Batch and Flex cost half, and Fast mode costs double.
This guide explains each column, then works through three requests so you can see which ones matter for your workload.
The flagship text models
OpenAI's pricing page lists these standard rates per million tokens for short-context requests1:
| Model | Input | Cached input | Output |
|---|---|---|---|
| GPT-6 Astra | $10.00 | $1.00 | $50.00 |
| GPT-6.1 Sol | $2.00 | $0.10 | $10.00 |
| GPT-6 Sol | $2.00 | $0.20 | $10.00 |
| GPT-6 Luna | $0.10 | $0.01 | $0.50 |
| 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 |
Two things stand out. GPT-6.1 Sol has the same input and output rates as GPT-6 Sol with half the cached-input rate, so a cache-heavy workload on 6 Sol has a reason to move. And the older GPT-5.6 Sol costs twice what GPT-6 Sol does; an application still pinned to it is paying for the pin. Our tier guide covers which tier suits which task.
How a request is billed
Every text request has three meters, each with its own rate:
- Input tokens. Everything you send: system prompt, conversation history, tool definitions, retrieved documents and images. The token counting guide (opens in a new tab) notes that the count also includes formatting tokens for message roles and boundaries, which you will not see if you count your text locally2.
- Cached input tokens. The part of the input that matched a cached prefix. Caching is on by default for supported models, the minimum cacheable prompt is 1,024 tokens for GPT-5.6 and later, and the matched count is reported in
input_tokens_details.cached_tokens3. - Output tokens. Everything the model generates, including reasoning tokens. OpenAI states that reasoning tokens are not visible through the API but occupy context and are billed as output; their count is in
output_tokens_details.reasoning_tokens4.
The third point surprises teams moving from non-reasoning models. A short visible answer can carry thousands of reasoning tokens, and if max_output_tokens is reached during reasoning, the response ends incomplete and you pay for input and reasoning with no visible answer at all4. OpenAI suggests reserving at least 25,000 tokens for reasoning and output when you start, then tuning down. Reasoning tokens: the hidden cost of thinking models covers effort settings in depth.
Cache writes are a cost on new models
For GPT-5.6 and later, OpenAI's caching guide says a cache write costs 1.25 times the standard input rate; GPT-5.5 and earlier have no separate cache-write charge3. The pricing page lists GPT-6 Astra's cache-write rate at $12.50 per million tokens1. So a prefix that is written and never read again costs 25% more than sending it uncached. Caching pays when a long prefix (a system prompt, a tool list, a document) is reused within the retention window. Prompt caching across providers has the break-even arithmetic.
The modifiers
| Modifier | Effect on the rate | When it applies |
|---|---|---|
| Long context | Higher input and output rates for the whole request | More than 272K input tokens |
| Batch | Half the standard rate | Asynchronous jobs submitted through the Batch API |
| Flex | Half the standard rate | Requests sent with Flex processing |
| Fast mode | Double the standard rate | Requests sent with Fast mode (renamed from Priority on 2026-07-30) |
| Regional processing | 10% uplift | Data residency and FedRAMP endpoints |
Long context is per request, not per token. OpenAI defines short context as up to 272K input tokens and long context as above it1. GPT-6 Astra's long-context rates are $20 input and $75 output, GPT-6 Sol's are $4 and $15, GPT-6 Luna's $0.20 and $0.75. A request at 273K tokens pays the higher rate on all of its tokens, which is why a retrieval step that occasionally over-fills the context shows up as a step in cost per request rather than a gentle slope.
Batch and Flex trade latency for half the rate. For example, GPT-6 Astra on Batch is $5 input and $25 output, and GPT-5.6 Terra is $1 and $61. Any job that a person is not waiting on — nightly classification, evaluation runs, backfills, embeddings of a corpus — belongs on one of them. Batch or synchronous has a sorting method.
Fast mode doubles the rate. OpenAI notes that Priority processing was renamed Fast mode on 30 July 2026; GPT-6 Sol in Fast mode is $4 input and $20 output1. Use it where latency is the product, and measure whether it is.
Everything that is not a chat token
- Built-in tools. Web search is $10 per 1,000 calls plus the search content tokens at the model's rates. File search calls are $2.50 per 1,000 and storage $0.10 per GB per day after 1 GB free. Hosted shell and code interpreter containers are billed per container session, from $0.03 for 1 GB1.
- Images. GPT Image models are priced per token: GPT Image 2 is $8 per million image input tokens and $30 per million image output tokens, with $5 per million text input tokens1. The image guide's calculator converts that into a per-image figure by quality and size.
- Embeddings. text-embedding-3-small is $0.02 per million tokens and text-embedding-3-large $0.131.
- Audio. The realtime models bill audio and text tokens separately (gpt-realtime-2 audio is $32 input and $64 output per million), tts-1 is $15 per million characters, and transcription runs from $0.0045 a minute on gpt-transcribe1.
A cost view that only multiplies chat tokens will show these requests as zero. If your product generates images or audio, record the unit and quantity of each request beside its token counts.
Three requests, worked through
How to estimate before you send
To predict a request's cost, count its input first. OpenAI's POST /v1/responses/input_tokens endpoint takes the same payload as a Responses request and returns the input token count, including images, files, tools and formatting tokens that a local tokenizer misses2. Multiply by the input rate, add a worst case for output (your max_output_tokens times the output rate), and you have an upper bound. Count tokens before you call the API compares the counting methods of OpenAI, Anthropic and Google.
Three mistakes account for most estimates that miss:
- Ignoring reasoning. The visible answer is a small part of the output on reasoning models.
- Treating cached tokens as free. They cost less, not nothing, and on new models the first write costs more.
- Forgetting the threshold. A request that crosses 272K input tokens is re-priced as a whole.
Pricing every request with INFRO
INFRO does not sell OpenAI usage; you connect your own OpenAI account and OpenAI bills you at your own rates. What INFRO adds is the arithmetic above on every request: each response carries an estimated provider cost at the vendor's list rate or, from the Team plan, your negotiated rate; POST /v1/estimates prices a request before you send it; and budgets per organization, project, member and key refuse a request that would exceed them before OpenAI is called. A model with no known rate is marked unpriced, never $0.
Summary
Read OpenAI's rate card as one base rate and a set of modifiers. Pick the tier by task, keep long prefixes cached only where they are reused, keep requests under 272K input tokens where you can, move anything nobody waits for to Batch or Flex, and reserve Fast mode for the paths where speed is measurably worth twice the price.