GPT-6.2 Astra vs Sol: preço, velocidade e custo por tarefa
Três tarefas de código idênticas, dois modelos, uma API: até onde vai o mais barato e o que o modelo principal acrescenta no trabalho difícil.
Nesta página
- GPT-6.2 Astra vs Sol: o que muda entre eles?
- Quanto custa uma requisição nas tarifas da OpenAI?
- O que aconteceu nas nossas três tarefas pequenas de código?
- Prompt 1: últimos eventos
- Prompt 2: união de intervalos
- Prompt 3: reembolsos em SQL
- Onde os testes independentes mostram diferença?
- Qual esforço de raciocínio usar?
- Qual modelo usar no código do dia a dia?
- Como testar os dois pela mesma API?
- Perguntas frequentes
- O GPT-6.2 Sol é bom o suficiente para programar?
- Quanto mais barato é o GPT-6.2 Sol que o Astra?
- Qual nível de esforço usar no GPT-6.2?
- Algum dos dois aceita imagens ou chama ferramentas?
- Fontes consultadas
- Histórico de atualizações
A comparação GPT-6.2 Astra vs Sol começa pelo preço: o Astra cobra $8 por milhão de tokens de entrada e $40 por milhão de saída, quatro vezes os $2 e $10 do Sol. Nas três tarefas pequenas de código que rodamos em 19 nov 2026, os dois passaram em todas as verificações; com as tarifas Standard da OpenAI, o Sol custou cerca de um quarto.
O Sol é o modelo para começar em trabalho curto e bem especificado. O argumento do Astra são as tarefas mais difíceis e abertas: nos testes independentes de código ele fica à frente com o mesmo rótulo medium, 2.5 pontos no Terminal-Bench 4.0 e 5.2 no FrontierCode. O ganho depende de esses pontos eliminarem retrabalho, então teste as tarefas complexas em que o Sol erra antes de pagar pelo Astra.
GPT-6.2 Sol
Passou nas três tarefas pequenas com cerca de um quarto do custo do Astra nas tarifas Standard da OpenAI. $2 de entrada e $10 de saída por milhão de tokens.
GPT-6.2 Astra
À frente em testes independentes de código com o mesmo rótulo medium. $8 de entrada e $40 de saída por milhão de tokens.
GPT-6.2 Astra vs Sol: o que muda entre eles?
A página do Astra, a página do Sol e a página de preços da OpenAI listam a mesma janela de contexto, o mesmo limite de saída, os mesmos níveis de raciocínio e os mesmos limites de requisições. O que muda de fato é o ID do modelo, o preço por token e a data de corte do conhecimento.
| Item | Astra | Sol |
|---|---|---|
| ID do modelo | gpt-6.2-astra | gpt-6.2-sol |
| Lançamento | 17 nov 2026 | 17 nov 2026 |
| Janela de contexto | 1,050,000 tokens | 1,050,000 tokens |
| Entrada máxima | 922,000 tokens | 922,000 tokens |
| Saída máxima | 128,000 tokens | 128,000 tokens |
| Corte do conhecimento | 18 mai 2026 | 1 jun 2026 |
| Níveis de raciocínio | low a max | low a max |
| Entrada | $8 | $2 |
| Entrada em cache | $0.40 | $0.10 |
| Escrita de cache, 30 min | $10 | $2.50 |
| Saída | $40 | $10 |
| Saída acima de 272K de entrada | $60 | $15 |
As tarifas Standard do Astra são exatamente o quádruplo das do Sol em todas as linhas, incluindo escrita de cache e as linhas de contexto longo.
Os dois modelos saíram na mesma entrada do changelog de 17 nov 2026. O anúncio de lançamento da OpenAI diz que usuários Plus, Pro, Enterprise e Edu têm os dois no ChatGPT Work e no Codex; em workspaces Enterprise e Edu, um administrador precisa ativá-los. Na API, os dois IDs rodam nos mesmos endpoints, e nos planos Pro o Pro 200 começa com o Sol enquanto o Pro 500 pode usar os dois.
Dois detalhes passam fácil. Os dois endpoints, Responses e Chat Completions, funcionam com os dois IDs; chamadas de ferramentas exigem a API Responses. Os dois modelos recebem texto e imagens como entrada e devolvem texto, então nenhum gera áudio ou vídeo. Os limites de requisições também batem em cada faixa, de 5,000 requisições e 1 milhão de tokens por minuto no Build até 15,000 e 40 milhões no Grow.
Cada modelo tem ainda seu próprio texto: os detalhes de lançamento do GPT-6.2 Astra e o resumo do GPT-6.2 Sol.
Quanto custa uma requisição nas tarifas da OpenAI?
$0.16 no Astra e $0.04 no Sol para um prompt de 10,000 tokens e 2,000 tokens de saída, com as tarifas Standard da OpenAI.
A conta do Astra: 10,000 × $8 ÷ 1,000,000 = $0.08 de entrada e 2,000 × $40 ÷ 1,000,000 = $0.08 de saída. A do Sol: 10,000 × $2 ÷ 1,000,000 = $0.02 mais 2,000 × $10 ÷ 1,000,000 = $0.02. Cem requisições desse formato custam $16 no Astra e $4 no Sol.
Tokens de raciocínio contam como tokens de saída e não têm linha de preço separada, então subir o esforço encarece a chamada porque ela escreve mais saída, e não porque muda o medidor. Prompts longos mantêm a mesma diferença. Acima de 272,000 tokens de entrada, a OpenAI dobra as tarifas de entrada e de cache e cobra 1.5 vez a tarifa de saída de contexto curto pela requisição inteira. Com 300,000 tokens de entrada e 2,000 de saída, o Astra paga 300,000 × $16 ÷ 1,000,000 = $4.80 mais 2,000 × $60 ÷ 1,000,000 = $0.12, ou $4.92. O Sol paga $1.20 mais $0.03, ou $1.23. O Sol custa exatamente um quarto. O processamento em lote corta pela metade as tarifas dos dois modelos, então a diferença continua lá.
O que aconteceu nas nossas três tarefas pequenas de código?
Os dois modelos passaram em todas as verificações das três tarefas. O Astra foi mais rápido nas duas tarefas de Python; o Sol foi mais rápido na de SQL.
Enviamos cada prompt uma vez para cada modelo pelo endpoint Responses da OmniaKey em 19 nov 2026, com raciocínio medium, limite de 4,096 tokens de saída, streaming e sem ferramentas. Alternamos qual modelo ia primeiro e não fizemos novas tentativas, num total de seis chamadas. A OmniaKey vende acesso aos dois modelos e os testes rodaram por ela. Todo dólar nesta seção é recalculado a partir dos tokens informados nas tarifas Standard da OpenAI, e não de uma fatura da OmniaKey.
As tarefas eram um seletor de último evento, uma união de intervalos e uma consulta de reembolsos. Cada uma rodou contra casos fixos e mais 100 casos pseudoaleatórios determinísticos com semente 20261119: 104 casos de último evento, 106 de intervalos e 102 de SQL. Esses números são casos de teste, não execuções separadas do modelo. Comportamento esperado: um evento escolhido por ID, minutos de intervalo sem contagem dupla e reembolsos descontados uma vez por pagamento.
Os três prompts, exatamente como enviados:
Prompt 1: últimos eventos
Return ONLY Python 3 code defining total_paid(events). Do not import modules or print. Each event is a dict with id (string), version (integer), status (string) and cents (integer). Select the event with the largest version per id; when versions tie, the later item in the input wins. Return the sum of cents only for selected events whose status is "paid". Input may be empty. Do not mutate the list or its dicts. The algorithm must run in O(n) time and support negative cents. Example: [{"id":"a","version":2,"status":"paid","cents":50},{"id":"a","version":1,"status":"paid","cents":200},{"id":"b","version":1,"status":"void","cents":20}] returns 50. Do not include tests or explanations.
Prompt 2: união de intervalos
Return ONLY Python 3 code defining union_minutes(intervals). Do not import modules or print. intervals is a list of two-integer [start,end] pairs representing half-open ranges in minutes, with start <= end. Values can be negative and pairs can be unsorted. Return the total length of their union. Adjacent, overlapping, nested and duplicate intervals must not be double-counted. Zero-length ranges add nothing. Empty input returns 0. Do not mutate the list or any pair. Use O(n log n) time and O(n) extra space or better. Example: [[5,10],[1,6],[10,12],[3,3]] returns 11. Do not include tests or explanations.
Prompt 3: reembolsos em SQL
Return ONLY one SQLite SELECT query, optionally with WITH common table expressions. No explanation or Markdown. Tables: payments(id INTEGER PRIMARY KEY, customer_id INTEGER NOT NULL, amount_cents INTEGER NOT NULL, status TEXT NOT NULL); refunds(id INTEGER PRIMARY KEY, payment_id INTEGER NOT NULL, amount_cents INTEGER NOT NULL, status TEXT NOT NULL). Return customer_id, net_cents for each customer with at least one payment whose status is 'paid', including customers whose net is zero or negative. net_cents is the sum of their paid payment amounts minus only refunds with status 'succeeded' attached to those paid payments. Exclude unpaid payments and refunds on them. A payment can have zero or multiple refunds. Do not multiply payment amounts when joining refunds. Sort by customer_id ascending. Use only these two tables.
| Tarefa | Astra | Sol |
|---|---|---|
| Último evento por ID | 104/104, 4.2 s | 104/104, 5.0 s |
| União de intervalos | 106/106, 4.4 s | 106/106, 6.5 s |
| Reembolsos em SQL | 102/102, 6.0 s | 102/102, 4.9 s |
| Total | 3 tarefas, 14.6 s | 3 tarefas, 16.4 s |
Os tokens por trás desses custos e o custo nas tarifas Standard oficiais:
| Tarefa | Entrada | Saída Astra | Saída Sol |
|---|---|---|---|
| Último evento por ID | 4,558 | 81 | 93 |
| União de intervalos | 4,532 | 81 | 149 |
| Reembolsos em SQL | 4,550 | 113 | 128 |
| Total | 13,640 | 275 | 370 |
| Tarefa | Astra | Sol |
|---|---|---|
| Último evento por ID | $0.0397 | $0.0100 |
| União de intervalos | $0.0395 | $0.0106 |
| Reembolsos em SQL | $0.0409 | $0.0104 |
| Três chamadas por modelo | $0.1201 | $0.0310 |
Cada requisição informou cerca de 4,380 tokens de instrução além do prompt visível, o mesmo nos dois modelos. Mantivemos os 13,640 tokens de entrada na conta em vez de estimar pelo tamanho do prompt. Não houve acertos nem escritas de cache. O Sol gastou 10, 47 e 13 tokens de raciocínio dentro dos totais de saída; o Astra não informou nenhum.
O código se comportou igual nos dois. Cada um guarda a maior versão por ID e resolve empate com o item posterior, nenhum altera a entrada, e os dois somam os reembolsos bem-sucedidos antes de juntar os pagamentos, para que vários reembolsos não multipliquem um pagamento.
São seis chamadas no total, então leia os tempos como uma observação de cada um, não como ranking de velocidade. As taxas de acerto mostram que os dois modelos terminam tarefas limitadas de um único turno; dizem pouco sobre uma sessão longa de agente com repositório, ferramentas e novas tentativas.
Onde os testes independentes mostram diferença?
A Artificial Analysis coloca o Astra à frente nos dois testes de código com o mesmo rótulo medium: 2.5 pontos no Terminal-Bench 4.0 e 5.2 pontos no FrontierCode.
| Medida | Astra | Sol |
|---|---|---|
| Intelligence Index | 57 | 53 |
| Terminal-Bench 4.0 | 58.6% | 56.1% |
| FrontierCode-AA2.0 | 46.6% | 41.4% |
| Tempo por tarefa | 4.5 min | 3.3 min |
| Custo por tarefa | $1.62 | $0.41 |
São os números atuais da comparação da Artificial Analysis, conferidos em 19 nov 2026. O Intelligence Index v5.0.1 cobre nove avaliações, com código valendo 25% da nota. A página é um retrato ao vivo e não traz uma data de execução separada, então trate os números como atuais e não como fixos. Ela rotula as linhas dos dois modelos como medium, que é o ajuste da OpenAI; o rótulo sozinho não mostra que os dois gastaram os mesmos tokens. Esses testes são tarefas longas de estilo agente, por isso uma tarefa custa dólares lá e centavos na nossa execução de um turno.
No esforço max, a mesma página dá 62 para o Astra e 57 para o Sol no índice, com 13.9 e 8.7 minutos por tarefa e $4.00 e $1.01 por tarefa. Astra em high e Sol em max chegam os dois a 60.1% no Terminal-Bench 4.0. A nota do Astra no FrontierCode é maior em xhigh (49.0%) do que em max (45.4%), então subir o ajuste não melhora todas as notas. Comparar o Astra em max com o Sol em low favoreceria o Astra; igualar os rótulos é a comparação mais limpa, ainda que o mesmo rótulo não signifique que os dois gastaram os mesmos tokens.
Qual esforço de raciocínio usar?
Comece com medium em qualquer um dos dois. É o ajuste por trás das notas independentes acima, e o guia de escolha de modelo da OpenAI recomenda o Sol em medium para a maioria dos fluxos com a API.
Os dois modelos aceitam low, medium, high, xhigh e max, e os dois recusam none. A OpenAI sugere começar uma integração nova em medium e usar low no lugar de none ou minimal. Ajustes mais altos costumam escrever mais tokens de saída e, nas execuções publicadas, levaram mais tempo em média, mas não elevam todas as notas. Os níveis altos são para tarefas que precisam de mais conferência, não para toda chamada.
A lista da OpenAI por tipo de tarefa é um bom padrão. Ela põe o Sol em medium para corrigir bugs e fazer features em código existente, o Sol em extra high para tarefas de várias etapas que pedem testes e revisão, e o Astra em extra high para problemas abertos que exigem pesar escolhas. Essas notas são estimativas, e o guia não dá números que as sustentem.
Qual modelo usar no código do dia a dia?
Comece com o Sol. Passe para o Astra quando suas tarefas difíceis falharem no Sol repetidamente, porque a vantagem independente do Astra é de poucos pontos enquanto o preço por token é quatro vezes o do Sol.
Em trabalho de rotina e bem especificado, como as três tarefas acima, o Sol empatou com o Astra verificação por verificação com cerca de um quarto do custo. Nos testes independentes, a vantagem do Astra com rótulo medium é de 2.5 pontos no Terminal-Bench 4.0 de 100 e de 5.2 pontos no FrontierCode.
Coloque o preço da diferença ao lado do trabalho que ela poupa. Com 10,000 tokens de entrada e 2,000 de saída, 100 chamadas ao Astra custam $12 mais do que 100 chamadas ao Sol. Compare isso com o que custa uma nova tentativa, uma passada de revisão ou uma resposta errada; só as suas tarefas podem dar número a isso.
Uma forma prática de medir: pegue 20 tarefas complexas recentes em que o Sol precisou de uma segunda passada, rode no Astra em high ou xhigh e compare o gasto extra com o trabalho que ele elimina. Se o Astra só muda respostas que você aceitaria de qualquer jeito, fique com o Sol.
Como testar os dois pela mesma API?
Aponte o SDK da OpenAI para a URL base da OmniaKey https://api.omniakey.com/v1, mantenha a chave em OMNIAKEY_API_KEY e troque uma única string para mudar de modelo. As duas famílias de endpoints funcionam com os dois IDs; use Responses se for chamar ferramentas.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["OMNIAKEY_API_KEY"],
base_url="https://api.omniakey.com/v1",
)
prompt = (
"Return ONLY Python 3 code defining union_minutes(intervals). Do not import "
"modules or print. intervals is a list of two-integer [start,end] pairs "
"representing half-open ranges in minutes, with start <= end. Values can be "
"negative and pairs can be unsorted. Return the total length of their union. "
"Adjacent, overlapping, nested and duplicate intervals must not be "
"double-counted. Zero-length ranges add nothing. Empty input returns 0. Do not "
"mutate the list or any pair. Use O(n log n) time and O(n) extra space or better. "
"Example: [[5,10],[1,6],[10,12],[3,3]] returns 11. Do not include tests or "
"explanations."
)
response = client.responses.create(
model="gpt-6.2-sol", # or "gpt-6.2-astra"
reasoning={"effort": "medium"},
max_output_tokens=4096,
input=prompt,
stream=True,
)
for event in response:
if event.type == "response.output_text.delta":
print(event.delta, end="")
Este é o formato de requisição que usamos nas três tarefas, com o prompt de união de intervalos acima inteiro. O bloco usage da resposta informa tokens de entrada e de saída, e o total de saída inclui os tokens de raciocínio.
Os dois endpoints funcionam com os dois IDs. Use Responses quando precisar de ferramentas; Chat Completions atende requisições sem elas. O antigo guia de configuração do GPT-6 Astra cobre o mesmo endpoint, o Codex e correções de erro; troque por gpt-6.2-astra ou gpt-6.2-sol onde o modelo é citado.
Os preços atuais da OmniaKey para os dois estão na página do modelo GPT-6.2 Astra e na página do modelo GPT-6.2 Sol.
Perguntas frequentes
O GPT-6.2 Sol é bom o suficiente para programar?
Nas nossas três tarefas pequenas ele empatou com o Astra verificação por verificação. A Artificial Analysis ainda põe o Astra 2.5 pontos à frente no Terminal-Bench 4.0 com o rótulo medium, então o Sol é um padrão sensato e o Astra, a proteção para trabalho mais difícil.
Quanto mais barato é o GPT-6.2 Sol que o Astra?
O Sol custa um quarto, ou 75% menos em cada tarifa Standard: $2 de entrada e $10 de saída por milhão de tokens contra $8 e $40. As nossas três tarefas ficaram entre 3.7 e 4.0 vezes de diferença, e 100 requisições de 10,000 de entrada e 2,000 de saída custam $4 contra $16.
Qual nível de esforço usar no GPT-6.2?
Medium em qualquer um dos dois. Os dois recusam none, e a OpenAI recomenda medium para uma integração nova. Suba para trabalho de várias etapas que precisa de testes e revisão. Ajustes altos não são automaticamente mais lentos nem melhores: a nota do Astra no FrontierCode é maior em xhigh do que em max.
Algum dos dois aceita imagens ou chama ferramentas?
Os dois aceitam texto e imagens e devolvem texto; áudio e vídeo não são suportados. Os dois endpoints funcionam, e chamadas de ferramentas exigem a API Responses.
Fontes consultadas
- OpenAI: apresentação do GPT-6.2 Astra e Sol (17 nov 2026)
- OpenAI: changelog da API (entrada de 17 nov 2026)
- OpenAI: página do modelo GPT-6.2 Astra
- OpenAI: página do modelo GPT-6.2 Sol
- OpenAI: preços da API
- OpenAI: guia de escolha de modelo
- OpenAI: guia do modelo mais recente
- Artificial Analysis: GPT-6.2 Astra vs GPT-6.2 Sol
- Artificial Analysis: metodologia do Intelligence Index
Preços e limites conferidos em 19 nov 2026.
Histórico de atualizações
- 19 nov 2026: primeira versão. Três tarefas rodadas na OmniaKey no mesmo dia; preços, limites e notas independentes conferidos nesse dia.
Modelos deste artigo
Artigos relacionados
GPT-6.2 Astra: data de lançamento, vazamentos e o confirmado
O GPT-6.2 Astra foi lançado em 17 de novembro de 2026. Veja os preços oficiais, o contexto de 1.050.000 tokens, as diferenças entre Codex e API e o que mudou em relação ao GPT-6 Astra.
GPT-6.2 Sol: data de lançamento, rumores e acesso à API
O GPT-6.2 Sol saiu. Aqui estão o ID exato do modelo, onde ele funciona, quanto custa uma requisição e o que muda em relação ao GPT-6.2 Astra e ao GPT-6.1 Sol.
Como usar GPT-6 Astra com a OmniaKey
Crie uma chave API, valide uma solicitação Responses e conecte Python, Node.js ou Codex.