
GPT-6.2 API pricing on PoYo is $6.40 input and $32 output per 1M tokens for gpt-6.2-astra, and $1.60 input and $8 output for gpt-6.2-sol. Both are 20% below OpenAI's standard rates, including cache reads and cache writes. This post puts the price lists side by side, explains what each meter covers, and works out the cost of four realistic request shapes. Current PoYo rates are always on the GPT-6.2 Astra and GPT-6.2 Sol model pages.
PoYo prices below are as listed on November 18, 2026. OpenAI prices come from its API pricing page, and OpenRouter prices from its public model list, both read the same day.
GPT-6.2 API price per 1M tokens
| Meter (per 1M tokens) | Astra: PoYo | Astra: OpenAI | Astra: OpenRouter | Sol: PoYo | Sol: OpenAI | Sol: OpenRouter |
|---|---|---|---|---|---|---|
| Input | $6.40 | $8.00 | $8.00 | $1.60 | $2.00 | $2.00 |
| Output, incl. reasoning | $32.00 | $40.00 | $40.00 | $8.00 | $10.00 | $10.00 |
| Cache read | $0.32 | $0.40 | $0.40 | $0.08 | $0.10 | $0.10 |
| Cache write | $8.00 | $10.00 | $10.00 | $2.00 | $2.50 | $2.50 |
In PoYo credits (1 credit = $0.005): Astra is 1,280 / 6,400 / 64 / 1,600 credits and Sol is 320 / 1,600 / 16 / 400 credits for the same four meters. OpenRouter lists both models at OpenAI's standard rates.
Per token, Astra costs exactly four times as much as Sol on every meter.
OpenAI's long-context and other tiers
OpenAI's pricing page separates short context (≤272K input tokens) from long context (>272K). Above 272K, "input and cache rates double and output costs 1.5 times the short-context rate for the full request":
| OpenAI standard, per 1M | Astra ≤272K | Astra >272K | Sol ≤272K | Sol >272K |
|---|---|---|---|---|
| Input | $8.00 | $16.00 | $2.00 | $4.00 |
| Output | $40.00 | $60.00 | $10.00 | $15.00 |
| Cache read | $0.40 | $0.80 | $0.10 | $0.20 |
| Cache write (30 min) | $10.00 | $20.00 | $2.50 | $5.00 |
OpenAI also lists Batch at 50% of standard, background windows at 30–40% off, and Fast and Ultrafast at a multiple of standard. Those are OpenAI-side tiers. The PoYo prices in this post are for the synchronous /v1/responses and /v1/chat/completions endpoints. All worked examples below keep each request at or under 272K input tokens.
What is and is not billed
| Item | How it is billed | Source |
|---|---|---|
| Prompt tokens (text and image) | Input rate | PoYo price list |
| Visible answer tokens | Output rate | PoYo price list |
| Reasoning tokens | Output rate; hidden, but counted in usage.output_tokens | OpenAI reasoning guide |
| Prompt tokens read from cache | Cache-read rate, 0.05× input for GPT-6.2 | OpenAI caching guide, PoYo price list |
| Prompt tokens written to cache | Cache-write rate, 1.25× input for the default 30-minute retention | OpenAI caching guide, PoYo price list |
| Batch, background, Fast, Ultrafast | OpenAI tiers, not part of these PoYo endpoints | OpenAI pricing page |
GPT-6.2 halves the cache-read ratio compared with GPT-6 Astra and GPT-6 Sol (0.05× vs 0.1× of input), so a stable prefix is worth more than before. OpenAI's caching guide sets the minimum cacheable prefix at 1,024 visible input tokens.
Worked GPT-6.2 API cost examples
Plug in your own token counts. Output counts include reasoning tokens.
1. Chat reply: 3K input, 800 output
| Model | Arithmetic (PoYo) | PoYo | OpenAI |
|---|---|---|---|
| Sol | 0.003 × $1.60 + 0.0008 × $8 | $0.0112 (2.24 credits) | $0.014 |
| Astra | 0.003 × $6.40 + 0.0008 × $32 | $0.0448 (8.96 credits) | $0.056 |
At 10,000 replies a month: $112 on Sol or $448 on Astra through PoYo, against $140 and $560 at OpenAI's list price.
2. Code review: 150K input, 12K output
| Model | Arithmetic (PoYo) | PoYo | OpenAI |
|---|---|---|---|
| Sol | 0.15 × $1.60 + 0.012 × $8 = $0.24 + $0.096 | $0.336 (67.2 credits) | $0.42 |
| Astra | 0.15 × $6.40 + 0.012 × $32 = $0.96 + $0.384 | $1.344 (268.8 credits) | $1.68 |
3. Agent session: 25 turns with a growing context
An agent starts with a 40,000-token prefix (developer message, tool definitions, task). Each turn adds 4,000 tokens of tool results and prior output, and the model writes 1,500 output tokens per turn. The last turn sends 136,000 input tokens, under the 272K line.
input per turn t = 40,000 + 4,000 × (t − 1)
total input = 25 × 40,000 + 4,000 × (0 + 1 + … + 24) = 2,200,000 tokens
total output = 25 × 1,500 = 37,500 tokens
best-case cache = 136,000 written (40K on turn 1, then 4K per turn)
+ 2,064,000 read
| Case | Sol on PoYo | Astra on PoYo | Sol at OpenAI | Astra at OpenAI |
|---|---|---|---|---|
| No cache hits | $3.82 (764 credits) | $15.28 (3,056 credits) | $4.775 | $19.10 |
| Best case: each turn reads the previous prefix | $0.737 (147.4 credits) | $2.948 (589.7 credits) | $0.921 | $3.686 |
Best case on Sol: 0.136 × $2 + 2.064 × $0.08 + 0.0375 × $8 = $0.272 + $0.165 + $0.30. Real runs land between the two rows, because a cache hit is not guaranteed. In both rows input dominates, so a stable prefix saves more than trimming output. Agent patterns are in GPT-6.2 API for coding agents.
4. Cached document Q&A: 200K document, 40 questions
A 200,000-token contract bundle is the fixed prefix; each of 40 questions adds 300 tokens and gets a 1,200-token answer. The first call writes the document to cache and the next 39 read it.
cache write: 200,000 tokens (first call)
cache read: 39 × 200,000 = 7,800,000 tokens
input rate: 40 × 300 = 12,000 tokens
output: 40 × 1,200 = 48,000 tokens
| Model | With cache hits (PoYo) | No cache hits (PoYo) | With cache hits (OpenAI) |
|---|---|---|---|
| Sol | $1.427 (285.4 credits) | $13.20 | $1.784 |
| Astra | $5.709 (1,141.8 credits) | $52.81 | $7.136 |
Cache hits cut this workload by about 89%. Keep the document first and the question last so the prefix stays identical.
GPT-6.2 API vs earlier GPT-6 models on PoYo
PoYo list prices per 1M tokens:
| Model ID | Input | Output | Cache read | Cache write | Example 2 | Example 4 (cached) |
|---|---|---|---|---|---|---|
gpt-6.2-astra | $6.40 | $32.00 | $0.32 | $8.00 | $1.344 | $5.709 |
gpt-6-astra | $8.00 | $40.00 | $0.80 | $10.00 | $1.68 | $10.256 |
gpt-6.2-sol | $1.60 | $8.00 | $0.08 | $2.00 | $0.336 | $1.427 |
gpt-6.1-sol | $1.60 | $8.00 | $0.08 | $2.00 | $0.336 | $1.427 |
gpt-6-sol | $1.60 | $8.00 | $0.16 | $2.00 | $0.336 | $2.051 |
GPT-6.2 Astra is 20% cheaper than GPT-6 Astra on input, output, and cache write, and 60% cheaper on cache read. GPT-6.2 Sol costs the same as GPT-6.1 Sol and halves GPT-6 Sol's cache-read price. Same token counts on each model make this a price comparison, not a cost-per-task claim. The migration steps are in GPT-6.2 API vs GPT-6.1 Sol API, and the cross-vendor picture in Claude API pricing and Gemini 4 Carbon API vs Claude Opus 5.5 vs GPT-6 Astra.
Frequently asked questions
How much does the GPT-6.2 API cost per 1M tokens?
On PoYo: Astra $6.40 input, $32 output, $0.32 cache read, $8 cache write; Sol $1.60, $8, $0.08, $2. OpenAI's standard rates are $8 / $40 / $0.40 / $10 and $2 / $10 / $0.10 / $2.50.
Are GPT-6.2 API reasoning tokens billed?
Yes. OpenAI bills reasoning tokens as output tokens. They are hidden from the response but counted in usage.output_tokens.
Is GPT-6.2 Sol cheaper than GPT-6.1 Sol?
No, per-token prices are identical on PoYo and at OpenAI. GPT-6.2 Sol is cheaper than GPT-6 Sol on cache reads ($0.08 vs $0.16 per 1M on PoYo).
How much cheaper is the GPT-6.2 Sol API than the GPT-6.2 Astra API?
Sol costs one quarter of Astra on every meter. Whether a task costs a quarter as much depends on how many tokens each model spends on it, so measure both on your own prompts.
What does OpenAI charge for GPT-6.2 prompts above 272K tokens?
OpenAI doubles input and cache rates and charges 1.5× output for the whole request: Astra $16 / $60 and Sol $4 / $15 per 1M input/output tokens.