Blog

OpenAI token pricing: every model's price per token, cache, Batch, Flex and Fast rates, and code to count tokens

Ramashankar S · · Updated · 19 min read

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.

ModelInputCached inputCache writeOutputBatch or Flex, in / outFast (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.50None$30.00Not offeredNot 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.

Price multipliers on OpenAI tokens: cache reads 0.05x and 0.1x, Batch and Flex 0.5x, regional 1.1x, 30-minute cache write 1.25x, long-prompt output 1.5x, long-prompt input 2x, Fast 2x, 12-hour cache write 2.5x, Ultrafast 6x

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.

ModelInput / cached / outputBatch, in / outFlexFast, in / outShuts down
gpt-5.5$5.00 / $0.50 / $30.00$2.50 / $15.00Yes$12.50 / $75.00Not announced
gpt-5.5-pro, gpt-5.4-pro$30.00 / none / $180.00$15.00 / $90.00YesNoNot announced
gpt-5.4$2.50 / $0.25 / $15.00$1.25 / $7.50Yes$5.00 / $30.00Not announced
gpt-5.4-mini$0.75 / $0.075 / $4.50$0.375 / $2.25Yes$1.50 / $9.00Not announced
gpt-5.4-nano$0.20 / $0.02 / $1.25$0.10 / $0.625YesNo1 Apr 2027
gpt-5.3-codex$1.75 / $0.175 / $14.00Not listedNo$3.50 / $28.001 Apr 2027
gpt-5.2$1.75 / $0.175 / $14.00$0.875 / $7.00Yes$3.50 / $28.00Not announced
gpt-5.2-pro$21.00 / none / $168.00$10.50 / $84.00NoNoNot announced
gpt-5.1$1.25 / $0.125 / $10.00$0.625 / $5.00Yes$2.50 / $20.001 Apr 2027
gpt-5$1.25 / $0.125 / $10.00$0.625 / $5.00Yes$2.50 / $20.0011 Dec 2026
gpt-5-mini$0.25 / $0.025 / $2.00$0.125 / $1.00Yes$0.45 / $3.6011 Dec 2026
gpt-5-nano$0.05 / $0.005 / $0.40$0.025 / $0.20YesNo11 Dec 2026
gpt-5-pro$15.00 / none / $120.00$7.50 / $60.00NoNo11 Dec 2026
o3$2.00 / $0.50 / $8.00$1.00 / $4.00Yes$3.50 / $14.0011 Dec 2026
o3-pro$20.00 / none / $80.00$10.00 / $40.00NoNo11 Dec 2026
gpt-4.1$2.00 / $0.50 / $8.00$1.00 / $4.00No$3.50 / $14.0014 Jan 2027
gpt-4.1-mini$0.40 / $0.10 / $1.60$0.20 / $0.80No$0.70 / $2.8014 Jan 2027
gpt-4o$2.50 / $1.25 / $10.00$1.25 / $5.00No$4.25 / $17.0014 Jan 2027
gpt-4o-mini$0.15 / $0.075 / $0.60$0.075 / $0.30No$0.25 / $1.0014 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:

LanguageTokensvs English
English921.00x
Chinese1051.14x
German1121.22x
Spanish1161.26x
French1231.34x
Hindi1381.50x
Japanese1471.60x
The same 83-word support reply counted in o200k_base tokens: English 92, Chinese 105, German 112, Spanish 116, French 123, Hindi 138, Japanese 147

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.

ModelInput per tokenOutput per tokenInput per 1,000 tokensOutput per 1,000 tokensA 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-lunagpt-6.1-solgpt-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) or completion_tokens (Chat Completions). output_tokens_details.reasoning_tokens shows 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. none works 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 use low.
  • reasoning.mode: "pro" bills at the normal token rates but does more work, so it uses more tokens.
  • max_output_tokens (Responses) and max_completion_tokens (Chat Completions) cap reasoning plus visible text. A response that hits the cap returns status: "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.context defaults to all_turns, which renders earlier turns' reasoning into later requests (gpt-6.1-sol supports it too). And in a previous_response_id chain, 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.

TierHow to request itPrice vs StandardTrade-off
BatchUpload a JSONL file to the Batch API0.5xResults inside a 24-hour window; up to 50,000 requests per batch
Flexservice_tier="flex"0.5xSlower; 429 "Resource Unavailable" at busy times, not charged
StandardDefault1x
Fast (was Priority)service_tier="fast" or "priority"2x on GPT-5.6 and laterUp to 2.5x faster
Ultrafastservice_tier="ultrafast"6xgpt-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.

Build Hour: Valuemaxxing with GPT-5.6OpenAI · 54:33 · YouTube
OpenAI's session on comparing models by cost and quality, from 24 July 2026; its prices predate the 30 July cuts and GPT-6.

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 max effort 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, messages and stream as request fields, so confirm that cached_tokens comes 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

Checked on 5 November 2026. Updated 17 November 2026: Aight's current model list.