
Os preços da GPT-6.2 API no PoYo são $6.40 de entrada e $32 de saída por 1M de tokens para gpt-6.2-astra, e $1.60 de entrada e $8 de saída para gpt-6.2-sol. Ambos ficam 20% abaixo das tarifas standard da OpenAI, incluindo as leituras e escritas de cache. Este artigo põe as tabelas de preços lado a lado, explica o que cobre cada medidor e calcula o custo de quatro formatos de pedido realistas. As tarifas atuais do PoYo estão sempre nas páginas dos modelos GPT-6.2 Astra e GPT-6.2 Sol.
Os preços do PoYo abaixo são os indicados a 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, ambas consultadas 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 na cache | $8.00 | $10.00 | $10.00 | $2.00 | $2.50 | $2.50 |
Em créditos 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 ambos os modelos às tarifas standard da OpenAI.
Por token, o Astra custa exatamente quatro vezes mais do que o Sol em todos os medidores.
Contexto longo e outros níveis da OpenAI
A página de preços da OpenAI separa o contexto curto (≤272K tokens de entrada) do contexto longo (>272K). Acima de 272K, "as tarifas de entrada e de cache duplicam e a saída custa 1.5 vezes a tarifa de contexto curto para todo o pedido":
| OpenAI standard, 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 na cache (30 min) | $10.00 | $20.00 | $2.50 | $5.00 |
A OpenAI lista também o Batch a 50% do preço standard, janelas em segundo plano (background) com 30–40% de desconto, e Fast e Ultrafast a um múltiplo do standard. São níveis do lado da OpenAI. Os preços do PoYo neste artigo são para os endpoints síncronos /v1/responses e /v1/chat/completions. Todos os exemplos calculados abaixo mantêm cada pedido em 272K tokens de entrada ou menos.
O que é e o que não é faturado
| Item | Como é faturado | Fonte |
|---|---|---|
| Tokens do prompt (texto e imagem) | Tarifa de entrada | Tabela de preços do PoYo |
| Tokens visíveis da resposta | Tarifa de saída | Tabela de preços do 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 da cache | Tarifa de leitura de cache, 0.05× a entrada no GPT-6.2 | Guia de caching da OpenAI, tabela de preços do PoYo |
| Tokens do prompt escritos na cache | Tarifa de escrita na cache, 1.25× a entrada para a retenção predefinida de 30 minutos | Guia de caching da OpenAI, tabela de preços do PoYo |
| Batch, background, Fast, Ultrafast | Níveis da OpenAI, não fazem parte destes endpoints do PoYo | Página de preços da OpenAI |
O GPT-6.2 reduz para metade o rácio de leitura de cache em relação ao GPT-6 Astra e ao GPT-6 Sol (0.05× vs 0.1× da entrada), por isso um prefixo estável vale mais do que antes. O guia de caching da OpenAI fixa o prefixo mínimo que pode ir para a cache em 1,024 tokens de entrada visíveis.
Exemplos de custo calculados para a GPT-6.2 API
Substitui as contagens de tokens pelas tuas. As contagens de saída incluem os tokens de raciocínio.
1. Resposta de chat: 3K de entrada, 800 de saída
| Modelo | Cálculo (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 através do PoYo, contra $140 e $560 ao preço de tabela da OpenAI.
2. Revisão de código: 150K de entrada, 12K de saída
| Modelo | Cálculo (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 um contexto crescente
Um agente começa com um prefixo de 40,000 tokens (mensagem developer, definições de ferramentas, tarefa). Cada turno acrescenta 4,000 tokens de resultados de ferramentas e de output anterior, e o modelo escreve 1,500 tokens de saída por turno. O último turno envia 136,000 tokens de entrada, abaixo da linha dos 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 no PoYo | Astra no PoYo | Sol na OpenAI | Astra na OpenAI |
|---|---|---|---|---|
| Sem acertos na 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. As execuções reais ficam entre as duas linhas, porque um acerto na cache não é garantido. Nas duas linhas a entrada domina, por isso um prefixo estável poupa mais do que cortar na saída. Os padrões para agentes estão em GPT-6.2 API para agentes de programação.
4. Q&A sobre um documento com cache: documento de 200K, 40 perguntas
Um conjunto de contratos com 200,000 tokens é o prefixo fixo; cada uma das 40 perguntas acrescenta 300 tokens e recebe uma resposta de 1,200 tokens. A primeira chamada escreve o documento na cache e as 39 seguintes leem-no.
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 na cache (PoYo) | Sem acertos na cache (PoYo) | Com acertos na 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 na cache reduzem o custo desta carga de trabalho em cerca de 89%. Mantém o documento primeiro e a pergunta no fim, para que o prefixo se mantenha idêntico.
GPT-6.2 API vs modelos GPT-6 anteriores no PoYo
Preços de tabela do PoYo por 1M de tokens:
| ID do modelo | Entrada | Saída | Leitura de cache | Escrita na 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 do que o GPT-6 Astra em entrada, saída e escrita na cache, e 60% mais barato na leitura de cache. O GPT-6.2 Sol custa o mesmo que o GPT-6.1 Sol e reduz para metade o preço de leitura de cache do GPT-6 Sol. Usar as mesmas contagens de tokens em todos os modelos faz disto uma comparação de preços, não uma afirmação sobre o custo por tarefa. Os passos de migração estão em GPT-6.2 API vs GPT-6.1 Sol API, e a comparação com outros fornecedores em preços da API do Claude 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?
No PoYo: Astra $6.40 de entrada, $32 de saída, $0.32 de leitura de cache e $8 de escrita na cache; Sol $1.60, $8, $0.08 e $2. As tarifas standard 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 faturados?
Sim. A OpenAI fatura os tokens de raciocínio como tokens de saída. Ficam ocultos na resposta, mas são contados em usage.output_tokens.
O GPT-6.2 Sol é mais barato do que o GPT-6.1 Sol?
Não, os preços por token são idênticos no PoYo e na OpenAI. O GPT-6.2 Sol é mais barato do que o GPT-6 Sol nas leituras de cache ($0.08 vs $0.16 por 1M no PoYo).
Quão mais barata é a GPT-6.2 Sol API do que a GPT-6.2 Astra API?
O Sol custa um quarto do Astra em todos os medidores. Se uma tarefa custa um quarto depende de quantos tokens cada modelo gasta nela, por isso mede os dois com os teus próprios prompts.
Quanto cobra a OpenAI por prompts do GPT-6.2 acima de 272K tokens?
A OpenAI duplica as tarifas de entrada e de cache e cobra 1.5× a saída para todo o pedido: Astra $16 / $60 e Sol $4 / $15 por 1M de tokens de entrada/saída.