
Su PoYo i prezzi della GPT-6.2 API sono $6.40 di input e $32 di output per 1M di token per gpt-6.2-astra, e $1.60 di input e $8 di output per gpt-6.2-sol. Entrambi sono inferiori del 20% alle tariffe standard di OpenAI, incluse letture e scritture in cache. Questo articolo mette i listini fianco a fianco, spiega cosa copre ogni voce e calcola il costo di quattro richieste realistiche. Le tariffe PoYo aggiornate sono sempre sulle pagine dei modelli GPT-6.2 Astra e GPT-6.2 Sol.
I prezzi PoYo qui sotto sono quelli in listino al 18 novembre 2026. I prezzi di OpenAI provengono dalla sua pagina dei prezzi dell'API e quelli di OpenRouter dal suo elenco pubblico dei modelli, entrambi consultati lo stesso giorno.
Prezzo della GPT-6.2 API per 1M di token
| Voce (per 1M di token) | 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, ragionamento incluso | $32.00 | $40.00 | $40.00 | $8.00 | $10.00 | $10.00 |
| Lettura dalla cache | $0.32 | $0.40 | $0.40 | $0.08 | $0.10 | $0.10 |
| Scrittura in cache | $8.00 | $10.00 | $10.00 | $2.00 | $2.50 | $2.50 |
In crediti PoYo (1 credito = $0.005): Astra costa 1,280 / 6,400 / 64 / 1,600 crediti e Sol 320 / 1,600 / 16 / 400 crediti per le stesse quattro voci. OpenRouter elenca entrambi i modelli alle tariffe standard di OpenAI.
Per token, Astra costa esattamente quattro volte Sol su ogni voce.
Contesto lungo e altri livelli di OpenAI
La pagina dei prezzi di OpenAI distingue il contesto breve (≤272K token di input) dal contesto lungo (>272K). Oltre i 272K, "le tariffe di input e cache raddoppiano e l'output costa 1.5 volte la tariffa per contesto breve per l'intera richiesta":
| 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 |
| Lettura dalla cache | $0.40 | $0.80 | $0.10 | $0.20 |
| Scrittura in cache (30 min) | $10.00 | $20.00 | $2.50 | $5.00 |
OpenAI elenca anche Batch al 50% della tariffa standard, finestre in background con uno sconto del 30–40%, e Fast e Ultrafast a un multiplo della tariffa standard. Sono livelli lato OpenAI. I prezzi PoYo di questo articolo valgono per gli endpoint sincroni /v1/responses e /v1/chat/completions. Tutti gli esempi calcolati qui sotto mantengono ogni richiesta entro i 272K token di input.
Cosa viene fatturato e cosa no
| Voce | Come viene fatturata | Fonte |
|---|---|---|
| Token del prompt (testo e immagini) | Tariffa di input | Listino PoYo |
| Token della risposta visibile | Tariffa di output | Listino PoYo |
| Token di ragionamento | Tariffa di output; nascosti, ma conteggiati in usage.output_tokens | Guida al ragionamento di OpenAI |
| Token del prompt letti dalla cache | Tariffa di lettura dalla cache, 0.05× l'input per GPT-6.2 | Guida al caching di OpenAI, listino PoYo |
| Token del prompt scritti in cache | Tariffa di scrittura in cache, 1.25× l'input per la retention predefinita di 30 minuti | Guida al caching di OpenAI, listino PoYo |
| Batch, background, Fast, Ultrafast | Livelli di OpenAI, non inclusi in questi endpoint PoYo | Pagina dei prezzi di OpenAI |
GPT-6.2 dimezza il rapporto di lettura dalla cache rispetto a GPT-6 Astra e GPT-6 Sol (0.05× contro 0.1× dell'input), quindi un prefisso stabile vale più di prima. La guida al caching di OpenAI fissa il prefisso minimo memorizzabile in cache a 1,024 token di input visibili.
Esempi di costo calcolati per la GPT-6.2 API
Inserisci i tuoi conteggi di token. I conteggi di output includono i token di ragionamento.
1. Risposta in chat: 3K di input, 800 di output
| Modello | Calcolo (PoYo) | PoYo | OpenAI |
|---|---|---|---|
| Sol | 0.003 × $1.60 + 0.0008 × $8 | $0.0112 (2.24 crediti) | $0.014 |
| Astra | 0.003 × $6.40 + 0.0008 × $32 | $0.0448 (8.96 crediti) | $0.056 |
Con 10,000 risposte al mese: $112 su Sol o $448 su Astra tramite PoYo, contro $140 e $560 al prezzo di listino di OpenAI.
2. Code review: 150K di input, 12K di output
| Modello | Calcolo (PoYo) | PoYo | OpenAI |
|---|---|---|---|
| Sol | 0.15 × $1.60 + 0.012 × $8 = $0.24 + $0.096 | $0.336 (67.2 crediti) | $0.42 |
| Astra | 0.15 × $6.40 + 0.012 × $32 = $0.96 + $0.384 | $1.344 (268.8 crediti) | $1.68 |
3. Sessione di agente: 25 turni con contesto crescente
Un agente parte da un prefisso di 40,000 token (messaggio developer, definizioni dei tool, task). Ogni turno aggiunge 4,000 token di risultati dei tool e output precedente, e il modello scrive 1,500 token di output per turno. L'ultimo turno invia 136,000 token di input, sotto la soglia dei 272K.
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
| Caso | Sol su PoYo | Astra su PoYo | Sol presso OpenAI | Astra presso OpenAI |
|---|---|---|---|---|
| Nessun cache hit | $3.82 (764 crediti) | $15.28 (3,056 crediti) | $4.775 | $19.10 |
| Caso migliore: ogni turno legge il prefisso precedente | $0.737 (147.4 crediti) | $2.948 (589.7 crediti) | $0.921 | $3.686 |
Caso migliore su Sol: 0.136 × $2 + 2.064 × $0.08 + 0.0375 × $8 = $0.272 + $0.165 + $0.30. Le esecuzioni reali si collocano tra le due righe, perché un cache hit non è garantito. In entrambe le righe domina l'input, quindi un prefisso stabile fa risparmiare più che ridurre l'output. I pattern per gli agenti sono in GPT-6.2 API per agenti di coding.
4. Q&A su documento in cache: documento da 200K, 40 domande
Un insieme di contratti da 200,000 token è il prefisso fisso; ognuna delle 40 domande aggiunge 300 token e riceve una risposta da 1,200 token. La prima chiamata scrive il documento in cache e le 39 successive lo leggono.
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
| Modello | Con cache hit (PoYo) | Senza cache hit (PoYo) | Con cache hit (OpenAI) |
|---|---|---|---|
| Sol | $1.427 (285.4 crediti) | $13.20 | $1.784 |
| Astra | $5.709 (1,141.8 crediti) | $52.81 | $7.136 |
I cache hit riducono il costo di questo carico di lavoro di circa l'89%. Metti il documento all'inizio e la domanda alla fine, così il prefisso resta identico.
GPT-6.2 API vs i modelli GPT-6 precedenti su PoYo
Prezzi di listino PoYo per 1M di token:
| ID modello | Input | Output | Lettura dalla cache | Scrittura in cache | Esempio 2 | Esempio 4 (in cache) |
|---|---|---|---|---|---|---|
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 costa il 20% in meno di GPT-6 Astra su input, output e scrittura in cache, e il 60% in meno sulla lettura dalla cache. GPT-6.2 Sol costa quanto GPT-6.1 Sol e dimezza il prezzo di lettura dalla cache di GPT-6 Sol. Con gli stessi conteggi di token su ogni modello, questo è un confronto di prezzo, non un'affermazione sul costo per task. I passaggi di migrazione sono in GPT-6.2 API vs GPT-6.1 Sol API, e il quadro tra fornitori diversi in Prezzi della Claude API e Gemini 4 Carbon API vs Claude Opus 5.5 vs GPT-6 Astra.
Domande frequenti
Quanto costa la GPT-6.2 API per 1M di token?
Su PoYo: Astra $6.40 di input, $32 di output, $0.32 di lettura dalla cache, $8 di scrittura in cache; Sol $1.60, $8, $0.08, $2. Le tariffe standard di OpenAI sono $8 / $40 / $0.40 / $10 e $2 / $10 / $0.10 / $2.50.
I token di ragionamento della GPT-6.2 API vengono fatturati?
Sì. OpenAI fattura i token di ragionamento come token di output. Sono nascosti nella risposta, ma conteggiati in usage.output_tokens.
GPT-6.2 Sol costa meno di GPT-6.1 Sol?
No, i prezzi per token sono identici su PoYo e presso OpenAI. GPT-6.2 Sol costa meno di GPT-6 Sol sulle letture dalla cache ($0.08 contro $0.16 per 1M su PoYo).
Quanto costa in meno la GPT-6.2 Sol API rispetto alla GPT-6.2 Astra API?
Sol costa un quarto di Astra su ogni voce. Se un task costi davvero un quarto dipende da quanti token ciascun modello spende per svolgerlo, quindi misura entrambi sui tuoi prompt.
Quanto fa pagare OpenAI i prompt GPT-6.2 oltre i 272K token?
OpenAI raddoppia le tariffe di input e cache e applica 1.5× all'output per l'intera richiesta: Astra $16 / $60 e Sol $4 / $15 per 1M di token di input/output.