> ## Documentation Index > Fetch the complete documentation index at: https://docs.aihubmix.com/llms.txt > Use this file to discover all available pages before exploring further. # Série GPT-5.6: o que muda na cobrança do cache de prompts > Julho de 2026: gpt-5.6-sol / gpt-5.6-terra / gpt-5.6-luna na AIHubMix, escrita de cache a 1.25x, prompt_cache_key, breakpoints e comparação com o Claude. Ilustração dos três níveis da série GPT-5.6 — Sol, Terra e Luna — e do mecanismo de cache de prompts A OpenAI lançou oficialmente a série GPT-5.6 em 9 de julho de 2026. A AIHubMix concluiu a integração dos três níveis de modelo: `gpt-5.6-sol`, `gpt-5.6-terra` e `gpt-5.6-luna` já podem ser chamados via Chat Completions e Responses. Este lançamento também ajusta o mecanismo e a cobrança do cache de prompts — a escrita de cache passa a ser cobrada separadamente. Este artigo apresenta o posicionamento dos três níveis e analisa cada mudança no cache. ## O que muda nos três níveis do GPT-5.6 O GPT-5.6 ajusta o sistema de nomenclatura: o número representa a geração do modelo, e Sol, Terra e Luna são níveis de capacidade que evoluem de forma independente. A definição oficial: Sol é o modelo flagship, Terra é o nível de preço reduzido com desempenho equivalente ao GPT-5.5, e Luna é o nível mais rápido e de menor preço. | | gpt-5.6-sol | gpt-5.6-terra | gpt-5.6-luna | | :----------------------------------- | :------------------------------------------- | :------------------------------------ | :---------------------------- | | Posicionamento oficial | Flagship para trabalho profissional complexo | Equilíbrio entre inteligência e custo | Para cargas sensíveis a custo | | Janela de contexto | 1.050.000 | 1.050.000 | 1.050.000 | | Saída máxima | 128.000 | 128.000 | 128.000 | | Corte de conhecimento | 2026-02-16 | 2026-02-16 | 2026-02-16 | | Nível aproximado na geração anterior | Sem sufixo | mini | nano | Sobre as capacidades, a posição oficial: o Sol alcança resultados state-of-the-art em programação, trabalho de conhecimento, cibersegurança e tarefas científicas; a OpenAI o descreve como seu melhor modelo de código até hoje, com novos recordes em Terminal-Bench 2.1 e DeepSWE; o Terra tem desempenho equivalente ao GPT-5.5 pela metade do preço. A série adiciona o nível de raciocínio max, e a Responses API ganha Programmatic Tool Calling e capacidades multi-agent (Beta). ## Análise da atualização do mecanismo de cache Antes do GPT-5.6, o cache de prompts da série GPT era totalmente automático: prefixos a partir de 1.024 tokens eram cacheados automaticamente, o desenvolvedor tinha controle sobre o que era cacheado ou por quanto tempo, e o cache era limpo após 5–10 minutos de inatividade. A OpenAI resume as mudanças do GPT-5.6 como "more predictable prompt caching" (cache de prompts mais previsível), em três pontos: 1. **A retenção passa de "mínimo de 5 minutos" para "mínimo de 30 minutos"**. `prompt_cache_options.ttl` atualmente aceita apenas `"30m"`; essa é a duração garantida, e na prática a retenção pode ser maior. 2. **Novos pontos de quebra de cache explícitos**. Definir `prompt_cache_breakpoint` em um bloco de conteúdo fixa a fronteira do cache no fim do conteúdo estável; alterações no conteúdo posterior ao ponto de quebra não invalidam o cache do prefixo anterior; com `prompt_cache_options.mode` em `"explicit"`, apenas os pontos de quebra manuais são usados. 3. **`prompt_cache_key` passa de otimização a requisito oficial**. A partir do GPT-5.6, o parâmetro deve ser definido para habilitar a correspondência de cache mais confiável; a recomendação oficial é manter o tráfego de cada key em torno de 15 requisições/minuto. ## Como avaliar a cobrança de escrita de cache a 1.25x A partir do GPT-5.6, a escrita de cache é cobrada a 1.25x o preço base de entrada e a leitura a 0.1x; nos modelos anteriores, a escrita de cache não tinha cobrança adicional. Texto oficial (do [anúncio de lançamento do GPT-5.6](https://openai.com/index/gpt-5-6/)): "For GPT-5.6 and later models, cache writes are billed at 1.25x the model's uncached input rate, while cache reads continue to receive the 90% cached-input discount." Calculando diretamente com os multiplicadores oficiais: escrever um prefixo custa 0.25x o preço de entrada a mais do que não usar cache; a partir daí, cada acerto economiza 0.9x o preço de entrada — **basta o prefixo ser reutilizado 1 vez para haver economia líquida**, e quanto mais reutilizações, maior a economia. * **Cargas com benefício claro**: workflows de agentes com prompts de sistema longos, RAG que cita repetidamente material de referência longo, aplicações com muitas definições de ferramentas e conversas de múltiplos turnos que apenas acrescentam mensagens ao final. Nessas cargas, a taxa de reutilização do prefixo é alta e o preço de leitura de 0.1x predomina. * **Cargas que exigem atenção**: requisições longas de uso único cujo prefixo não será reutilizado. O cache automático fica ativado por padrão e essas requisições geram uma taxa de escrita de 1.25x que não é recuperada; defina `prompt_cache_options.mode` como `"explicit"` sem pontos de quebra, e a requisição não usa cache nem gera taxa de escrita. ## Comparação: cache de prompts do GPT-5.6 e do Claude O design de cache do GPT-5.6 converge com o `cache_control` do Claude em várias dimensões; a diferença central está no comportamento padrão: o GPT faz cache automaticamente sem nenhum parâmetro; o Claude exige a habilitação do cache na requisição — campo `cache_control` de nível superior (ponto de quebra automático) ou ponto de quebra explícito em nível de bloco de conteúdo. | Dimensão | Série GPT-5.6 | Série Claude (todos os modelos ativos) | | :--------------------------- | :----------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------- | | Ativação | Cache automático, ponto de quebra explícito opcional | Requer habilitação: `cache_control` de nível superior (ponto de quebra automático) ou ponto de quebra explícito em nível de bloco | | Parâmetro de ponto de quebra | `prompt_cache_breakpoint` (nível de bloco de conteúdo) | `cache_control` (nível superior ou de bloco de conteúdo) | | Limite de pontos de quebra | Máximo de 4 novas escritas por requisição | Máximo de 4 pontos de quebra | | Retenção do cache | Mínimo de 30 minutos | 5 minutos por padrão (refresh gratuito a cada acerto), opção de 1 hora | | Cobrança de escrita de cache | 1.25x o preço de entrada | 1.25x na faixa de 5 minutos, 2x na de 1 hora | | Cobrança de leitura de cache | 0.1x o preço de entrada | 0.1x o preço de entrada | | Comprimento mínimo de cache | 1.024 tokens | 512–4.096 tokens conforme o modelo | | Requisito de acerto | Idêntico byte a byte antes do ponto de quebra | Idêntico byte a byte antes do ponto de quebra | A coluna do Claude na tabela vale para todos os modelos Claude ativos: escrita a 1.25x na faixa de 5 minutos, 2x na de 1 hora e leitura a 0.1x são uniformes em toda a linha ([documentação de cache de prompts da Anthropic](https://platform.claude.com/docs/en/docs/build-with-claude/prompt-caching)); as diferenças entre modelos ficam apenas no comprimento mínimo de cache. A fonte da coluna GPT-5.6 é o [guia de cache de prompts da OpenAI](https://developers.openai.com/api/docs/guides/prompt-caching). O limite de pontos de quebra, o multiplicador de escrita (na faixa correspondente) e o multiplicador de leitura são idênticos nas duas famílias; para o desenvolvedor, isso significa que a mesma estratégia de estrutura de prompt — "conteúdo fixo primeiro, conteúdo variável depois" — funciona nas duas. O custo de migração se concentra na sintaxe dos parâmetros: o GPT usa `prompt_cache_breakpoint` + `prompt_cache_key`, e o Claude usa `cache_control`. ## Comparação da escrita de cache nos dois protocolos Para o mesmo cenário de "cachear uma instrução longa fixa", as implementações mínimas nos dois protocolos ficam assim. Os exemplos usam `gpt-5.6-sol` e `claude-opus-4-8` — ambos têm o mesmo preço base de entrada (\$5/M), e os preços efetivos calculados para escrita (1.25x) e leitura (0.1x) de cache também são idênticos; apenas a sintaxe difere: O protocolo GPT define `prompt_cache_key` no nível superior (o prefixo longo é cacheado automaticamente, sem marcação de ponto de quebra); o protocolo Claude define `cache_control` no nível superior para habilitar o cache automático e, quando é preciso controlar a fronteira do cache com precisão, passa a usar pontos de quebra em nível de bloco de conteúdo: ```shell GPT-5.6 (Chat Completions) theme={null} curl https://aihubmix.com/v1/chat/completions \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $AIHUBMIX_API_KEY" \ -d '{ "model": "gpt-5.6-sol", "prompt_cache_key": "my-app-report-v1", "messages": [ { "role": "system", "content": "[instrução longa fixa, ≥1024 tokens]" }, { "role": "user", "content": "Summarize the key figures." } ] }' ``` ```shell Claude (Messages) theme={null} curl https://aihubmix.com/v1/messages \ -H "Content-Type: application/json" \ -H "x-api-key: $AIHUBMIX_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{ "model": "claude-opus-4-8", "max_tokens": 1024, "cache_control": {"type": "ephemeral"}, "system": "[instrução longa fixa, ≥1024 tokens]", "messages": [ { "role": "user", "content": "Summarize the key figures." } ] }' ``` Comparando as duas requisições, as diferenças se concentram em: endpoint (`/v1/chat/completions` e `/v1/messages`), cabeçalho de autenticação (`Authorization: Bearer` e `x-api-key` + `anthropic-version`), parâmetro de cache (`prompt_cache_key` de nível superior e `cache_control` de nível superior) e o `max_tokens` explícito exigido pelo Claude. As duas requisições foram testadas em aihubmix.com (2026-07-10): `gpt-5.6-sol` retornou `cached_tokens: 2816` na segunda chamada; `claude-opus-4-8` retornou `cache_creation_input_tokens: 3632` na primeira chamada e `cache_read_input_tokens: 3632` na segunda. Além do formato da requisição, há três diferenças de mecanismo: 1. **Forma de habilitação**: o GPT faz cache automaticamente mesmo sem nenhum parâmetro de cache, e `prompt_cache_key` serve para aumentar a confiabilidade dos acertos; o Claude exige declaração — ponto de quebra `cache_control` em nível de bloco de conteúdo, ou `cache_control` de nível superior no modo automático. 2. **Campos de usage**: no GPT, o volume de leitura de cache fica em `prompt_tokens_details.cached_tokens`; o Claude reporta escrita e leitura separadamente em `cache_creation_input_tokens` e `cache_read_input_tokens`, o que facilita conferir escrita e acertos individualmente. 3. **Controle do tempo de vida**: o `ttl` do GPT-5.6 atualmente aceita apenas `"30m"`; o Claude usa 5 minutos por padrão (refresh gratuito a cada acerto), com opção de `"ttl": "1h"` (escrita cobrada a 2x). ### O que alterar ao trocar de modelo entre protocolos O gateway da AIHubMix suporta chamadas entre protocolos: a interface compatível com OpenAI pode chamar modelos Claude (o `cache_control` vai diretamente nos blocos de conteúdo das mensagens em formato OpenAI; a sintaxe está em [Cache de prompts](/pt/practices/prompt-caching)); o `/v1/messages` compatível com Claude também pode chamar o GPT-5.6 (testado e funcional). Ao trocar de modelo, verifique três itens: * Troque `model` pelo ID do modelo de destino; * Troque a sintaxe do parâmetro de cache: `prompt_cache_key` / ponto de quebra explícito correspondem ao `cache_control` do Claude; * Troque o nome do campo de usage: `cached_tokens` corresponde ao `cache_read_input_tokens` do Claude. Caminho recomendado para o cache de prompts: modelos GPT via Chat Completions (o caminho com acerto testado neste artigo); modelos Claude funcionam pelos dois protocolos. ## Comparação: cache do GPT-5.6 e das gerações GPT anteriores | Dimensão | Antes do GPT-5.6 | GPT-5.6 e posteriores | | :----------------------------- | :------------------------------------------------------- | :----------------------------------------------------------------------------------------- | | Escrita de cache | Sem cobrança adicional | 1.25x o preço de entrada | | Retenção do cache | Limpo após 5–10 minutos de inatividade, no máximo 1 hora | Mínimo de 30 minutos | | Controle do cache | Nenhum | Ponto de quebra explícito, modo explicit, correspondência confiável via `prompt_cache_key` | | Retenção estendida de 24 horas | Alguns modelos suportam `prompt_cache_retention` | Substituída por `prompt_cache_options.ttl` (atualmente apenas 30m) | A direção das mudanças é consistente: nas gerações anteriores, o cache era gratuito, sem controle e com retenção incerta; o GPT-5.6 cobra pela escrita e, ao mesmo tempo, oferece retenção mínima garantida e meios precisos de controle do cache. Pelos multiplicadores, quando o prefixo é reutilizado em média mais de 1 vez, a economia supera o novo custo de escrita; a retenção garantida de 30 minutos e os pontos de quebra controláveis aumentam a previsibilidade de atingir essa taxa de reutilização. ## Comece a usar na AIHubMix Os três níveis já estão disponíveis, com os IDs de modelo `gpt-5.6-sol`, `gpt-5.6-terra` e `gpt-5.6-luna`. O cache não requer configuração adicional; requisições consecutivas com o mesmo prefixo longo geram acerto: ```py Python theme={null} import os from openai import OpenAI client = OpenAI( api_key=os.environ["AIHUBMIX_API_KEY"], base_url="https://aihubmix.com/v1", ) long_context = "You are a meticulous assistant for analyzing quarterly financial reports... [instrução longa fixa, ≥1024 tokens]" for i in range(2): completion = client.chat.completions.create( model="gpt-5.6-sol", prompt_cache_key="my-app-report-assistant-v1", messages=[ {"role": "system", "content": long_context}, {"role": "user", "content": "Summarize the key figures in one sentence."}, ], ) print(completion.usage.prompt_tokens_details) ``` Se `usage.prompt_tokens_details.cached_tokens` da segunda chamada for maior que 0, houve acerto (exemplo medido: `cached_tokens: 2816`). A descrição dos parâmetros, os detalhes de cobrança e a solução de problemas de acerto estão na documentação [Cache de Prompt do GPT](/pt/api/GPT-Cache). ## Perguntas Frequentes (FAQ) ### Quais interfaces podem chamar o GPT-5.6 na AIHubMix? Chat Completions (`/v1/chat/completions`), Responses (`/v1/responses`) e a interface Messages compatível com Claude (`/v1/messages`); os três níveis de modelo já estão disponíveis. Para o cache de prompts, a recomendação atual é usar Chat Completions. ### Sem alterações no cliente, o que muda na cobrança ao migrar para o GPT-5.6? O cache de prompts entra em vigor automaticamente: requisições com prefixo a partir de 1.024 tokens geram um item de escrita de cache cobrado a 1.25x o preço de entrada; quando o prefixo é reutilizado, a leitura é cobrada a 0.1x. Em aplicações com alta taxa de reutilização de prefixo, o custo total tende a cair; requisições longas de uso único sem reutilização de prefixo podem desativar o cache com o modo explicit. ### Já uso o cache de prompts do Claude; o que preciso alterar para migrar ao GPT-5.6? A estratégia de estrutura do prompt permanece: conteúdo fixo no início, conteúdo variável no final. O parâmetro muda de `cache_control` para `prompt_cache_breakpoint`, com a adição de `prompt_cache_key`; a retenção muda das duas faixas de 5 minutos/1 hora para o mínimo garantido de 30 minutos. ### Como escolher entre os três níveis do GPT-5.6? Posição oficial: para trabalho profissional complexo e tarefas de código, Sol; para cargas de trabalho do dia a dia, Terra (desempenho equivalente ao GPT-5.5 pela metade do preço); para cenários de grande volume sensíveis a custo, Luna. Os três níveis têm a mesma janela de contexto e a mesma saída máxima, permitindo roteamento em camadas conforme a complexidade da tarefa. ## Referências oficiais As especificações de modelo, o mecanismo de cache e os multiplicadores de cobrança deste artigo vêm das seguintes fontes oficiais: * [Anúncio de lançamento do GPT-5.6](https://openai.com/index/gpt-5-6/) (OpenAI, 2026-07-09) * [Guia de cache de prompts da OpenAI](https://developers.openai.com/api/docs/guides/prompt-caching) * [OpenAI Pricing](https://developers.openai.com/api/docs/pricing) * [Documentação de cache de prompts da Anthropic](https://platform.claude.com/docs/en/docs/build-with-claude/prompt-caching) Documentação relacionada no site: [Cache de Prompt do GPT](/pt/api/GPT-Cache) · [Cache de Prompt do Claude](/pt/api/Claude-Cache) · [Cache de prompts](/pt/practices/prompt-caching) *** Consulte os preços da série GPT-5.6 no [catálogo de modelos](https://aihubmix.com/models) ou conheça outras formas de integração na [central de documentação](https://docs.aihubmix.com). *** Última atualização: 2026-07-10