Tokens, janela de contexto e saída: guia OpenAI

Limites de tokens, janela de contexto e saída são três conceitos relacionados, mas não equivalentes. Tokens são as unidades processadas pelo modelo; a janela de contexto é o orçamento total disponível em uma solicitação; e o limite de saída é o máximo que o modelo pode gerar dentro desse orçamento.

Em uma chamada à API, a janela precisa acomodar a entrada, o histórico incluído, as instruções, as ferramentas, a resposta e, nos modelos de raciocínio, os tokens internos usados para pensar. Por isso, um modelo com saída máxima de 128 mil tokens não consegue necessariamente gerar 128 mil tokens visíveis depois que você ocupa quase toda a janela com o prompt.

Janela de contexto é a capacidade total da solicitação. Saída máxima é apenas o teto da parte gerada pelo modelo.

Limites e documentação verificados em 11 de outubro de 2026. Consulte sempre a página do model ID usado, pois contexto, saída, preço, status e compatibilidade podem mudar.

A diferença entre token, contexto e saída

Conceito	O que limita	Exemplo de pergunta
Token	A unidade usada para representar texto e outros conteúdos processados	Quantos tokens este prompt consome?
Tokens de entrada	O conteúdo enviado ao modelo	Meu histórico, arquivo e ferramentas cabem?
Tokens de saída	O conteúdo gerado, inclusive partes não visíveis quando aplicável	Quanto a resposta consumiu?
Janela de contexto	O total que pode ser usado em uma solicitação	Entrada, resposta e raciocínio cabem juntos?
Saída máxima	O máximo que o modelo pode gerar	Qual é o maior teto possível para a resposta?
Rate limit	O volume de requisições ou tokens permitido por período	Quantos tokens por minuto posso enviar?
Limite de uso	A franquia da conta, do plano ou do workspace	Quantas mensagens ou créditos ainda tenho?

A documentação da OpenAI sobre como entender e contar tokens recomenda verificar separadamente a janela de contexto e a saída máxima na página de cada modelo.

O que é um token?

Um token é uma unidade numérica em que o modelo divide o conteúdo antes de processá-lo. Ele pode representar:

uma palavra inteira;
parte de uma palavra;
um sinal de pontuação;
um espaço combinado com caracteres próximos;
um fragmento de código;
uma unidade usada para representar outro tipo de entrada, conforme o modelo e a modalidade.

Um token não equivale a uma palavra. A mesma palavra pode ser dividida de formas diferentes dependendo do idioma, da grafia, do espaço que a antecede, da codificação e do modelo.

A OpenAI oferece estimativas aproximadas para textos em inglês, como cerca de quatro caracteres ou três quartos de uma palavra por token. Essas aproximações não devem ser usadas como regra para textos em português, código, JSON, tabelas ou conteúdos multimodais.

Português sempre usa mais tokens que inglês?

Não existe uma porcentagem universal. Algumas palavras e construções em português podem ser divididas em mais tokens, enquanto outras podem ter representação eficiente na codificação usada pelo modelo.

Para orçamento e validação técnica, conte o payload real. Não converta palavras em tokens usando um multiplicador fixo.

Quatro categorias de tokens que você precisa acompanhar

Categoria	O que inclui	Impacto
Entrada	Instruções, mensagens, histórico, exemplos, ferramentas, schemas, imagens e arquivos processados	Ocupa contexto e pode ser cobrada
Entrada em cache	Prefixo de entrada reaproveitado de uma solicitação compatível	Ocupa contexto, mas pode ter preço e latência menores
Saída visível	Texto, JSON ou chamada de ferramenta que sua aplicação recebe	Ocupa contexto e entra no uso de saída
Raciocínio e estrutura não visível	Tokens internos de raciocínio e, conforme o modelo, formatação ou delimitadores	Podem ocupar contexto e aumentar output_tokens sem aparecer no texto

A documentação de contagem de tokens alerta que o total de saída relatado pode ser maior que a quantidade de texto visível. Alguns modelos geram tokens para raciocínio, canais, chamadas de ferramenta ou estrutura da mensagem.

O que entra na janela de contexto?

Como modelo mental, pense na janela desta forma:

janela de contexto
≈ entrada
+ saída
+ raciocínio
+ estrutura necessária para processar a solicitação

Essa expressão ajuda a entender a capacidade, mas não substitui a contagem oficial. O modo exato de renderizar mensagens e ferramentas depende do endpoint e do modelo.

A entrada pode incluir mais do que o texto digitado

instruções da aplicação;
mensagens anteriores;
respostas anteriores do assistente;
resultados de funções e ferramentas;
descrições e schemas de ferramentas;
schemas de Structured Outputs;
imagens e arquivos;
partes internas usadas para representar os limites entre mensagens.

Por isso, contar somente os caracteres do texto do usuário pode subestimar bastante a entrada de um agente com dezenas de ferramentas.

Janela de contexto e saída máxima não se somam

Suponha um modelo hipotético com:

janela total de 100 mil tokens;
saída máxima nominal de 20 mil tokens;
entrada de 86 mil tokens.

O espaço bruto restante seria 14 mil tokens, não 20 mil. Se o modelo ainda usar tokens de raciocínio ou estrutura, o texto visível poderá ser menor.

saída potencial
≤ menor valor entre:

1. saída máxima do modelo;
2. contexto restante após entrada, raciocínio e estrutura.

Os valores do exemplo são fictícios. Use a página do modelo e a contagem da solicitação real para dimensionar uma aplicação.

Exemplos atuais de janelas e saídas na OpenAI API

Os números variam por model ID e por modalidade. Estes exemplos mostram por que não existe um único “limite da OpenAI”:

Modelo	Janela de contexto	Saída máxima	Observação
GPT-6 Astra	1.050.000 tokens	128.000 tokens	Modelo de raciocínio para trabalhos exigentes
GPT-6 Luna	1.050.000 tokens	128.000 tokens	Modelo eficiente para tarefas focadas e alto volume
GPT-Realtime-1.5	32.000 tokens	4.096 tokens	Modelo de áudio em tempo real

O catálogo atual de modelos da OpenAI é a fonte adequada para conferir contexto, saída, modalidades, ferramentas, preços, status e model ID.

Não use essa tabela como lista permanente. Um modelo pode ser atualizado, marcado como Legacy ou Deprecated, substituído ou removido.

Um milhão de tokens permite um milhão de entrada mais 128 mil de saída?

Não. Quando a página declara uma janela total de 1.050.000 tokens e uma saída máxima de 128.000, a entrada e a geração precisam respeitar a janela total. O limite de saída não é um bloco extra adicionado depois do contexto.

Uma entrada próxima de 1.050.000 tokens não deixa espaço suficiente para gerar uma resposta longa e pode nem ser aceita depois que instruções, ferramentas e overhead forem contabilizados.

Qual é a janela de contexto do ChatGPT?

Não existe um único número aplicável a todo o ChatGPT. O limite pode variar com:

plano;
modelo selecionado;
nível de raciocínio;
workspace;
ferramenta ou experiência usada;
fase de disponibilização.

As notas de versão do ChatGPT registraram, em 20 de fevereiro de 2026, uma janela total de 256 mil tokens para o modo Thinking selecionado manualmente, dividida em até 128 mil de entrada e até 128 mil de saída.

Esse registro não deve ser transformado em limite universal para todos os modelos atuais. A página de modelos atuais no ChatGPT orienta verificar plano, seletor de modelos, rollout e configurações do workspace.

Também não copie a janela de 1.050.000 tokens de um model ID da API e presuma que uma conversa no aplicativo oferece exatamente a mesma capacidade. Produto, modelo e API são camadas diferentes.

Por que a resposta pode terminar antes do limite?

Saída máxima é um teto, não uma meta. O modelo pode parar porque:

considerou a tarefa concluída;
gerou um token natural de encerramento;
atingiu max_output_tokens;
atingiu o espaço restante na janela de contexto;
consumiu parte da saída com raciocínio interno;
produziu uma chamada de ferramenta e aguarda o resultado;
encontrou uma restrição de segurança;
ocorreu timeout ou interrupção de rede;
a interface do produto aplicou outro limite.

Pedir “escreva o máximo possível” não obriga o modelo a consumir todo o teto. Para entregáveis longos, defina estrutura, seções, profundidade e critério de conclusão.

Reasoning tokens podem consumir a saída sem aparecer

Modelos de raciocínio podem gerar de centenas a dezenas de milhares de tokens internos antes ou durante a resposta. Esses tokens não são normalmente exibidos, mas podem ser registrados em output_tokens_details.reasoning_tokens.

Segundo o guia de modelos de raciocínio da OpenAI, eles ocupam espaço na janela e são cobrados como tokens de saída.

Se o limite de saída for baixo, o modelo pode atingir max_output_tokens durante o raciocínio e retornar uma resposta incompleta antes de produzir texto visível suficiente.

Como reservar espaço

Não preencha a janela inteira com entrada.
Defina uma margem para raciocínio e resposta.
Use o menor esforço de raciocínio que mantém a qualidade necessária.
Meça o consumo em exemplos representativos.
Ajuste o buffer segundo os dados reais de uso.

A documentação recomenda reservar inicialmente uma margem ampla para raciocínio e saída ao experimentar modelos dessa categoria. O valor adequado deve ser recalibrado para seu workload.

Como contar tokens antes da chamada à API

Existem três métodos, com níveis diferentes de precisão.

1. Estimativa por caracteres ou palavras

Serve para uma noção inicial, mas não para bloquear solicitações ou prever custos com precisão. O resultado varia por idioma, conteúdo, codificação e modelo.

2. tiktoken para texto simples

O tiktoken é a biblioteca oficial de tokenização da OpenAI. Ele é útil para texto simples quando você seleciona a codificação correta.

Uma contagem local pode não representar o payload completo quando a solicitação inclui:

imagens;
PDFs;
schemas de ferramentas;
Structured Outputs;
limites e papéis de mensagens;
formatação interna dependente do modelo.

3. Endpoint oficial de contagem da Responses API

O endpoint POST /v1/responses/input_tokens recebe o mesmo formato de entrada da Responses API e devolve a contagem exata que o modelo receberá para aquele payload.

Ele aceita mensagens, imagens, arquivos, ferramentas e conversas. A contagem inclui tokens estruturais que podem não aparecer no texto.

Exemplo em Python: contar, gerar e revisar o uso

O exemplo usa gpt-6-luna, um model ID atual voltado a tarefas focadas e de alto volume. Confirme o catálogo de modelos antes de copiar o código para produção.

import os
import sys

from openai import OpenAI

if not os.getenv("OPENAI_API_KEY"):
    raise SystemExit("Defina OPENAI_API_KEY no ambiente antes de executar.")

client = OpenAI()
model = "gpt-6-luna"

instructions = (
    "Responda em português do Brasil. "
    "Explique o conceito com precisão e sem acrescentar dados não fornecidos."
)

user_input = """
Explique a diferença entre janela de contexto e limite de saída
em até cinco parágrafos, com um exemplo numérico.
""".strip()

try:
    count = client.responses.input_tokens.count(
        model=model,
        instructions=instructions,
        input=user_input,
    )

    print(f"Tokens de entrada calculados: {count.input_tokens}")

    response = client.responses.create(
        model=model,
        instructions=instructions,
        input=user_input,
        reasoning={"effort": "low"},
        max_output_tokens=2_000,
        store=False,
    )

    print("\nResposta:\n")
    print(response.output_text)

    print("\nUso informado pela API:")
    print(response.usage)

    if response.status == "incomplete":
        print("\nA resposta ficou incompleta.")
        print(f"Detalhes: {response.incomplete_details}")

except Exception as exc:
    print(f"Falha na solicitação: {exc}", file=sys.stderr)
    raise SystemExit(1)

O código não foi executado neste artigo. Teste-o em um projeto separado e mantenha o SDK atualizado.

O que conferir no objeto usage

input_tokens: total de entrada processado;
input_tokens_details.cached_tokens: parte reaproveitada do cache;
input_tokens_details.cache_write_tokens: parte gravada no cache quando aplicável;
output_tokens: tudo o que o modelo gerou e contabilizou;
output_tokens_details.reasoning_tokens: parte usada no raciocínio interno;
total_tokens: total registrado na solicitação.

Os campos disponíveis podem depender do modelo, endpoint e versão do SDK.

O que acontece ao atingir max_output_tokens?

Na Responses API, a resposta pode retornar:

status: incomplete
incomplete_details.reason: max_output_tokens

Isso significa que o limite de geração foi atingido antes da conclusão. O consumo pode incluir input e reasoning tokens mesmo quando pouco texto ficou visível.

Não resolva o problema aumentando o limite indiscriminadamente. Primeiro verifique:

se o prompt pede conteúdo repetitivo;
se o input está ocupando quase toda a janela;
se o esforço de raciocínio é maior que o necessário;
se a tarefa deve ser dividida em etapas;
se você precisa preservar mais espaço para o texto visível;
se outro modelo é mais adequado.

max_output_tokens não controla somente o texto visível

A documentação atual informa que max_output_tokens limita todos os tokens gerados pelo modelo. Isso pode incluir:

texto visível;
raciocínio interno;
chamadas de ferramenta;
tokens estruturais não exibidos.

Se você precisa de 2.000 tokens de texto visível, definir exatamente max_output_tokens=2000 pode ser insuficiente. Deixe margem e meça o comportamento real.

Responses API e Chat Completions usam parâmetros diferentes

Endpoint	Entrada registrada	Saída registrada	Parâmetro de limite
Responses API	`input_tokens`	`output_tokens`	`max_output_tokens`
Chat Completions	`prompt_tokens`	`completion_tokens`	`max_completion_tokens` nos modelos compatíveis

Não reutilize automaticamente parâmetros de endpoints antigos. Confira a documentação do endpoint e do modelo escolhidos.

O histórico da conversa conta na janela?

Sim, quando o conteúdo anterior é incluído no contexto da nova geração. Uma conversa de várias etapas pode acumular:

mensagens do usuário;
respostas do assistente;
chamadas e resultados de ferramentas;
instruções;
arquivos ou trechos recuperados.

Usar previous_response_id simplifica o gerenciamento de estado, mas não cria contexto infinito. A documentação de estado de conversa orienta acompanhar a janela à medida que a thread cresce.

Como reduzir o histórico ativo

remova mensagens irrelevantes;
substitua resultados extensos por uma síntese verificável;
preserve decisões, restrições, IDs e fontes;
mantenha conhecimento permanente fora da thread;
recupere apenas os trechos necessários;
use compaction quando o modelo e o endpoint oferecerem suporte;
reinicie o contexto quando a tarefa mudar de objetivo.

Uma síntese também pode perder detalhes. Guarde os dados originais e valide fatos críticos depois da compactação.

O que acontece quando a entrada excede o contexto?

Na Responses API, a estratégia de truncamento pode ser configurada. A referência atual de criação de respostas descreve dois comportamentos:

disabled: comportamento padrão; a solicitação falha com erro 400 se ultrapassar a janela;
auto: itens do início da conversa podem ser removidos para caber no contexto.

O truncamento automático pode remover uma instrução antiga, uma decisão ou uma exceção importante. Em fluxos financeiros, jurídicos, médicos, operacionais ou de segurança, gerencie explicitamente o contexto em vez de depender de descarte silencioso.

Limite de arquivo não é janela de contexto

O ChatGPT aceita documentos e arquivos de texto com até 2 milhões de tokens por arquivo e até 512 MB para documentos e apresentações, segundo a página de envio de arquivos e áudio.

Isso não significa que 2 milhões de tokens serão colocados simultaneamente na janela ativa. O limite informa o que pode ser enviado, não quanto será incluído em cada geração.

Em um exemplo específico do ChatGPT Enterprise, a OpenAI documenta uma combinação de context stuffing e índice privado: parte do documento é colocada diretamente no contexto, enquanto o restante fica disponível para recuperação. Consulte o guia de otimização de uploads no ChatGPT Enterprise.

Esse comportamento é específico do produto descrito. Não presuma que todas as contas, Projects, GPTs ou chamadas da API usam exatamente o mesmo processo.

Como trabalhar com um documento maior que o contexto

Crie um inventário de capítulos, seções, anexos e tabelas.
Defina a pergunta antes de recuperar trechos.
Divida por unidade semântica, não apenas por caracteres.
Mantenha metadados como página, seção, data e versão.
Recupere trechos relevantes.
Peça uma resposta com referências rastreáveis.
Faça uma segunda busca por exceções e informações contrárias.
Registre o que não foi localizado.
Volte ao documento original antes de uma decisão importante.

Uma resposta coerente não prova que todo o arquivo foi lido ou que cada exceção foi recuperada.

Contexto longo ou RAG?

RAG, sigla para geração aumentada por recuperação, seleciona trechos de uma base antes de chamar o modelo. Ele pode reduzir custo e ruído quando o acervo é maior que a janela ou quando apenas uma parte é relevante.

Estratégia	Vantagem	Risco
Enviar tudo no contexto	O modelo recebe o material junto	Custo, latência, distração e limite
Chunking sequencial	Fácil de implementar	Pode separar regra e exceção
RAG ou File Search	Recupera apenas partes relevantes	Pode não encontrar uma passagem importante
Resumo hierárquico	Reduz o tamanho progressivamente	Pode acumular omissões
Abordagem híbrida	Combina resumo global e recuperação detalhada	Exige mais engenharia e avaliação

Uma janela maior não elimina automaticamente a necessidade de retrieval. O melhor desenho depende da pergunta, do tamanho da base, da atualização, da latência e do nível de cobertura exigido.

Prompt caching não aumenta a janela

O prompt caching reaproveita o cálculo de um prefixo idêntico ou compatível. Ele pode reduzir latência e preço de entrada, mas os tokens em cache continuam fazendo parte da entrada lógica.

Tokens em cache:

ocupam espaço na janela de contexto;
continuam contando nos limites de tokens por minuto;
podem ter tarifa diferente;
aparecem em usage.input_tokens_details.cached_tokens;
não garantem resposta idêntica;
não garantem um cache hit futuro.

O que pode reduzir o reaproveitamento

trocar o modelo;
alterar a ordem ou o schema das ferramentas;
mudar o Structured Output schema;
alterar o esforço de raciocínio;
mudar o prefixo estável;
compactar a conversa;
expirar a entrada de cache.

Meça cached_tokens, cache_write_tokens, latência e custo realizado. Não estime a economia somente pelo tamanho do prompt.

Structured Outputs e function calling consomem tokens?

Sim. Definições de ferramentas, descrições, parâmetros e JSON Schemas são parte do contexto renderizado da solicitação.

Um agente com dezenas de funções extensas pode gastar uma parcela importante da janela antes de receber a pergunta do usuário.

Como reduzir esse consumo

mantenha nomes e descrições claros, mas concisos;
evite exemplos repetidos em cada função;
carregue ferramentas somente quando necessário;
use tool search ou carregamento adiado quando compatível;
não duplique regras no prompt e em cada schema;
conte o payload completo antes de enviar.

Janela de contexto não é rate limit

Limite	Escopo	Falha típica	Solução comum
Context window	Uma solicitação	Erro 400 ou truncamento	Reduzir, resumir ou recuperar menos contexto
Max output	Uma geração	Status incomplete	Reservar espaço ou dividir a entrega
TPM	Tokens por minuto	Erro 429	Fila, backoff e redução de concorrência
RPM	Requisições por minuto	Erro 429	Agrupar tarefas ou controlar chamadas
Batch queue	Entrada pendente em lotes	Novo lote rejeitado	Aguardar processamento ou reduzir fila
Spend limit	Projeto ou organização	Solicitação bloqueada por orçamento	Revisar limite e autorização
Message allowance	Produto ChatGPT	Modelo temporariamente indisponível	Usar outra opção ou aguardar reset

O guia de rate limits da OpenAI API explica que RPM e TPM variam por modelo, projeto, organização e nível de uso.

Uma solicitação de 100 mil tokens pode caber na janela e falhar por TPM. Outra pode respeitar TPM e falhar porque uma única requisição excede o contexto.

Streaming aumenta o limite?

Não. Streaming muda a forma como a saída é entregue: você recebe eventos à medida que são gerados. Ele não aumenta a janela nem a saída máxima do modelo.

O streaming pode melhorar a experiência percebida e reduzir o tempo até o primeiro trecho, mas a solicitação continua sujeita aos mesmos limites de contexto, geração e taxa.

Como calcular o custo de tokens

Uma fórmula geral é:

custo =
entrada sem cache × tarifa de entrada
+ cache write × tarifa de escrita no cache
+ entrada em cache × tarifa de leitura do cache
+ saída × tarifa de saída
+ ferramentas ou unidades adicionais

Nem todos os modelos usam todas essas categorias. Consulte a página atual de preços da API e a página do model ID.

Nos modelos atuais de raciocínio, reasoning tokens entram no uso de saída. Algumas famílias também aplicam preço diferente quando a entrada ultrapassa um limite de contexto longo. Por exemplo, páginas atuais de modelos com janelas amplas informam tarifas maiores acima de determinado volume de entrada.

Não escolha o modelo apenas pelo preço por milhão de tokens. Meça:

quantidade de tentativas;
tamanho médio da entrada;
tokens de raciocínio;
tamanho da saída;
uso de ferramentas;
latência;
taxa de correção ou revisão;
qualidade final da tarefa.

Como evitar respostas cortadas

Conte a entrada completa.
Confirme a janela e a saída máxima do model ID.
Reserve espaço para raciocínio.
Defina max_output_tokens com margem.
Peça estrutura e tamanho explícitos.
Divida entregáveis longos em partes independentes.
Use estado externo para documentos e histórico.
Verifique response.status.
Inspecione incomplete_details.
Não concatene automaticamente partes sem revisar continuidade e duplicação.

Prompt para um texto longo em partes

Crie primeiro um plano completo para o documento.

Objetivo:
[objetivo]

Público:
[público]

Seções obrigatórias:
[seções]

Regras:
- não escreva o documento inteiro nesta etapa;
- identifique dependências entre seções;
- indique fatos e fontes necessários;
- estime quais seções precisam de mais espaço;
- não repita conteúdo.

Depois da aprovação, escreva uma seção por vez.
Em cada seção:
- preserve as decisões já aprovadas;
- não antecipe a seção seguinte;
- finalize com uma lista de fatos que precisam ser mantidos no contexto.

Esse método melhora o controle, mas exige uma fonte externa de verdade para preservar definições, referências e decisões entre as etapas.

Erros comuns e diagnóstico

Sintoma	Causa provável	Como verificar	Ação
Erro de contexto	Entrada maior que a janela	Conte o payload completo	Reduza ou divida o contexto
Resposta incompleta	Max output atingido	Veja status e incomplete_details	Aumente com margem ou divida a tarefa
Pouco texto e muitos output tokens	Raciocínio ou estrutura não visível	Leia output_tokens_details	Ajuste effort e limite
Erro 429	RPM, TPM ou quota	Leia headers e painel de limites	Backoff, fila ou redução de concorrência
Arquivo aceito, informação não encontrada	Trecho não entrou no contexto ou não foi recuperado	Peça página, seção e cobertura	Faça busca dirigida e confira o original
Cache abaixo do esperado	Prefixo ou configuração mudou	Compare cached_tokens e ferramentas	Estabilize o prefixo
Custo subiu após prompt maior	Mais entrada, long context ou retries	Compare usage por chamada	Reduza ruído e teste outro fluxo
Fatos antigos desapareceram	Truncamento ou resumo incompleto	Revise o estado enviado ao modelo	Preserve um registro externo

Janela maior significa resposta melhor?

Não necessariamente. Uma janela maior permite fornecer mais conteúdo, mas pode aumentar:

custo;
latência;
ruído;
risco de instruções conflitantes;
dificuldade de localizar exceções;
complexidade de avaliação.

Forneça o contexto necessário, não o máximo possível. Compare respostas com um conjunto representativo de tarefas antes de escolher um modelo apenas pelo maior número anunciado.

Checklist antes de enviar uma solicitação grande

O model ID está ativo e é adequado à tarefa?
A janela foi confirmada na página oficial?
A saída máxima foi confirmada?
O payload completo foi contado?
Ferramentas e schemas foram incluídos na contagem?
Existe margem para raciocínio?
O histórico contém mensagens desnecessárias?
Resultados de ferramentas podem ser resumidos?
O arquivo precisa entrar inteiro?
Retrieval seria mais eficiente?
O truncamento está explícito?
O sistema trata response.status incomplete?
Há retry seguro para 429?
O custo foi calculado com usage real?
Existe um teste de cobertura e qualidade?

Perguntas frequentes

Um token equivale a quantas palavras?

Não existe equivalência fixa. A relação varia por idioma, palavra, pontuação, codificação e modelo. Estimativas por palavras servem apenas para planejamento inicial.

A janela de contexto inclui a resposta?

Sim. Na OpenAI API, a janela total inclui a entrada, a saída e, nos modelos de raciocínio, os tokens internos aplicáveis.

O limite máximo de saída é adicional à janela?

Não. Ele é um teto interno à capacidade total. A saída real também depende do espaço que restou depois da entrada e do raciocínio.

Cached tokens ocupam contexto?

Sim. O cache reduz processamento, latência ou tarifa quando há reaproveitamento, mas não transforma o prefixo em contexto gratuito ou externo à janela.

Prompt caching aumenta a janela?

Não. Ele reaproveita o cálculo de uma entrada compatível. O limite de contexto do modelo permanece o mesmo.

O histórico é cobrado novamente?

Quando o histórico é incluído na nova solicitação, ele entra na contagem de entrada. Parte pode receber tarifa de cache quando houver um prefixo reutilizável, mas ainda aparece no consumo.

Streaming permite uma resposta maior?

Não. Streaming altera a entrega dos tokens, não o limite de contexto nem a saída máxima.

Structured Outputs e function calling gastam contexto?

Sim. Schemas, descrições, parâmetros, chamadas e resultados podem entrar no contexto e no uso de tokens.

Um arquivo de 2 milhões de tokens é lido inteiro?

O número é um limite de upload para documentos no ChatGPT, não uma garantia de que todo o arquivo será colocado simultaneamente no contexto ou recuperado em cada pergunta.

Qual modelo tem a maior janela?

Consulte o catálogo no momento da implementação. O maior número muda com novos modelos e não determina sozinho qual modelo é melhor para sua tarefa.

Como saber se a resposta foi cortada?

Na Responses API, verifique response.status e incomplete_details. Não deduza somente pelo último caractere do texto.

Aumentar max_output_tokens sempre resolve?

Não. O problema pode ser falta de espaço total, raciocínio excessivo, input redundante, timeout, ferramenta, rate limit ou divisão inadequada da tarefa.

Regra prática para escolher o limite

Comece pela saída que o produto realmente precisa, não pelo máximo permitido. Depois:

Conte a entrada completa.
Reserve margem para raciocínio e estrutura.
Defina um teto de saída coerente com o formato.
Execute exemplos representativos.
Meça uso, custo, latência e completude.
Ajuste o modelo ou o workflow com base nesses dados.

O objetivo não é maximizar tokens. É oferecer ao modelo contexto suficiente para concluir a tarefa com qualidade, previsibilidade e custo controlado.