comparisons

GPT-6.2 API Pricing: Astra and Sol on PoYo vs OpenAI, Cost per Request

Poyo.ai Team
8 min read
Share:

GPT-6.2 API pricing on PoYo compared with OpenAI

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: PoYoAstra: OpenAIAstra: OpenRouterSol: PoYoSol: OpenAISol: 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 1MAstra ≤272KAstra >272KSol ≤272KSol >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

ItemHow it is billedSource
Prompt tokens (text and image)Input ratePoYo price list
Visible answer tokensOutput ratePoYo price list
Reasoning tokensOutput rate; hidden, but counted in usage.output_tokensOpenAI reasoning guide
Prompt tokens read from cacheCache-read rate, 0.05× input for GPT-6.2OpenAI caching guide, PoYo price list
Prompt tokens written to cacheCache-write rate, 1.25× input for the default 30-minute retentionOpenAI caching guide, PoYo price list
Batch, background, Fast, UltrafastOpenAI tiers, not part of these PoYo endpointsOpenAI 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

ModelArithmetic (PoYo)PoYoOpenAI
Sol0.003 × $1.60 + 0.0008 × $8$0.0112 (2.24 credits)$0.014
Astra0.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

ModelArithmetic (PoYo)PoYoOpenAI
Sol0.15 × $1.60 + 0.012 × $8 = $0.24 + $0.096$0.336 (67.2 credits)$0.42
Astra0.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
CaseSol on PoYoAstra on PoYoSol at OpenAIAstra 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
ModelWith 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 IDInputOutputCache readCache writeExample 2Example 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.

Share: