Reasoning tokens no GPT-6 Astra: o que são e por que sua fatura cobra mais do que o texto recebido

Você pede um resumo, recebe umas 400 palavras de volta e a fatura marca milhares de tokens de saída

Cadê o resto do texto? 🤔

O resto do texto existe, só que você nunca vai ler ele

A OpenAI lançou o GPT-6 Astra em 03/09/2026 como seu modelo mais capaz, voltado a raciocínio complexo, código, uso de computador, pesquisa e criação de documentos, assumindo o topo da linha no lugar do GPT-5.6 Sol

E ele é um modelo de raciocínio, ou seja: antes de escrever a resposta que você lê, ele escreve pra si mesmo

Esse rascunho invisível é o que a gente chama de reasoning tokens, e é ele que aparece na sua conta

O que são reasoning tokens (e por que eles não aparecem na resposta)

Pensa em um dev sênior resolvendo um bug

Ele rabisca hipótese, descarta duas, testa uma terceira e só então te manda a mensagem no chat: "era o cache"

Formação Recomendada

Formação Claude Code

Domine Claude Code do absoluto zero até o avançado

• 114 aulas
• 4 projetos
• 9h 18min

Conhecer formação

O modelo faz igual

A cadeia de raciocínio é gerada token a token, exatamente como qualquer outro texto, mas a API não devolve essa cadeia bruta pra você

O que ela expõe são os reasoning summaries, uma versão condensada do processo de raciocínio

Invisível não é sinônimo de gratuito:

Essa é a parte que assusta a galera

Os tokens de raciocínio não são visíveis pela API, porém eles entram em output_tokens e são cobrados à taxa de tokens de saída do modelo

Mesma tarifa do texto que você recebeu, sem desconto por ser rascunho

E eles também ocupam a janela de contexto:

Outro detalhe que pega o povo desprevenido

Como o raciocínio é saída, ele entra no total da janela de contexto junto com todo o resto: a entrada mais a saída inteira, raciocínio incluído

No Astra a janela é de 1,0M de tokens, o que dá bastante folga, mas em conversa longa com raciocínio pesado essa conta anda mais rápido do que você imagina

Como ver quantos reasoning tokens sua requisição gastou

Antes de otimizar, medir

O número exato de reasoning tokens de cada resposta vem no objeto de uso da própria resposta, então não tem adivinhação aqui

1. Abra o objeto de resposta e olhe o campo de uso

É ali que mora a verdade da sua fatura:

usage.output_tokens                              # total de saída cobrado
usage.output_tokens_details.reasoning_tokens     # a parte que você nunca leu

O erro comum deste passo: assumir que output_tokens é o tamanho do texto que chegou pra você. Não é. Esse número é texto visível + raciocínio, tudo junto, tudo na tarifa de saída

2. Isole o texto visível

Subtraia reasoning_tokens do total de output_tokens

O que sobrar é, grosso modo, o que você de fato leu na tela

É nessa hora que cai a ficha de quem achava que estava pagando por parágrafo

3. Repita a leitura entre níveis de esforço

Rode a MESMA tarefa real (não um "oi, tudo bem") mudando só o nível de esforço e anote o reasoning_tokens de cada rodada

O erro comum deste passo: comparar prompts diferentes e achar que mediu alguma coisa. Se a tarefa muda, o número não diz nada

4. Guarde esses números por rota da sua aplicação

Um endpoint de classificação e um de análise de código não gastam igual, e tratar os dois com a mesma configuração é dinheiro jogado fora

Esse hábito de auditar consumo antes de reclamar do preço é o mesmo de quando você vai ver o gasto de tokens do Claude Code: sem o número na mão, é só achismo

Quanto custa cada token no GPT-6 Astra: tabela de preços

A tabela padrão do Astra é essa aqui:

E tem os modificadores, que são onde a conta vira outra coisa:

Repara no último: não é só o excedente que muda de preço, é a requisição completa que passa a ser tarifada assim

A Artificial Analysis calcula ainda uma taxa combinada (blended) de US$ 7,70 por 1M de tokens pro Astra, na proporção 7:2:1 entre cache hit, entrada e saída

Comparando com o GPT-5.6 Sol:

O Sol custava US$ 4 por 1M de entrada e US$ 20 por 1M de saída

O Astra pede US$ 10 e US$ 50

Ou seja: 2,5 vezes o preço do antecessor, na entrada e na saída

Trocar o nome do modelo na variável de ambiente e seguir a vida é o caminho mais rápido pra tomar um susto no fim do mês 😅

Como controlar o gasto com reasoning.effort e max_output_tokens

A boa notícia: a variável de raciocínio é sua pra controlar

São dois freios, e eles funcionam de jeitos bem diferentes

1. Escolha o nível em reasoning.effort

O Astra aceita cinco níveis:

reasoning.effort = "low" | "medium" | "high" | "xhigh" | "max"

Tome cuidado: o Astra não suporta o nível none. Se você veio de um fluxo que usava isso, precisa escolher outro

2. Comece no medium

A orientação oficial é usar o medium como ponto de partida equilibrado

É o default mental que eu usaria antes de sair otimizando no escuro

3. Desça pro low quando latência importa mais que profundidade

Esforço mais baixo favorece velocidade e menor uso de tokens

Autocomplete, classificação, roteamento, esse tipo de carga sensível a latência

4. Suba pro high ou xhigh só com ganho medido

A recomendação é subir quando mais raciocínio traz ganho medido de qualidade, não quando você acha que vai ficar melhor

E o max fica reservado pras tarefas mais difíceis, aquelas em que qualidade é prioridade e custo é detalhe

5. Defina max_output_tokens sabendo o que ele cobre

max_output_tokens = <o teto total que você aceita gerar>

Ele limita tudo que o modelo gera, ou seja, a saída inteira: o raciocínio, o texto visível que chega pra você e a formatação não visível

O erro comum deste passo: apertar demais esse limite pra "economizar". Se estourar, a resposta volta com status incomplete e incomplete_details.reason igual a max_output_tokens

Traduzindo: você pagou o raciocínio inteiro e não recebeu a resposta 🙃

6. Esqueça o tuning de amostragem

O Astra não suporta valores customizados de temperature nem de top_p, e também não suporta log probabilities

Então não dá pra tentar controlar verbosidade por esse lado, o jogo é esforço e teto de saída

Quanto cada nível de esforço rende: inteligência x tokens gastos

Aqui é onde a decisão fica fácil, porque tem número

No Artificial Analysis Intelligence Index, o Astra pontua assim por nível de esforço:

Se liga nisso

Sair do medium pro max multiplica o consumo por mais de 4 (de 9,8M pra 42M tokens) pra ganhar 2 pontos no índice

E lembra que cada um desses tokens de saída é cobrado a US$ 50,00 por 1M

Agora pensa no seu caso de uso: um agente que roda mil vezes por dia num fluxo repetitivo não precisa de max

Já uma migração de arquitetura, uma análise de bug cabeludo, um documento longo que vai pro cliente, aí sim vale pagar o raciocínio caro

O Astra é mais econômico que o Sol nisso:

Segundo a Artificial Analysis, o Astra usa cerca de 10% menos tokens de saída no esforço max em comparação ao GPT-5.6 Sol, definindo uma nova fronteira de Pareto entre Intelligence Index e Output Tokens per Task

E ele também controla melhor o tamanho da própria cadeia de pensamento: no teste CoT-Control, segue a restrição em 60,9% das vezes na faixa entre 750 e 1.250 tokens

Não é 100%, beleza? Mas é um modelo que obedece mais quando você pede pra pensar menos, e isso conta no bolso

Fatura maior do que o esperado: causas comuns e como prevenir

Quatro cenários que aparecem direto, com causa e prevenção

Sintoma 1: resposta curtinha, conta alta

Causa: o raciocínio foi contado como saída, na tarifa de saída, mesmo sem aparecer pra você

Prevenção: audite usage.output_tokens_details.reasoning_tokens nas suas rotas mais chamadas e baixe o reasoning.effort onde o ganho de qualidade não for medido

Sintoma 2: conversa multi-turno saindo caro demais

Causa: usando previous_response_id, todos os input tokens das respostas da cadeia são faturados como input tokens

A API descarta os reasoning items irrelevantes pro turno atual, mas a entrada acumulada continua sendo cobrada

Prevenção: encurtar a cadeia e aproveitar entrada cacheada, que sai a US$ 1,00 por 1M em vez dos US$ 10,00 da entrada normal

Sintoma 3: requisição gigante custando o dobro do previsto

Causa: o corte de 272 mil tokens de entrada. Passou disso, a tarifação muda pra requisição inteira: 2x nas taxas de entrada e de cache, 1,5x na taxa de saída

Prevenção: saber onde está esse limite antes de jogar o repositório inteiro no prompt. Já vi gente descobrir isso pela fatura, e não é uma experiência agradável

Sintoma 4: resposta truncada e ainda assim cobrada

Causa: max_output_tokens estourado, com incomplete_details.reason apontando exatamente isso

Prevenção: dimensionar o teto contando o raciocínio junto, não só o tamanho do texto que você espera ler

Bônus: reaproveitar raciocínio em fluxo sem estado

Cada reasoning item vem com encrypted_content por padrão quando você cria uma resposta

Esse conteúdo criptografado pode ser reenviado em requisições futuras como um reasoning item normal

Ou seja: dá pra manter o benefício do raciocínio anterior mesmo em arquitetura stateless, sem depender de guardar a conversa toda

O que isso muda no seu bolso agora

O Astra estreia com liberação escalonada, começando pelas empresas do Trusted Access Program

O acesso via API e nos planos Plus, Pro, Business e Enterprise foi anunciado pros dias seguintes

Então a maior parte da galera ainda tem alguns dias pra fazer o dever de casa antes de plugar em produção

E o dever de casa é esse: refazer a projeção de custo ANTES de trocar o nome do modelo

A tarifa é 2,5 vezes a do GPT-5.6 Sol, e o raciocínio é uma variável que você controla, não uma taxa fixa que caiu do céu

Quem migrar no piloto automático mantendo o mesmo nível de esforço de antes vai pagar caro por profundidade que talvez nem precisasse

Conclusão

Recapitulando o essencial: reasoning token é token de saída, cobrado na tarifa de saída do GPT-6 Astra (US$ 50,00 por 1M), invisível na resposta mas visível no objeto de uso, em usage.output_tokens_details.reasoning_tokens

E você tem dois freios na mão: reasoning.effort, com os cinco níveis que o Astra aceita, e max_output_tokens, que cobre a saída inteira, do raciocínio ao texto visível e à formatação

O próximo passo prático é simples: pega uma tarefa real do seu sistema, roda em medium e em high, compara reasoning_tokens e qualidade do resultado

Só sobe o esforço se o ganho for medido, nunca por sensação de que "deve ficar melhor"

A parte cara do modelo é justamente a que ninguém vê, então bora medir antes de pagar… 😀

até o próximo post!