Summary
- One flagship row on OpenAI's price list carries five prices under the single header
Prices per 1M tokens.: input $8.00, output $40.00, cached input $0.40, a 30-minute cache write at $10.00 and a 12-hour cache write at $20.00 for gpt-6.2-astra. - Across the eight documents read, the price list defines no token, the three pages that discuss the unit give three estimates in three units, and the only model-to-encoding table in the set is an archived page whose newest model is gpt-4o — an older row that prints three prices, not ten.
Start with the header, because the header is the whole instrument. The pricing page prints one unit line, Prices per 1M tokens., and then a column set — Model Input Output Cached input 30m write 12h write — in which every number is a dollar figure per million tokens. The flagship row, quoted as returned: gpt-6.2-astra $8.00 $40.00 $0.40 $10.00 $20.00. Five prices, one model, one unit.
The Batch block repeats the same five columns at half the figures: $4.00 / $20.00 / $0.20 / $5.00 / $10.00. The returned text also names processing tiers — Standard, Batch, Flex, Fast, Ultrafast — so the count of prices a buyer faces on one model is the product of columns and tiers, not of models alone. The second host doubles the columns again by splitting context at a printed boundary: Short context: ≤272K input tokens. Long context: >272K input tokens. The same gpt-6.2-astra row therefore prints ten prices there, running from $8.00 to $60.00. Two renderings of one table disagree on which rows exist — the platform rendering omits gpt-6.1-terra and gpt-6-luna — and the retrieved text cannot establish whether they are one document on two hosts or two documents. That disagreement belongs in the record, not in a footnote.
The prices themselves are consistent. $0.40 divided by $8.00 is 0.05: the printed cached-input price sits at exactly one-twentieth of the printed input price. $10.00 and $20.00 divided by $8.00 give 1.25 and 2.5, which are the ratios the caching guide states in words — reads at 0.05× ordinary input on GPT-6.2 Astra, GPT-6.2 Sol, GPT-6.1 Sol and GPT-6.1 Terra and 0.1× on most GPT-5.6 and later models, writes at 1.25× for thirty minutes and 2.5× for twelve hours. The arithmetic is not in dispute. What is in dispute is what it multiplies.
The cheap column is also the most conditioned one, and its conditions are written in the same unit the page never defines. Cache reuse requires the entire rendered prefix to match. A prompt prefix must meet the model's minimum cacheable token length before it can be cached. Tokens in the OpenAI-provided hidden system content do not count toward this minimum. The minimum cacheable prompt length is 1,024 tokens for GPT-5.6 and later. When no explicit breakpoints are placed, the request does not use prompt caching or create cache writes. Cache-write pricing is not an additive fee: input tokens use the uncached-input, cached-input, or cache-write rate. The same non-additive rule is restated verbatim on the developers-host mirror. For earlier models, the guide says the reported cached count is rounded down to the nearest multiple of 128 after hidden system tokens are subtracted. A one-twentieth price is real; it is gated by a 1,024-token prefix, an exact match, and a rounding rule, all expressed in the unit the price list leaves standing.
Now the unit. The library README describes the mechanism — Byte pair encoding (BPE) is a way of converting text into tokens. — and offers one conversion figure, in bytes: On average, in practice, each token corresponds to about 4 bytes. The advanced-usage guide offers a different one, in characters and words: As a rough rule of thumb, 1 token is approximately 4 characters or 0.75 words for English text. It also reports that a token can be as short as one character or as long as one word, that "ChatGPT is great!" encodes into six tokens, and that Chat models use additional tokens for message formatting, so counting the text alone doesn't give the full input token count. The help centre repeats the heuristic triple — 1 token is approximately 4 characters. 1 token is approximately three-quarters of a word. 100 tokens are approximately 75 words. — and then says the quiet part out loud: These are estimates, not exact counts.
Three pages, three units: bytes, characters, words. Each figure is labelled approximate, and none of the eight documents read defines the token on the price list itself. That is not a scandal; it is a disclosure boundary. The exact number on the page is a dollar figure per million tokens. The quantity that turns a document into a bill is stated elsewhere, in units that do not convert into one another without a chosen heuristic.
The encoding table is where the boundary hardens. The cookbook page is the only document in the set that maps encoding names to model families: o200k_base for gpt-4o and gpt-4o-mini, cl100k_base for gpt-4-turbo, gpt-4, gpt-3.5-turbo and the ada-002 and embedding-3 models, p50k_base for Codex and text-davinci-002 and -003, r50k_base for GPT-3 models. It opens Encodings specify how text is converted into tokens. Different models use different encodings. It also carries the banner This recipe is archived and may reference outdated models or APIs., its prose says the library supports three encodings while its table lists four, and its newest model is gpt-4o. So the rows whose encoding a reader can actually name are the older rows that print exactly three prices — input, output, cached input — and the row that prints ten prices has no encoding name in any document obtained.
My arithmetic, since no page prints it: at the guide's 0.75 words per token, one million tokens is about 750,000 English words, so $8.00 per million tokens works out to roughly $10.67 per million English words. Change the heuristic to the README's about 4 bytes and the figure moves, because bytes are not characters and characters are not words. The help centre's own pair makes the same point: 100 tokens at four characters each is 400 characters, while the same 100 tokens are given as 75 words. Two statements, two objects, one unit label.
The practical consequence is a comparison problem, not a pricing problem. Two vendors' per-token prices can be compared as written only if the tokens are counted the same way, and within this one price list the rows are already counted under at least four named encodings. A buyer who budgets from word counts is budgeting from an estimate that the vendor itself flags as an estimate. A buyer who budgets from tokens is budgeting exactly, in a unit he cannot independently define from the page he is buying from.
One more mark on the instrument: several rows print a dash where the cached price would sit — gpt-5.5-pro, gpt-5.4-pro, gpt-5.2-pro, gpt-5-pro, o3-pro. A dash is not a zero and not a free cache; it is an absence of a printed price, and it belongs on the same row as the numbers that are printed.
So the disclosure is precise where it is priced and approximate where it is defined. The dollar figures carry two decimals. The denominator carries three estimates, three units, an archived encoding table, and a boundary at 272,000 tokens that appears on one rendering of the table and not the other. Anyone quoting these prices per thousand words is quoting my arithmetic and OpenAI's heuristic, not a number the price page prints. The linked directory entry records the company; the instrument is the page.
Member Briefing
Read the full trend briefing
Members read the full briefing with the source notes behind every finding.
Strategic Circle
A daily briefing in your language, built from changes we have verified.
Join for USD 20/monthCancel anytime.
Members also get the full research library, a daily briefing on the networks they follow and the private forum.






