
O preço da GPT-6.2 API na PoYo é de $6.40 de entrada e $32 de saída por 1M de tokens para o gpt-6.2-astra, e de $1.60 de entrada e $8 de saída para o gpt-6.2-sol. Os dois ficam 20% abaixo das tarifas padrão da OpenAI, incluindo leituras e escritas de cache. Este post coloca as tabelas de preço lado a lado, explica o que cada medidor cobre e calcula o custo de quatro formatos realistas de requisição. As tarifas atuais da PoYo estão sempre nas páginas dos modelos GPT-6.2 Astra e GPT-6.2 Sol.
Os preços da PoYo abaixo são os listados em 18 de novembro de 2026. Os preços da OpenAI vêm da sua página de preços da API, e os do OpenRouter, da sua lista pública de modelos, ambos consultados no mesmo dia.
Preço da GPT-6.2 API por 1M de tokens
| Medidor (por 1M de tokens) | Astra: PoYo | Astra: OpenAI | Astra: OpenRouter | Sol: PoYo | Sol: OpenAI | Sol: OpenRouter |
|---|---|---|---|---|---|---|
| Entrada | $6.40 | $8.00 | $8.00 | $1.60 | $2.00 | $2.00 |
| Saída, incl. raciocínio | $32.00 | $40.00 | $40.00 | $8.00 | $10.00 | $10.00 |
| Leitura de cache | $0.32 | $0.40 | $0.40 | $0.08 | $0.10 | $0.10 |
| Escrita de cache | $8.00 | $10.00 | $10.00 | $2.00 | $2.50 | $2.50 |
Em créditos da PoYo (1 crédito = $0.005): o Astra custa 1,280 / 6,400 / 64 / 1,600 créditos e o Sol 320 / 1,600 / 16 / 400 créditos nos mesmos quatro medidores. O OpenRouter lista os dois modelos pelas tarifas padrão da OpenAI.
Por token, o Astra custa exatamente quatro vezes mais que o Sol em todos os medidores.
Contexto longo e outros níveis da OpenAI
A página de preços da OpenAI separa contexto curto (≤272K tokens de entrada) de contexto longo (>272K). Acima de 272K, "as tarifas de entrada e de cache dobram e a saída custa 1.5 vez a tarifa de contexto curto para a requisição inteira":
| OpenAI padrão, por 1M | Astra ≤272K | Astra >272K | Sol ≤272K | Sol >272K |
|---|---|---|---|---|
| Entrada | $8.00 | $16.00 | $2.00 | $4.00 |
| Saída | $40.00 | $60.00 | $10.00 | $15.00 |
| Leitura de cache | $0.40 | $0.80 | $0.10 | $0.20 |
| Escrita de cache (30 min) | $10.00 | $20.00 | $2.50 | $5.00 |
A OpenAI também lista o Batch a 50% do padrão, janelas em segundo plano (background) com 30–40% de desconto e os níveis Fast e Ultrafast a um múltiplo do padrão. Esses são níveis do lado da OpenAI. Os preços da PoYo neste post valem para os endpoints síncronos /v1/responses e /v1/chat/completions. Todos os exemplos calculados abaixo mantêm cada requisição em 272K tokens de entrada ou menos.
O que é cobrado e o que não é
| Item | Como é cobrado | Fonte |
|---|---|---|
| Tokens do prompt (texto e imagem) | Tarifa de entrada | Tabela de preços da PoYo |
| Tokens visíveis da resposta | Tarifa de saída | Tabela de preços da PoYo |
| Tokens de raciocínio | Tarifa de saída; ocultos, mas contados em usage.output_tokens | Guia de raciocínio da OpenAI |
| Tokens do prompt lidos do cache | Tarifa de leitura de cache, 0.05× a entrada no GPT-6.2 | Guia de cache da OpenAI, tabela de preços da PoYo |
| Tokens do prompt gravados no cache | Tarifa de escrita de cache, 1.25× a entrada com a retenção padrão de 30 minutos | Guia de cache da OpenAI, tabela de preços da PoYo |
| Batch, background, Fast, Ultrafast | Níveis da OpenAI, não fazem parte destes endpoints da PoYo | Página de preços da OpenAI |
O GPT-6.2 reduz pela metade a proporção de leitura de cache em comparação com o GPT-6 Astra e o GPT-6 Sol (0.05× contra 0.1× da entrada), então um prefixo estável vale mais do que antes. O guia de cache da OpenAI define o prefixo mínimo que pode ir para o cache em 1,024 tokens de entrada visíveis.
Exemplos de custo calculados da GPT-6.2 API
Use as suas próprias contagens de tokens. As contagens de saída incluem os tokens de raciocínio.
1. Resposta de chat: 3K de entrada, 800 de saída
| Modelo | Conta (PoYo) | PoYo | OpenAI |
|---|---|---|---|
| Sol | 0.003 × $1.60 + 0.0008 × $8 | $0.0112 (2.24 créditos) | $0.014 |
| Astra | 0.003 × $6.40 + 0.0008 × $32 | $0.0448 (8.96 créditos) | $0.056 |
Com 10,000 respostas por mês: $112 no Sol ou $448 no Astra pela PoYo, contra $140 e $560 pelo preço de tabela da OpenAI.
2. Revisão de código: 150K de entrada, 12K de saída
| Modelo | Conta (PoYo) | PoYo | OpenAI |
|---|---|---|---|
| Sol | 0.15 × $1.60 + 0.012 × $8 = $0.24 + $0.096 | $0.336 (67.2 créditos) | $0.42 |
| Astra | 0.15 × $6.40 + 0.012 × $32 = $0.96 + $0.384 | $1.344 (268.8 créditos) | $1.68 |
3. Sessão de agente: 25 turnos com contexto crescente
Um agente começa com um prefixo de 40,000 tokens (mensagem developer, definições de ferramentas, tarefa). Cada turno adiciona 4,000 tokens de resultados de ferramentas e saídas anteriores, e o modelo escreve 1,500 tokens de saída por turno. O último turno envia 136,000 tokens de entrada, abaixo da linha de 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 na PoYo | Astra na PoYo | Sol na OpenAI | Astra na OpenAI |
|---|---|---|---|---|
| Sem acertos de cache | $3.82 (764 créditos) | $15.28 (3,056 créditos) | $4.775 | $19.10 |
| Melhor caso: cada turno lê o prefixo anterior | $0.737 (147.4 créditos) | $2.948 (589.7 créditos) | $0.921 | $3.686 |
Melhor caso no Sol: 0.136 × $2 + 2.064 × $0.08 + 0.0375 × $8 = $0.272 + $0.165 + $0.30. Execuções reais ficam entre as duas linhas, porque um acerto de cache não é garantido. Nas duas linhas a entrada domina, então um prefixo estável economiza mais do que cortar a saída. Padrões de agentes estão em GPT-6.2 API para agentes de programação.
4. Perguntas e respostas sobre documento com cache: documento de 200K, 40 perguntas
Um conjunto de contratos com 200,000 tokens é o prefixo fixo; cada uma das 40 perguntas adiciona 300 tokens e recebe uma resposta de 1,200 tokens. A primeira chamada grava o documento no cache e as 39 seguintes o leem.
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
| Modelo | Com acertos de cache (PoYo) | Sem acertos de cache (PoYo) | Com acertos de cache (OpenAI) |
|---|---|---|---|
| Sol | $1.427 (285.4 créditos) | $13.20 | $1.784 |
| Astra | $5.709 (1,141.8 créditos) | $52.81 | $7.136 |
Os acertos de cache reduzem o custo dessa carga de trabalho em cerca de 89%. Mantenha o documento primeiro e a pergunta por último para que o prefixo continue idêntico.
GPT-6.2 API vs modelos GPT-6 anteriores na PoYo
Preços de tabela da PoYo por 1M de tokens:
| ID do modelo | Entrada | Saída | Leitura de cache | Escrita de cache | Exemplo 2 | Exemplo 4 (com 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 |
O GPT-6.2 Astra é 20% mais barato que o GPT-6 Astra em entrada, saída e escrita de cache, e 60% mais barato em leitura de cache. O GPT-6.2 Sol custa o mesmo que o GPT-6.1 Sol e corta pela metade o preço de leitura de cache do GPT-6 Sol. Como as contagens de tokens são as mesmas em cada modelo, isto é uma comparação de preço, não uma afirmação sobre custo por tarefa. Os passos de migração estão em GPT-6.2 API vs GPT-6.1 Sol API, e o panorama entre fornecedores em Preço da Claude API e Gemini 4 Carbon API vs Claude Opus 5.5 vs GPT-6 Astra.
Perguntas frequentes
Quanto custa a GPT-6.2 API por 1M de tokens?
Na PoYo: Astra $6.40 de entrada, $32 de saída, $0.32 de leitura de cache e $8 de escrita de cache; Sol $1.60, $8, $0.08 e $2. As tarifas padrão da OpenAI são $8 / $40 / $0.40 / $10 e $2 / $10 / $0.10 / $2.50.
Os tokens de raciocínio da GPT-6.2 API são cobrados?
Sim. A OpenAI cobra os tokens de raciocínio como tokens de saída. Eles ficam ocultos na resposta, mas são contados em usage.output_tokens.
O GPT-6.2 Sol é mais barato que o GPT-6.1 Sol?
Não, os preços por token são idênticos na PoYo e na OpenAI. O GPT-6.2 Sol é mais barato que o GPT-6 Sol nas leituras de cache ($0.08 contra $0.16 por 1M na PoYo).
Quanto a GPT-6.2 Sol API é mais barata que a GPT-6.2 Astra API?
O Sol custa um quarto do Astra em todos os medidores. Se uma tarefa vai custar um quarto depende de quantos tokens cada modelo gasta nela, então meça os dois com os seus próprios prompts.
Quanto a OpenAI cobra por prompts do GPT-6.2 acima de 272K tokens?
A OpenAI dobra as tarifas de entrada e de cache e cobra 1.5× a saída para a requisição inteira: Astra $16 / $60 e Sol $4 / $15 por 1M de tokens de entrada/saída.