# OpenAI API pricing in 2026: GPT-6 tiers, Batch, Flex and Fast

URL: https://infro.io/blog/openai-api-pricing-2026
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-10-20
Last modified: 2026-10-20
Last reviewed: 2026-10-20 (next review due 2026-11-19)
Topic: Cost and FinOps
Format: Guide

> OpenAI bills text models per million tokens in three parts: input, cached input and output, with reasoning tokens billed as output. In October 2026 GPT-6 Astra lists at $10 input and $50 output, GPT-6 Sol and 6.1 Sol at $2 and $10, and GPT-6 Luna at $0.10 and $0.50. Requests above 272K input tokens pay the long-context rates, Batch and Flex are half the standard rate, Fast mode is double, and regional processing endpoints add 10%.

Key takeaways:
- Every OpenAI text request is input, cached input and output tokens, each at its own rate; reasoning tokens are billed as output even though you never see them.
- GPT-6 Astra is $10 in and $50 out per 1M tokens, Sol $2 and $10, Luna $0.10 and $0.50, at the standard tier and short context.
- A request above 272K input tokens pays the long-context rate on the whole request, not just the tokens past the line.
- Batch and Flex run at half the standard rate; Fast mode costs double; regional processing endpoints add 10%.
- For GPT-5.6 and later, cache writes cost 1.25x the input rate, so caching pays only when a prefix is read again.

**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 tokens[1]. 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 requests[1]:

| 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 |

Table: Standard tier, requests up to 272K input tokens, per 1M tokens, from OpenAI's pricing page on 2026-10-20.

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](https://infro.io/blog/gpt-6-astra-sol-luna-tiers) covers which tier suits which task.

## How a request is billed

Every text request has three meters, each with its own rate:

1. **Input tokens.** Everything you send: system prompt, conversation history, tool definitions, retrieved documents and images. The [token counting guide](https://developers.openai.com/api/docs/guides/token-counting) notes that the count also includes formatting tokens for message roles and boundaries, which you will not see if you count your text locally[2].
2. **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_tokens`[3].
3. **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_tokens`[4].

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 all[4]. 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](https://infro.io/blog/reasoning-tokens-cost) 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 charge[3]. The pricing page lists GPT-6 Astra's cache-write rate at $12.50 per million tokens[1]. 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](https://infro.io/blog/prompt-caching-break-even) 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 |

Table: Rate modifiers listed on OpenAI's pricing page on 2026-10-20.

**Long context is per request, not per token.** OpenAI defines short context as up to 272K input tokens and long context as above it[1]. 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 $6[1]. 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](https://infro.io/blog/batch-vs-synchronous-llm) 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 output[1]. 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 GB[1].
- **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 tokens[1]. 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.13[1].
- **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-transcribe[1].

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

> **Example: Support assistant on GPT-6 Sol**
> Each request sends a 1,500-token system prompt that is already cached, 500 tokens of new conversation, and receives 300 output tokens.
> 
> - Fresh input: 500 × $2.00 / 1M = $0.0010
> - Cached input: 1,500 × $0.20 / 1M = $0.0003
> - Output: 300 × $10.00 / 1M = $0.0030
> - **Total: about $0.0043 per request, or about $4,300 per million requests**
> 
> Output is 70% of the cost. Shorter answers move the bill more than a shorter prompt would.

> **Example: Nightly document classification on GPT-6 Luna**
> 10,000 documents a night, each 3,000 input tokens, each answered with a 50-token label.
> 
> - Standard: 30M input × $0.10 = $3.00, plus 0.5M output × $0.50 = $0.25, so $3.25 a night
> - On Batch at half the rate: about $1.63 a night
> 
> Nobody is waiting for the labels, so the Batch API is the right home.

> **Example: One long-context analysis on GPT-6 Astra**
> One request with 300,000 input tokens and 4,000 output tokens.
> 
> - Long-context rates apply: 0.3M × $20 = $6.00, plus 0.004M × $75 = $0.30, so $6.30
> - The same request trimmed to 270,000 input tokens stays on short-context rates: 0.27M × $10 = $2.70, plus 0.004M × $50 = $0.20, so $2.90
> 
> Cutting 10% of the input more than halves the cost, because the request drops under the 272K line.

## 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 misses[2]. 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](https://infro.io/blog/count-tokens-before-api-call) 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.

## Questions

### How much does GPT-6 cost per request?

It depends on the tokens. At standard rates a GPT-6 Sol request with 500 new input tokens, 1,500 cached input tokens and 300 output tokens costs about $0.0043: $0.001 for input, $0.0003 for cached input and $0.003 for output. The same shape on GPT-6 Astra costs about five times as much.

### Is the OpenAI Batch API half price?

Yes for the text models on OpenAI's pricing page in October 2026: Batch input, cached input and output are listed at half the standard rate. Flex processing is listed at the same half rate. Batch returns results within a completion window rather than immediately.

### Are reasoning tokens charged?

Yes. OpenAI bills reasoning tokens as output tokens. They are not returned in the response text, but their count appears in the usage object under output_tokens_details.reasoning_tokens.

### Does OpenAI charge for cache writes?

For GPT-5.6 and later models, OpenAI's prompt caching guide says cache writes cost 1.25 times the standard input rate. GPT-5.5 and earlier have no separate cache-write charge.

## Sources

1. Pricing — OpenAI. https://developers.openai.com/api/docs/pricing (accessed 2026-10-20)
2. Counting tokens — OpenAI. https://developers.openai.com/api/docs/guides/token-counting (accessed 2026-10-20)
3. Prompt caching — OpenAI. https://developers.openai.com/api/docs/guides/prompt-caching (accessed 2026-10-20)
4. Reasoning models — OpenAI. https://developers.openai.com/api/docs/guides/reasoning (accessed 2026-10-20)