OpenAI token pricing runs from $0.10 / $0.50 per million input / output tokens on gpt-6-luna to $10 / $50 on gpt-6-astra, with gpt-6.1-terra at $1 / $5 and gpt-6.1-sol at $2 / $10. Cached input costs 5% or 10% of the input price, the Batch API and Flex halve every rate, Fast mode (called Priority until 30 July 2026) doubles it, and reasoning tokens are billed as output.
Below are every model's rates in one table, the price per token and per 1,000 tokens, how cache writes, long prompts and reasoning change a bill, and Python code that counts tokens with tiktoken and prices a real response. All figures are OpenAI's list prices in US dollars from its pricing page, checked on 5 November 2026.
OpenAI token pricing for every current model
Prices per 1M tokens, for prompts up to 272,000 input tokens. "Cache write" is the default 30-minute write. Batch and Flex share one price list on these models.
| Model | Input | Cached input | Cache write | Output | Batch or Flex, in / out | Fast (Priority), in / out |
|---|---|---|---|---|---|---|
| gpt-6-astra | $10.00 | $1.00 | $12.50 | $50.00 | $5.00 / $25.00 | $20.00 / $100.00 |
| gpt-6.1-sol | $2.00 | $0.10 | $2.50 | $10.00 | $1.00 / $5.00 | $4.00 / $20.00 |
| gpt-6-sol | $2.00 | $0.20 | $2.50 | $10.00 | $1.00 / $5.00 | $4.00 / $20.00 |
| gpt-6.1-terra | $1.00 | $0.05 | $1.25 | $5.00 | $0.50 / $2.50 | $2.00 / $10.00 |
| gpt-6-luna | $0.10 | $0.01 | $0.125 | $0.50 | $0.05 / $0.25 | $0.20 / $1.00 |
| gpt-5.6-sol | $4.00 | $0.40 | $5.00 | $20.00 | $2.00 / $10.00 | $8.00 / $40.00 |
| gpt-5.6-terra | $2.00 | $0.20 | $2.50 | $12.00 | $1.00 / $6.00 | $4.00 / $24.00 |
| gpt-5.6-luna | $0.20 | $0.02 | $0.25 | $1.20 | $0.10 / $0.60 | $0.40 / $2.40 |
| chat-latest | $5.00 | $0.50 | None | $30.00 | Not offered | Not offered |
- Batch, Flex and Fast multiply the cached and cache-write rates too: a gpt-6-luna cache hit in Batch costs $0.005.
- A prompt over 272,000 input tokens is billed at 2x input and cache rates and 1.5x output, for the whole request.
- Ultrafast mode, on gpt-6-astra and gpt-6.1-sol only, costs 6x Standard: $60 / $300 and $12 / $60.
- Regional processing (data residency) adds 10% for models released on or after 5 March 2026.
- gpt-5.6-sol's $4 / $20 is a promotion the pricing page says runs until 30 November 2026. The August changelog described it as 20% off input and 33% off output, which implies $5 / $30 afterward.
- Responses and Chat Completions "are not priced separately," per the pricing page.
All GPT-6 and GPT-5.6 models have a 1,050,000-token context window, a 922,000-token input limit and 128,000 output tokens, according to their model pages. chat-latest points at the model currently in ChatGPT, has a 272,000-token input limit, and can't run in Batch. For which model to start with and a first request, see the OpenAI API guide.

Older models still on the price list
These bill at older rates and, apart from gpt-5.5 and newer, have no cache-write charge. Prices per 1M tokens, Standard tier.
| Model | Input / cached / output | Batch, in / out | Flex | Fast, in / out | Shuts down |
|---|---|---|---|---|---|
| gpt-5.5 | $5.00 / $0.50 / $30.00 | $2.50 / $15.00 | Yes | $12.50 / $75.00 | Not announced |
| gpt-5.5-pro, gpt-5.4-pro | $30.00 / none / $180.00 | $15.00 / $90.00 | Yes | No | Not announced |
| gpt-5.4 | $2.50 / $0.25 / $15.00 | $1.25 / $7.50 | Yes | $5.00 / $30.00 | Not announced |
| gpt-5.4-mini | $0.75 / $0.075 / $4.50 | $0.375 / $2.25 | Yes | $1.50 / $9.00 | Not announced |
| gpt-5.4-nano | $0.20 / $0.02 / $1.25 | $0.10 / $0.625 | Yes | No | 1 Apr 2027 |
| gpt-5.3-codex | $1.75 / $0.175 / $14.00 | Not listed | No | $3.50 / $28.00 | 1 Apr 2027 |
| gpt-5.2 | $1.75 / $0.175 / $14.00 | $0.875 / $7.00 | Yes | $3.50 / $28.00 | Not announced |
| gpt-5.2-pro | $21.00 / none / $168.00 | $10.50 / $84.00 | No | No | Not announced |
| gpt-5.1 | $1.25 / $0.125 / $10.00 | $0.625 / $5.00 | Yes | $2.50 / $20.00 | 1 Apr 2027 |
| gpt-5 | $1.25 / $0.125 / $10.00 | $0.625 / $5.00 | Yes | $2.50 / $20.00 | 11 Dec 2026 |
| gpt-5-mini | $0.25 / $0.025 / $2.00 | $0.125 / $1.00 | Yes | $0.45 / $3.60 | 11 Dec 2026 |
| gpt-5-nano | $0.05 / $0.005 / $0.40 | $0.025 / $0.20 | Yes | No | 11 Dec 2026 |
| gpt-5-pro | $15.00 / none / $120.00 | $7.50 / $60.00 | No | No | 11 Dec 2026 |
| o3 | $2.00 / $0.50 / $8.00 | $1.00 / $4.00 | Yes | $3.50 / $14.00 | 11 Dec 2026 |
| o3-pro | $20.00 / none / $80.00 | $10.00 / $40.00 | No | No | 11 Dec 2026 |
| gpt-4.1 | $2.00 / $0.50 / $8.00 | $1.00 / $4.00 | No | $3.50 / $14.00 | 14 Jan 2027 |
| gpt-4.1-mini | $0.40 / $0.10 / $1.60 | $0.20 / $0.80 | No | $0.70 / $2.80 | 14 Jan 2027 |
| gpt-4o | $2.50 / $1.25 / $10.00 | $1.25 / $5.00 | No | $4.25 / $17.00 | 14 Jan 2027 |
| gpt-4o-mini | $0.15 / $0.075 / $0.60 | $0.075 / $0.30 | No | $0.25 / $1.00 | 14 Jan 2027 |
Dates are from the deprecations page. Fast mode on older models isn't a flat 2x: 2.5x on gpt-5.5, 1.67x to 2x on the rest. gpt-6-luna, the named replacement for the GPT-4 models, costs less per token than all four but reasons at medium effort by default, so check output tokens after switching.
What a token is
A token is a chunk of text the model reads or writes: a word, part of a word, a space plus a word, or punctuation. OpenAI's help article on tokens gives the English rules of thumb: about 4 characters per token, three-quarters of a word per token, 100 tokens for about 75 words.
Measured with tiktoken 0.14.0 and o200k_base, plain English matches: Pride and Prejudice is 1.34 tokens per word (170,260 tokens for 127,360 words), the US Constitution 1.30. Technical text runs higher because prices, IDs and code split into small pieces: 1.43 for OpenAI's prompt caching guide, 1.6 to 1.7 for pricing posts on this blog.
Language matters more. The same 83-word support reply came to 92 tokens in English and up to 60% more in other languages:
| Language | Tokens | vs English |
|---|---|---|
| English | 92 | 1.00x |
| Chinese | 105 | 1.14x |
| German | 112 | 1.22x |
| Spanish | 116 | 1.26x |
| French | 123 | 1.34x |
| Hindi | 138 | 1.50x |
| Japanese | 147 | 1.60x |

Tokenizers also differ between providers. An independent comparison on GitHub (token-count-compare) counted the same 31 files at 44,794 tokens on every GPT-5.5, GPT-5.6 and GPT-6 model and 68,940 on Claude Opus 5.5, 54% more. Compare prices per task, not per token, as the Claude API pricing guide does for Anthropic's side.
How to count tokens with tiktoken
tiktoken is OpenAI's open-source tokenizer library. Version 0.14.0 (17 August 2026) is current on PyPI, and it maps every GPT-5 and GPT-5.6 model to o200k_base, a vocabulary of about 200,000 tokens. It doesn't know the GPT-6 names: tiktoken.encoding_for_model("gpt-6-luna") raises KeyError, which issue #608 reported in September. OpenAI hasn't published GPT-6's encoding; a pull request mapping GPT-6 to o200k_base (#616) was still open on 5 November, and the token-count comparison above found GPT-6 counts identical to GPT-5's. So load the encoding by name and treat the result as an estimate:
pip install tiktoken==0.14.0 openai==3.45.0
import tiktoken
enc = tiktoken.get_encoding("o200k_base") # encoding_for_model("gpt-6-luna") raises KeyError
tokens = enc.encode("tiktoken is great!")
print(len(tokens), [enc.decode_single_token_bytes(t) for t in tokens])
# 6 [b't', b'ikt', b'oken', b' is', b' great', b'!']
A local count covers plain text only. Message roles, tool definitions, schemas, images and files add tokens tiktoken can't see. For the exact input count of a full request, send the same payload to the input token counting endpoint, which OpenAI's help center says is free and doesn't use your inference quota:
from openai import OpenAI
client = OpenAI() # reads OPENAI_API_KEY
count = client.responses.input_tokens.count(
model="gpt-6-luna",
instructions="You answer billing questions for Example Co.",
input="Why was I charged twice in October?",
)
print(count.input_tokens) # exact, including message formatting tokens
Neither count predicts output; read usage on real responses for that.
OpenAI cost per token and per 1,000 tokens
Divide the per-million price by 1,000,000 for one token, or by 1,000 for 1,000 tokens. The last column uses the plain-English rate above: a 1,000-word answer is about 1,340 output tokens, before any reasoning.
| Model | Input per token | Output per token | Input per 1,000 tokens | Output per 1,000 tokens | A 1,000-word answer |
|---|---|---|---|---|---|
| gpt-6-astra | $0.00001 | $0.00005 | $0.01 | $0.05 | $0.067 |
| chat-latest | $0.000005 | $0.00003 | $0.005 | $0.03 | $0.040 |
| gpt-5.6-sol | $0.000004 | $0.00002 | $0.004 | $0.02 | $0.027 |
| gpt-6.1-sol, gpt-6-sol | $0.000002 | $0.00001 | $0.002 | $0.01 | $0.013 |
| gpt-5.6-terra | $0.000002 | $0.000012 | $0.002 | $0.012 | $0.016 |
| gpt-6.1-terra | $0.000001 | $0.000005 | $0.001 | $0.005 | $0.0067 |
| gpt-5.6-luna | $0.0000002 | $0.0000012 | $0.0002 | $0.0012 | $0.0016 |
| gpt-6-luna | $0.0000001 | $0.0000005 | $0.0001 | $0.0005 | $0.00067 |
Images bill as input tokens: on gpt-6-astra at detail: high, a 1024×1024 image is 1,229 tokens, about $0.012 (vision guide).
ChatGPT cost per token
ChatGPT subscriptions aren't billed per token; the API is billed separately. The closest per-token price is chat-latest, the API model that points at the latest model in ChatGPT: $5 per million input tokens and $30 per million output, so $0.000005 per input token and $0.00003 per output token. A 1,000-word ChatGPT-style answer costs about $0.04 through it.
Three caveats. OpenAI's model page recommends GPT-6 models for production because the snapshot behind chat-latest changes. It has no Batch, Flex or Fast option. And the same answer from gpt-6.1-sol costs about a third as much per output token. Since 28 October 2026, ChatGPT Pro subscribers can claim monthly API usage of $100, $200 or $500 depending on tier, and Business workspaces $20 or $100 per paid seat up to $500; it expires at the end of each billing cycle.
How cached input and cache writes are priced
Every input token is billed at exactly one of three rates: uncached input, cache read or cache write. OpenAI's prompt caching guide says "Cache-write pricing is not an additive fee." On GPT-5.6 and later:
- A cache read costs 0.1x the input price, or 0.05x on gpt-6.1-sol and gpt-6.1-terra.
- A cache write costs 1.25x for the default 30-minute lifetime, or 2.5x for a 12-hour lifetime (Responses API only,
prompt_cache_options.ttl="12h", added 20 October). - Only prefixes of at least 1,024 tokens are cached.
- One write plus one full reuse costs 1.35x the plain input price against 2x without caching; ten requests cost 2.15x against 10x. A prefix written and never reused costs 25% more than no caching.
- A 12-hour write pays off from the second reuse.
Models before GPT-5.6 have no write charge, and their cache discount varies: 50% off on gpt-4o, 75% on gpt-4.1 and o3, 90% on the GPT-5 line.
The trap is the default implicit mode. It places the cache breakpoint at the end of the latest user message, so a single-turn app pays 1.25x on its whole prompt, including the part that changes on every request. Explicit mode with a breakpoint after the fixed instructions avoids that; the cheapest way to use the OpenAI API has the code and a monthly example. The usage block shows what happened: input_tokens_details.cached_tokens for reads, cache_write_tokens for writes, and cache_write_tokens_details split into ttl_30m_tokens and ttl_12h_tokens. In Chat Completions the same counts sit under prompt_tokens_details.
Prompts over 272,000 tokens
On GPT-5.4 and later, a request whose input exceeds 272,000 tokens moves entirely to the long-context rate: 2x input, cache reads and cache writes, and 1.5x output. Cached tokens count toward the 272,000.
| Prompt size (1,000 output tokens, no caching) | gpt-6-luna | gpt-6.1-sol | gpt-6-astra |
|---|---|---|---|
| 200,000 tokens | $0.0205 | $0.41 | $2.05 |
| 270,000 tokens | $0.0275 | $0.55 | $2.75 |
| 275,000 tokens | $0.0558 | $1.12 | $5.58 |
Five thousand tokens past the line roughly doubles the request, so trim history or split documents before they cross it.
How reasoning tokens are billed
Reasoning tokens are billed as output tokens at the model's output price, even though the API never returns their text. OpenAI's reasoning guide says they "occupy space in the model's context window and are billed as output tokens."
- They're already inside
usage.output_tokens(Responses) orcompletion_tokens(Chat Completions).output_tokens_details.reasoning_tokensshows how many; don't add them twice. - OpenAI's own usage example: 75 input tokens and 1,186 output tokens, of which 1,024 were reasoning. On gpt-6.1-sol that request costs $0.012, and 86% of it is thinking.
- Effort sets how many. gpt-6.1-sol, gpt-6-sol, gpt-6-luna, gpt-6.1-terra and the GPT-5.6 models default to
medium.noneworks on gpt-6-luna, gpt-6-sol, gpt-6.1-terra and GPT-5.6; gpt-6-astra and gpt-6.1-sol reject it with a 400, so uselow. reasoning.mode: "pro"bills at the normal token rates but does more work, so it uses more tokens.max_output_tokens(Responses) andmax_completion_tokens(Chat Completions) cap reasoning plus visible text. A response that hits the cap returnsstatus: "incomplete", possibly with no visible text, and you still pay for the input and reasoning. OpenAI suggests reserving at least 25,000 tokens while you experiment.- Output counts can exceed visible text even with zero reasoning, because of formatting tokens (token counting guide).
- On GPT-5.6 models,
reasoning.contextdefaults toall_turns, which renders earlier turns' reasoning into later requests (gpt-6.1-sol supports it too). And in aprevious_response_idchain, OpenAI's conversation state guide says all previous input tokens are billed as input on each turn.
OpenAI says gpt-6-astra reached stronger results with "substantially fewer output tokens" than earlier models, so measure reasoning tokens on your own tasks at two effort levels before comparing models by price.
Batch, Flex, Fast and Ultrafast
The service tier changes every token's price by a fixed multiple. The response's service_tier field shows which tier actually served the request.
| Tier | How to request it | Price vs Standard | Trade-off |
|---|---|---|---|
| Batch | Upload a JSONL file to the Batch API | 0.5x | Results inside a 24-hour window; up to 50,000 requests per batch |
| Flex | service_tier="flex" | 0.5x | Slower; 429 "Resource Unavailable" at busy times, not charged |
| Standard | Default | 1x | |
| Fast (was Priority) | service_tier="fast" or "priority" | 2x on GPT-5.6 and later | Up to 2.5x faster |
| Ultrafast | service_tier="ultrafast" | 6x | gpt-6-astra and gpt-6.1-sol, Responses API |
- Flex is in beta; on a 429, retry later or resend at Standard. An expired batch is charged for the requests it completed.
- Fast mode traffic that ramps too quickly can be served at standard speed and charged standard rates, with
service_tier: "default"in the response. Past 1M input tokens per minute, OpenAI suggests growing no more than 50% every 15 minutes. - If a project's service tier is set to Fast, every request that doesn't name a tier pays 2x. Since 21 October, admins can restrict which tiers a project may use.
Price a request in Python
The function below turns a Responses API usage block into dollars, with cache reads, both cache-write lifetimes, the 272,000-token rule and the service tier. It ran against OpenAI's documented examples on 5 November 2026; add the models you use to PRICES.
import tiktoken
# OpenAI list prices, US$ per 1M tokens, Standard tier, prompts up to 272K tokens (5 Nov 2026)
# model: (input, cached input, output)
PRICES = {
"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.1-terra": (1.00, 0.05, 5.00),
"gpt-6-luna": (0.10, 0.01, 0.50),
}
# multiplier by the service_tier the response reports (Fast shows as "priority")
TIER = {"default": 1.0, "flex": 0.5, "priority": 2.0, "fast": 2.0, "ultrafast": 6.0}
enc = tiktoken.get_encoding("o200k_base")
def estimate(model, prompt, output_tokens):
"""Rough US$ before sending: plain-text count, no caching, Standard tier."""
n = len(enc.encode(prompt))
p_in, _, p_out = PRICES[model]
return n, (n * p_in + output_tokens * p_out) / 1e6
def request_cost(model, usage, service_tier="default", batch=False):
"""Exact US$ for one Responses API call, from response.usage."""
p_in, p_cached, p_out = PRICES[model]
d = usage.input_tokens_details
w = d.cache_write_tokens_details # writes split by lifetime
w30 = w.ttl_30m_tokens if w else d.cache_write_tokens
w12 = w.ttl_12h_tokens if w else 0
plain = usage.input_tokens - d.cached_tokens - d.cache_write_tokens
long_in, long_out = (2.0, 1.5) if usage.input_tokens > 272_000 else (1.0, 1.0)
usd = (long_in * (plain * p_in + d.cached_tokens * p_cached
+ w30 * 1.25 * p_in + w12 * 2.5 * p_in)
+ long_out * usage.output_tokens * p_out) / 1e6 # output includes reasoning
return usd * (0.5 if batch else TIER.get(service_tier, 1.0))
Before a call, estimate; after it, price the real usage:
print(estimate("gpt-6.1-sol", "Summarize this support ticket in two sentences: " + "The invoice total is wrong. " * 40, 400))
# (251, 0.004502)
from openai import OpenAI
client = OpenAI()
r = client.responses.create(model="gpt-6.1-sol", input="...", reasoning={"effort": "low"},
max_output_tokens=8_000)
print(r.usage.output_tokens_details.reasoning_tokens, r.service_tier)
print(f"${request_cost('gpt-6.1-sol', r.usage, r.service_tier):.5f}")
Checked offline: OpenAI's reasoning example prices at $0.01201 on gpt-6.1-sol ($0.006 Flex, $0.02402 Fast), and the caching guide's mixed-lifetime example gives its stated $0.01515. To run the same arithmetic across many models without code, Aight's free token cost calculator prices one job on every model, and the LLM API cost per month guide works full monthly bills.
What developers report
- A month after GPT-5.6 introduced cache writes, OpenAI staff said overlapping cache-read and cache-write counts were "a bug with certain types of requests not getting accounted correctly," and that refunds would be calculated (OpenAI Developer Community, 10 Jul 2026, link)
- OpenAI Support, in the same thread, on whether writes are charged on top of input: "it isn't an extra fee added on top" (11 Oct 2026, link)
- Simon Willison, citing an independent count test, said it "strongly suggests that GPT-6 models use the same tokenizer as GPT-5" (tiktoken issue #608, 9 Oct 2026, link)
- "It's still insane that they stopped showing you all the tokens you pay for." (Hacker News commenter on hidden reasoning tokens, GPT-6.1 Sol thread, 29 Sep 2026, link)
- A Hacker News commenter reported Luna agents at
maxeffort filling their whole context windows with reasoning tokens before writing any code (GLM-5.3-Flash thread, 26 Aug 2026, before GPT-6 Luna shipped, link)
OpenAI token pricing through Aight
Aight lists gpt-6-luna, gpt-6-sol, gpt-6.1-sol, gpt-6-astra and the GPT-5.6 models at OpenAI's list prices, including cache reads, cache writes and the 272,000-token rates, behind one OpenAI-compatible key. A $100 recharge costs $103 with the 3% processing fee and adds $110 of balance with the 10% extra, so gpt-6-luna works out to about $0.094 / $0.47 per 1M tokens and gpt-6.1-sol to $1.87 / $9.36.
Where OpenAI direct is the better route:
- Batch and Flex halve the price; Aight's API reference documents chat completions, embeddings and the model list only, so neither is available, and 50% beats the extra's roughly 6%.
- chat-latest isn't on Aight's models page.
- The reference documents
model,messagesandstreamas request fields, so confirm thatcached_tokenscomes back before you count on cache prices.
Aight fits live traffic mixed with Claude or Gemini: one prepaid balance that doesn't expire, refundable unspent paid balance, and a monthly cap per key.
FAQ
How much does one OpenAI token cost?
From $0.0000001 per input token on gpt-6-luna to $0.00001 on gpt-6-astra, and five times that per output token on GPT-6 models. Cached input costs a tenth or a twentieth of the input price.
How many tokens is 1,000 words?
About 1,300 to 1,340 tokens for plain English on OpenAI's o200k_base encoding, and 1,400 to 1,700 for technical text full of numbers and code. Other languages take more: up to 60% more in the sample above.
Do cached tokens count toward rate limits?
Yes. Cached tokens count toward tokens-per-minute limits like any other input, per OpenAI's rate limits guide, even though they cost less.
Why is the bill higher than a tiktoken count?
tiktoken counts plain text only. The bill also includes message formatting, tool definitions, images, reasoning tokens billed as output, cache writes at 1.25x, Fast mode set at project level, and prompts past 272,000 tokens. Compare usage on a few real responses with your estimate to find the gap, and set a spend limit while you do.
Sources
- OpenAI API docs: Pricing, Models, model pages for gpt-6-astra, gpt-6.1-sol, gpt-6-sol, gpt-6.1-terra, gpt-6-luna, gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna and chat-latest
- OpenAI API docs: Prompt caching, Reasoning models, Counting tokens, Conversation state, Images and vision, Using GPT-6
- OpenAI API docs: Batch API, Flex processing, Fast mode, Rate limits, API usage for ChatGPT subscribers, Changelog, Deprecations
- OpenAI Help Center: Understanding and counting tokens
- OpenAI Developer Community: GPT-5.6 cache read/write token billing thread
- tiktoken: GitHub repository, changelog, PyPI 0.14.0, issue #608, pull request #616; openai on PyPI (3.45.0)
- williamliu-ai, token-count-compare, run of 26 Sep 2026
- Project Gutenberg, Pride and Prejudice and The United States Constitution, used for token-per-word measurements
- Hacker News comments 49899392 and 49452225
- YouTube: OpenAI, Build Hour: Valuemaxxing with GPT-5.6
- Aight: Models and pricing, API reference, Token cost calculator, Refund policy
Checked on 5 November 2026. Updated 17 November 2026: Aight's current model list.