O cache de prompts é um recurso poderoso que otimiza seu uso da API permitindo retomar a partir de prefixos específicos em seus prompts. Essa abordagem reduz significativamente o tempo de processamento e os custos para tarefas repetitivas ou prompts com elementos consistentes. Aqui está um exemplo de como implementar o cache de prompts com a API de Mensagens usando um bloco cache_control:
curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "system": [
      {
        "type": "text",
        "text": "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n"
      },
      {
        "type": "text",
        "text": "<the entire contents of Pride and Prejudice>",
        "cache_control": {"type": "ephemeral"}
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "Analyze the major themes in Pride and Prejudice."
      }
    ]
  }'

# Call the model again with the same inputs up to the cache checkpoint
curl https://api.anthropic.com/v1/messages # rest of input
JSON
{"cache_creation_input_tokens":188086,"cache_read_input_tokens":0,"input_tokens":21,"output_tokens":393}
{"cache_creation_input_tokens":0,"cache_read_input_tokens":188086,"input_tokens":21,"output_tokens":393}
Neste exemplo, o texto completo de “Pride and Prejudice” é armazenado em cache usando o parâmetro cache_control. Isso permite reutilizar este texto grande em várias chamadas de API sem reprocessá-lo cada vez. Alterar apenas a mensagem do usuário permite fazer várias perguntas sobre o livro enquanto utiliza o conteúdo em cache, levando a respostas mais rápidas e eficiência melhorada.

Como funciona o cache de prompts

Quando você envia uma solicitação com cache de prompts ativado:
  1. O sistema verifica se um prefixo de prompt, até um ponto de interrupção de cache especificado, já está em cache de uma consulta recente.
  2. Se encontrado, usa a versão em cache, reduzindo o tempo de processamento e custos.
  3. Caso contrário, processa o prompt completo e armazena o prefixo em cache assim que a resposta começa.
Isso é especialmente útil para:
  • Prompts com muitos exemplos
  • Grandes quantidades de contexto ou informações de fundo
  • Tarefas repetitivas com instruções consistentes
  • Conversas longas com múltiplos turnos
Por padrão, o cache tem uma vida útil de 5 minutos. O cache é atualizado sem custo adicional cada vez que o conteúdo em cache é usado.
Se você achar que 5 minutos é muito curto, Anthropic também oferece uma duração de cache de 1 hora com custo adicional. O cache de 1 hora está atualmente em beta.Para mais informações, consulte duração de cache de 1 hora.
O cache de prompts armazena o prefixo completo em cacheO cache de prompts referencia o prompt inteiro - tools, system e messages (nessa ordem) até e incluindo o bloco designado com cache_control.

Preços

O cache de prompts introduz uma nova estrutura de preços. A tabela abaixo mostra o preço por milhão de tokens para cada modelo suportado:
ModelBase Input Tokens5m Cache Writes1h Cache WritesCache Hits & RefreshesOutput Tokens
Claude Opus 4.1$15 / MTok$18.75 / MTok$30 / MTok$1.50 / MTok$75 / MTok
Claude Opus 4$15 / MTok$18.75 / MTok$30 / MTok$1.50 / MTok$75 / MTok
Claude Sonnet 4.5$3 / MTok$3.75 / MTok$6 / MTok$0.30 / MTok$15 / MTok
Claude Sonnet 4$3 / MTok$3.75 / MTok$6 / MTok$0.30 / MTok$15 / MTok
Claude Sonnet 3.7$3 / MTok$3.75 / MTok$6 / MTok$0.30 / MTok$15 / MTok
Claude Sonnet 3.5 (deprecated)$3 / MTok$3.75 / MTok$6 / MTok$0.30 / MTok$15 / MTok
Claude Haiku 4.5$1 / MTok$1.25 / MTok$2 / MTok$0.10 / MTok$5 / MTok
Claude Haiku 3.5$0.80 / MTok$1 / MTok$1.6 / MTok$0.08 / MTok$4 / MTok
Claude Opus 3 (deprecated)$15 / MTok$18.75 / MTok$30 / MTok$1.50 / MTok$75 / MTok
Claude Haiku 3$0.25 / MTok$0.30 / MTok$0.50 / MTok$0.03 / MTok$1.25 / MTok
A tabela acima reflete os seguintes multiplicadores de preço para cache de prompts:
  • Tokens de escrita de cache de 5 minutos custam 1,25 vezes o preço de tokens de entrada base
  • Tokens de escrita de cache de 1 hora custam 2 vezes o preço de tokens de entrada base
  • Tokens de leitura de cache custam 0,1 vezes o preço de tokens de entrada base

Como implementar o cache de prompts

Modelos suportados

O cache de prompts é atualmente suportado em:
  • Claude Opus 4.1
  • Claude Opus 4
  • Claude Sonnet 4.5
  • Claude Sonnet 4
  • Claude Sonnet 3.7
  • Claude Sonnet 3.5 (descontinuado)
  • Claude Haiku 4.5
  • Claude Haiku 3.5
  • Claude Haiku 3
  • Claude Opus 3 (descontinuado)

Estruturando seu prompt

Coloque conteúdo estático (definições de ferramentas, instruções do sistema, contexto, exemplos) no início do seu prompt. Marque o final do conteúdo reutilizável para cache usando o parâmetro cache_control. Os prefixos de cache são criados na seguinte ordem: tools, system, depois messages. Essa ordem forma uma hierarquia onde cada nível se baseia nos anteriores.

Como funciona a verificação automática de prefixo

Você pode usar apenas um ponto de interrupção de cache no final do seu conteúdo estático, e o sistema encontrará automaticamente o prefixo correspondente mais longo. Aqui está como funciona:
  • Quando você adiciona um ponto de interrupção cache_control, o sistema verifica automaticamente se há acertos de cache em todos os limites de bloco de conteúdo anteriores (até aproximadamente 20 blocos antes do seu ponto de interrupção explícito)
  • Se qualquer uma dessas posições anteriores corresponder ao conteúdo em cache de solicitações anteriores, o sistema usa o prefixo correspondente mais longo
  • Isso significa que você não precisa de vários pontos de interrupção apenas para ativar o cache - um no final é suficiente

Quando usar vários pontos de interrupção

Você pode definir até 4 pontos de interrupção de cache se quiser:
  • Armazenar em cache diferentes seções que mudam em frequências diferentes (por exemplo, ferramentas raramente mudam, mas o contexto é atualizado diariamente)
  • Ter mais controle sobre exatamente o que é armazenado em cache
  • Garantir cache para conteúdo mais de 20 blocos antes do seu ponto de interrupção final
Limitação importante: A verificação automática de prefixo apenas procura aproximadamente 20 blocos de conteúdo antes de cada ponto de interrupção explícito. Se seu prompt tiver mais de 20 blocos de conteúdo antes do seu ponto de interrupção de cache, o conteúdo anterior a isso não será verificado para acertos de cache, a menos que você adicione pontos de interrupção adicionais.

Limitações de cache

O comprimento mínimo de prompt armazenável em cache é:
  • 1024 tokens para Claude Opus 4.1, Claude Opus 4, Claude Sonnet 4.5, Claude Sonnet 4, Claude Sonnet 3.7, Claude Sonnet 3.5 (descontinuado) e Claude Opus 3 (descontinuado)
  • 4096 tokens para Claude Haiku 4.5
  • 2048 tokens para Claude Haiku 3.5 e Claude Haiku 3
Prompts mais curtos não podem ser armazenados em cache, mesmo se marcados com cache_control. Qualquer solicitação para armazenar em cache menos do que este número de tokens será processada sem cache. Para ver se um prompt foi armazenado em cache, consulte os campos de uso da resposta. Para solicitações simultâneas, observe que uma entrada de cache só fica disponível após o início da primeira resposta. Se você precisar de acertos de cache para solicitações paralelas, aguarde a primeira resposta antes de enviar solicitações subsequentes. Atualmente, “ephemeral” é o único tipo de cache suportado, que por padrão tem uma vida útil de 5 minutos.

Entendendo os custos dos pontos de interrupção de cache

Os pontos de interrupção de cache em si não adicionam nenhum custo. Você é cobrado apenas por:
  • Escritas de cache: Quando novo conteúdo é escrito no cache (25% mais do que tokens de entrada base para TTL de 5 minutos)
  • Leituras de cache: Quando conteúdo em cache é usado (10% do preço de token de entrada base)
  • Tokens de entrada regulares: Para qualquer conteúdo não armazenado em cache
Adicionar mais pontos de interrupção cache_control não aumenta seus custos - você ainda paga a mesma quantia com base no que é realmente armazenado em cache e lido. Os pontos de interrupção simplesmente lhe dão controle sobre quais seções podem ser armazenadas em cache independentemente.

O que pode ser armazenado em cache

A maioria dos blocos na solicitação pode ser designada para cache com cache_control. Isso inclui:
  • Ferramentas: Definições de ferramentas no array tools
  • Mensagens do sistema: Blocos de conteúdo no array system
  • Mensagens de texto: Blocos de conteúdo no array messages.content, para turnos de usuário e assistente
  • Imagens e documentos: Blocos de conteúdo no array messages.content, em turnos de usuário
  • Uso de ferramentas e resultados de ferramentas: Blocos de conteúdo no array messages.content, em turnos de usuário e assistente
Cada um desses elementos pode ser marcado com cache_control para ativar o cache para essa parte da solicitação.

O que não pode ser armazenado em cache

Embora a maioria dos blocos de solicitação possa ser armazenada em cache, existem algumas exceções:
  • Blocos de pensamento não podem ser armazenados em cache diretamente com cache_control. No entanto, blocos de pensamento PODEM ser armazenados em cache junto com outro conteúdo quando aparecem em turnos anteriores do assistente. Quando armazenados em cache dessa forma, eles CONTAM como tokens de entrada quando lidos do cache.
  • Blocos de sub-conteúdo (como citações) em si não podem ser armazenados em cache diretamente. Em vez disso, armazene em cache o bloco de nível superior. No caso de citações, os blocos de conteúdo de documento de nível superior que servem como material de origem para citações podem ser armazenados em cache. Isso permite que você use cache de prompts com citações de forma eficaz armazenando em cache os documentos que as citações referenciará.
  • Blocos de texto vazios não podem ser armazenados em cache.

O que invalida o cache

Modificações no conteúdo em cache podem invalidar parte ou todo o cache. Conforme descrito em Estruturando seu prompt, o cache segue a hierarquia: toolssystemmessages. Alterações em cada nível invalidam esse nível e todos os níveis subsequentes. A tabela a seguir mostra quais partes do cache são invalidadas por diferentes tipos de alterações. ✘ indica que o cache é invalidado, enquanto ✓ indica que o cache permanece válido.
O que mudaCache de ferramentasCache do sistemaCache de mensagensImpacto
Definições de ferramentasModificar definições de ferramentas (nomes, descrições, parâmetros) invalida todo o cache
Alternância de busca na webAtivar/desativar busca na web modifica o prompt do sistema
Alternância de citaçõesAtivar/desativar citações modifica o prompt do sistema
Escolha de ferramentaAlterações no parâmetro tool_choice afetam apenas blocos de mensagens
ImagensAdicionar/remover imagens em qualquer lugar do prompt afeta blocos de mensagens
Parâmetros de pensamentoAlterações nas configurações de pensamento estendido (ativar/desativar, orçamento) afetam blocos de mensagens
Resultados não-ferramentas passados para solicitações de pensamento estendidoQuando resultados não-ferramentas são passados em solicitações enquanto o pensamento estendido está ativado, todos os blocos de pensamento previamente em cache são removidos do contexto, e quaisquer mensagens no contexto que seguem esses blocos de pensamento são removidas do cache. Para mais detalhes, consulte Cache com blocos de pensamento.

Rastreando o desempenho do cache

Monitore o desempenho do cache usando esses campos de resposta da API, dentro de usage na resposta (ou evento message_start se streaming):
  • cache_creation_input_tokens: Número de tokens escritos no cache ao criar uma nova entrada.
  • cache_read_input_tokens: Número de tokens recuperados do cache para esta solicitação.
  • input_tokens: Número de tokens de entrada que não foram lidos do cache ou usados para criar um cache.

Melhores práticas para cache eficaz

Para otimizar o desempenho do cache de prompts:
  • Armazene em cache conteúdo estável e reutilizável, como instruções do sistema, informações de fundo, contextos grandes ou definições de ferramentas frequentes.
  • Coloque conteúdo em cache no início do prompt para melhor desempenho.
  • Use pontos de interrupção de cache estrategicamente para separar diferentes seções de prefixo armazenável em cache.
  • Analise regularmente as taxas de acerto de cache e ajuste sua estratégia conforme necessário.

Otimizando para diferentes casos de uso

Adapte sua estratégia de cache de prompts ao seu cenário:
  • Agentes conversacionais: Reduza custo e latência para conversas estendidas, especialmente aquelas com instruções longas ou documentos carregados.
  • Assistentes de codificação: Melhore o preenchimento automático e perguntas sobre base de código mantendo seções relevantes ou uma versão resumida da base de código no prompt.
  • Processamento de documentos grandes: Incorpore material completo de longa forma, incluindo imagens em seu prompt sem aumentar a latência de resposta.
  • Conjuntos de instruções detalhadas: Compartilhe listas extensas de instruções, procedimentos e exemplos para ajustar as respostas do Claude. Os desenvolvedores geralmente incluem um ou dois exemplos no prompt, mas com cache de prompts você pode obter desempenho ainda melhor incluindo 20+ exemplos diversos de respostas de alta qualidade.
  • Uso de ferramentas de agente: Melhore o desempenho para cenários envolvendo múltiplas chamadas de ferramentas e alterações de código iterativas, onde cada etapa normalmente requer uma nova chamada de API.
  • Converse com livros, artigos, documentação, transcrições de podcasts e outro conteúdo de longa forma: Traga qualquer base de conhecimento à vida incorporando o(s) documento(s) inteiro(s) no prompt e deixando os usuários fazerem perguntas.

Resolvendo problemas comuns

Se experimentar comportamento inesperado:
  • Certifique-se de que as seções em cache são idênticas e marcadas com cache_control nos mesmos locais em todas as chamadas
  • Verifique se as chamadas são feitas dentro da vida útil do cache (5 minutos por padrão)
  • Verifique se tool_choice e o uso de imagens permanecem consistentes entre chamadas
  • Valide que você está armazenando em cache pelo menos o número mínimo de tokens
  • O sistema verifica automaticamente se há acertos de cache em limites de blocos de conteúdo anteriores (até ~20 blocos antes do seu ponto de interrupção). Para prompts com mais de 20 blocos de conteúdo, você pode precisar de parâmetros cache_control adicionais no início do prompt para garantir que todo o conteúdo possa ser armazenado em cache
  • Verifique se as chaves em seus blocos de conteúdo tool_use têm ordenação estável, pois algumas linguagens (por exemplo, Swift, Go) randomizam a ordem das chaves durante a conversão JSON, quebrando caches
Alterações em tool_choice ou a presença/ausência de imagens em qualquer lugar do prompt invalidarão o cache, exigindo que uma nova entrada de cache seja criada. Para mais detalhes sobre invalidação de cache, consulte O que invalida o cache.

Cache com blocos de pensamento

Ao usar pensamento estendido com cache de prompts, blocos de pensamento têm comportamento especial: Cache automático junto com outro conteúdo: Embora blocos de pensamento não possam ser explicitamente marcados com cache_control, eles são armazenados em cache como parte do conteúdo da solicitação quando você faz chamadas de API subsequentes com resultados de ferramentas. Isso comumente acontece durante o uso de ferramentas quando você passa blocos de pensamento de volta para continuar a conversa. Contagem de tokens de entrada: Quando blocos de pensamento são lidos do cache, eles contam como tokens de entrada em suas métricas de uso. Isso é importante para cálculo de custo e orçamento de tokens. Padrões de invalidação de cache:
  • O cache permanece válido quando apenas resultados de ferramentas são fornecidos como mensagens de usuário
  • O cache é invalidado quando conteúdo de usuário não-resultado-de-ferramenta é adicionado, causando que todos os blocos de pensamento anteriores sejam removidos
  • Esse comportamento de cache ocorre mesmo sem marcadores cache_control explícitos
Para mais detalhes sobre invalidação de cache, consulte O que invalida o cache. Exemplo com uso de ferramentas:
Solicitação 1: Usuário: "Qual é o tempo em Paris?"
Resposta: [thinking_block_1] + [tool_use block 1]

Solicitação 2:
Usuário: ["Qual é o tempo em Paris?"],
Assistente: [thinking_block_1] + [tool_use block 1],
Usuário: [tool_result_1, cache=True]
Resposta: [thinking_block_2] + [text block 2]
# Solicitação 2 armazena em cache seu conteúdo de solicitação (não a resposta)
# O cache inclui: mensagem do usuário, thinking_block_1, tool_use block 1 e tool_result_1

Solicitação 3:
Usuário: ["Qual é o tempo em Paris?"],
Assistente: [thinking_block_1] + [tool_use block 1],
Usuário: [tool_result_1, cache=True],
Assistente: [thinking_block_2] + [text block 2],
Usuário: [Text response, cache=True]
# Bloco de usuário não-resultado-de-ferramenta causa que todos os blocos de pensamento sejam ignorados
# Esta solicitação é processada como se blocos de pensamento nunca estivessem presentes
Quando um bloco de usuário não-resultado-de-ferramenta é incluído, ele designa um novo loop de assistente e todos os blocos de pensamento anteriores são removidos do contexto. Para informações mais detalhadas, consulte a documentação de pensamento estendido.

Armazenamento e compartilhamento de cache

  • Isolamento de Organização: Caches são isolados entre organizações. Diferentes organizações nunca compartilham caches, mesmo que usem prompts idênticos.
  • Correspondência Exata: Acertos de cache requerem segmentos de prompt 100% idênticos, incluindo todo o texto e imagens até e incluindo o bloco marcado com controle de cache.
  • Geração de Token de Saída: O cache de prompts não tem efeito na geração de token de saída. A resposta que você recebe será idêntica ao que você obteria se o cache de prompts não fosse usado.

Duração de cache de 1 hora

Se você achar que 5 minutos é muito curto, Anthropic também oferece uma duração de cache de 1 hora com custo adicional. Para usar o cache estendido, inclua ttl na definição cache_control assim:
"cache_control": {
    "type": "ephemeral",
    "ttl": "5m" | "1h"
}
A resposta incluirá informações detalhadas de cache como a seguinte:
{
    "usage": {
        "input_tokens": ...,
        "cache_read_input_tokens": ...,
        "cache_creation_input_tokens": ...,
        "output_tokens": ...,

        "cache_creation": {
            "ephemeral_5m_input_tokens": 456,
            "ephemeral_1h_input_tokens": 100,
        }
    }
}
Observe que o campo cache_creation_input_tokens atual é igual à soma dos valores no objeto cache_creation.

Quando usar o cache de 1 hora

Se você tiver prompts que são usados em uma cadência regular (ou seja, prompts do sistema que são usados com mais frequência do que a cada 5 minutos), continue usando o cache de 5 minutos, pois isso continuará sendo atualizado sem custo adicional. O cache de 1 hora é melhor usado nos seguintes cenários:
  • Quando você tem prompts que provavelmente são usados com menos frequência do que 5 minutos, mas mais frequentemente do que a cada hora. Por exemplo, quando um agente secundário de agente levará mais de 5 minutos, ou ao armazenar uma conversa longa com um usuário e você geralmente espera que esse usuário possa não responder nos próximos 5 minutos.
  • Quando a latência é importante e seus prompts de acompanhamento podem ser enviados além de 5 minutos.
  • Quando você quer melhorar sua utilização de limite de taxa, já que acertos de cache não são deduzidos do seu limite de taxa.
O cache de 5 minutos e 1 hora se comportam da mesma forma com relação à latência. Você geralmente verá tempo-para-primeiro-token melhorado para documentos longos.

Misturando diferentes TTLs

Você pode usar controles de cache de 1 hora e 5 minutos na mesma solicitação, mas com uma restrição importante: Entradas de cache com TTL mais longo devem aparecer antes de TTLs mais curtos (ou seja, uma entrada de cache de 1 hora deve aparecer antes de qualquer entrada de cache de 5 minutos). Ao misturar TTLs, determinamos três locais de faturamento em seu prompt:
  1. Posição A: A contagem de tokens no acerto de cache mais alto (ou 0 se nenhum acerto).
  2. Posição B: A contagem de tokens no bloco cache_control de 1 hora mais alto após A (ou igual a A se nenhum existir).
  3. Posição C: A contagem de tokens no último bloco cache_control.
Se B e/ou C forem maiores que A, eles serão necessariamente acertos de cache perdidos, porque A é o acerto de cache mais alto.
Você será cobrado por:
  1. Tokens de leitura de cache para A.
  2. Tokens de escrita de cache de 1 hora para (B - A).
  3. Tokens de escrita de cache de 5 minutos para (C - B).
Aqui estão 3 exemplos. Isso mostra os tokens de entrada de 3 solicitações, cada uma com diferentes acertos de cache e acertos de cache perdidos. Cada um tem um preço calculado diferente, mostrado nas caixas coloridas, como resultado. Diagrama de Mistura de TTLs

Exemplos de cache de prompts

Para ajudá-lo a começar com cache de prompts, preparamos um livro de receitas de cache de prompts com exemplos detalhados e melhores práticas. Abaixo, incluímos vários trechos de código que demonstram vários padrões de cache de prompts. Esses exemplos demonstram como implementar cache em diferentes cenários, ajudando você a entender as aplicações práticas desse recurso:
curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "system": [
        {
            "type": "text",
            "text": "You are an AI assistant tasked with analyzing legal documents."
        },
        {
            "type": "text",
            "text": "Here is the full text of a complex legal agreement: [Insert full text of a 50-page legal agreement here]",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    "messages": [
        {
            "role": "user",
            "content": "What are the key terms and conditions in this agreement?"
        }
    ]
}'
Este exemplo demonstra o uso básico de cache de prompts, armazenando em cache o texto completo do contrato legal como um prefixo enquanto mantém a instrução do usuário não armazenada em cache.Para a primeira solicitação:
  • input_tokens: Número de tokens apenas na mensagem do usuário
  • cache_creation_input_tokens: Número de tokens em toda a mensagem do sistema, incluindo o documento legal
  • cache_read_input_tokens: 0 (nenhum acerto de cache na primeira solicitação)
Para solicitações subsequentes dentro da vida útil do cache:
  • input_tokens: Número de tokens apenas na mensagem do usuário
  • cache_creation_input_tokens: 0 (nenhuma criação de novo cache)
  • cache_read_input_tokens: Número de tokens em toda a mensagem do sistema em cache
curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "Get the current weather in a given location",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "The unit of temperature, either celsius or fahrenheit"
                    }
                },
                "required": ["location"]
            }
        },
        # many more tools
        {
            "name": "get_time",
            "description": "Get the current time in a given time zone",
            "input_schema": {
                "type": "object",
                "properties": {
                    "timezone": {
                        "type": "string",
                        "description": "The IANA time zone name, e.g. America/Los_Angeles"
                    }
                },
                "required": ["timezone"]
            },
            "cache_control": {"type": "ephemeral"}
        }
    ],
    "messages": [
        {
            "role": "user",
            "content": "What is the weather and time in New York?"
        }
    ]
}'
Neste exemplo, demonstramos o cache de definições de ferramentas.O parâmetro cache_control é colocado na ferramenta final (get_time) para designar todas as ferramentas como parte do prefixo estático.Isso significa que todas as definições de ferramentas, incluindo get_weather e qualquer outra ferramenta definida antes de get_time, serão armazenadas em cache como um único prefixo.Essa abordagem é útil quando você tem um conjunto consistente de ferramentas que deseja reutilizar em várias solicitações sem reprocessá-las cada vez.Para a primeira solicitação:
  • input_tokens: Número de tokens na mensagem do usuário
  • cache_creation_input_tokens: Número de tokens em todas as definições de ferramentas e prompt do sistema
  • cache_read_input_tokens: 0 (nenhum acerto de cache na primeira solicitação)
Para solicitações subsequentes dentro da vida útil do cache:
  • input_tokens: Número de tokens na mensagem do usuário
  • cache_creation_input_tokens: 0 (nenhuma criação de novo cache)
  • cache_read_input_tokens: Número de tokens em todas as definições de ferramentas e prompt do sistema em cache
curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "system": [
        {
            "type": "text",
            "text": "...long system prompt",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Hello, can you tell me more about the solar system?",
                }
            ]
        },
        {
            "role": "assistant",
            "content": "Certainly! The solar system is the collection of celestial bodies that orbit our Sun. It consists of eight planets, numerous moons, asteroids, comets, and other objects. The planets, in order from closest to farthest from the Sun, are: Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, and Neptune. Each planet has its own unique characteristics and features. Is there a specific aspect of the solar system you would like to know more about?"
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Good to know."
                },
                {
                    "type": "text",
                    "text": "Tell me more about Mars.",
                    "cache_control": {"type": "ephemeral"}
                }
            ]
        }
    ]
}'
Neste exemplo, demonstramos como usar cache de prompts em uma conversa com múltiplos turnos.Durante cada turno, marcamos o bloco final da mensagem final com cache_control para que a conversa possa ser incrementalmente armazenada em cache. O sistema procurará automaticamente e usará o prefixo previamente em cache mais longo para mensagens de acompanhamento. Ou seja, blocos que foram previamente marcados com um bloco cache_control não são marcados posteriormente, mas ainda serão considerados um acerto de cache (e também uma atualização de cache!) se forem atingidos dentro de 5 minutos.Além disso, observe que o parâmetro cache_control é colocado na mensagem do sistema. Isso é para garantir que se isso for removido do cache (após não ser usado por mais de 5 minutos), ele será adicionado de volta ao cache na próxima solicitação.Essa abordagem é útil para manter contexto em conversas contínuas sem reprocessar repetidamente as mesmas informações.Quando isso é configurado corretamente, você deve ver o seguinte na resposta de uso de cada solicitação:
  • input_tokens: Número de tokens na nova mensagem do usuário (será mínimo)
  • cache_creation_input_tokens: Número de tokens nos novos turnos de assistente e usuário
  • cache_read_input_tokens: Número de tokens na conversa até o turno anterior
curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "search_documents",
            "description": "Search through the knowledge base",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Search query"
                    }
                },
                "required": ["query"]
            }
        },
        {
            "name": "get_document",
            "description": "Retrieve a specific document by ID",
            "input_schema": {
                "type": "object",
                "properties": {
                    "doc_id": {
                        "type": "string",
                        "description": "Document ID"
                    }
                },
                "required": ["doc_id"]
            },
            "cache_control": {"type": "ephemeral"}
        }
    ],
    "system": [
        {
            "type": "text",
            "text": "You are a helpful research assistant with access to a document knowledge base.\n\n# Instructions\n- Always search for relevant documents before answering\n- Provide citations for your sources\n- Be objective and accurate in your responses\n- If multiple documents contain relevant information, synthesize them\n- Acknowledge when information is not available in the knowledge base",
            "cache_control": {"type": "ephemeral"}
        },
        {
            "type": "text",
            "text": "# Knowledge Base Context\n\nHere are the relevant documents for this conversation:\n\n## Document 1: Solar System Overview\nThe solar system consists of the Sun and all objects that orbit it...\n\n## Document 2: Planetary Characteristics\nEach planet has unique features. Mercury is the smallest planet...\n\n## Document 3: Mars Exploration\nMars has been a target of exploration for decades...\n\n[Additional documents...]",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    "messages": [
        {
            "role": "user",
            "content": "Can you search for information about Mars rovers?"
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "tool_use",
                    "id": "tool_1",
                    "name": "search_documents",
                    "input": {"query": "Mars rovers"}
                }
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "tool_1",
                    "content": "Found 3 relevant documents: Document 3 (Mars Exploration), Document 7 (Rover Technology), Document 9 (Mission History)"
                }
            ]
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "I found 3 relevant documents about Mars rovers. Let me get more details from the Mars Exploration document."
                }
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Yes, please tell me about the Perseverance rover specifically.",
                    "cache_control": {"type": "ephemeral"}
                }
            ]
        }
    ]
}'
Este exemplo abrangente demonstra como usar todos os 4 pontos de interrupção de cache disponíveis para otimizar diferentes partes do seu prompt:
  1. Cache de ferramentas (ponto de interrupção de cache 1): O parâmetro cache_control na última definição de ferramenta armazena em cache todas as definições de ferramentas.
  2. Cache de instruções reutilizáveis (ponto de interrupção de cache 2): As instruções estáticas no prompt do sistema são armazenadas em cache separadamente. Essas instruções raramente mudam entre solicitações.
  3. Cache de contexto RAG (ponto de interrupção de cache 3): Os documentos da base de conhecimento são armazenados em cache independentemente, permitindo que você atualize os documentos RAG sem invalidar o cache de ferramentas ou instruções.
  4. Cache de histórico de conversa (ponto de interrupção de cache 4): A resposta do assistente é marcada com cache_control para ativar o cache incremental da conversa conforme ela progride.
Essa abordagem oferece flexibilidade máxima:
  • Se você apenas atualizar a mensagem final do usuário, todos os quatro segmentos de cache são reutilizados
  • Se você atualizar os documentos RAG mas manter as mesmas ferramentas e instruções, os dois primeiros segmentos de cache são reutilizados
  • Se você alterar a conversa mas manter as mesmas ferramentas, instruções e documentos, os três primeiros segmentos são reutilizados
  • Cada ponto de interrupção de cache pode ser invalidado independentemente com base no que muda em sua aplicação
Para a primeira solicitação:
  • input_tokens: Tokens na mensagem final do usuário
  • cache_creation_input_tokens: Tokens em todos os segmentos em cache (ferramentas + instruções + documentos RAG + histórico de conversa)
  • cache_read_input_tokens: 0 (nenhum acerto de cache)
Para solicitações subsequentes com apenas uma nova mensagem do usuário:
  • input_tokens: Tokens apenas na nova mensagem do usuário
  • cache_creation_input_tokens: Qualquer novo token adicionado ao histórico de conversa
  • cache_read_input_tokens: Todos os tokens previamente em cache (ferramentas + instruções + documentos RAG + conversa anterior)
Esse padrão é especialmente poderoso para:
  • Aplicações RAG com contextos de documento grande
  • Sistemas de agente que usam múltiplas ferramentas
  • Conversas de longa duração que precisam manter contexto
  • Aplicações que precisam otimizar diferentes partes do prompt independentemente

Perguntas frequentes

Na maioria dos casos, um único ponto de interrupção de cache no final do seu conteúdo estático é suficiente. O sistema verifica automaticamente se há acertos de cache em todos os limites de bloco de conteúdo anteriores (até 20 blocos antes do seu ponto de interrupção) e usa o prefixo correspondente mais longo.Você só precisa de múltiplos pontos de interrupção se:
  • Você tiver mais de 20 blocos de conteúdo antes do seu ponto de cache desejado
  • Você quiser armazenar em cache seções que são atualizadas em frequências diferentes independentemente
  • Você precisar de controle explícito sobre o que é armazenado em cache para otimização de custo
Exemplo: Se você tiver instruções do sistema (raramente mudam) e contexto RAG (muda diariamente), você pode usar dois pontos de interrupção para armazená-los em cache separadamente.
Não, os pontos de interrupção de cache em si são gratuitos. Você só paga por:
  • Escrever conteúdo no cache (25% mais do que tokens de entrada base para TTL de 5 minutos)
  • Ler do cache (10% do preço de token de entrada base)
  • Tokens de entrada regulares para conteúdo não armazenado em cache
O número de pontos de interrupção não afeta o preço - apenas a quantidade de conteúdo armazenado em cache e lido importa.
A vida útil padrão mínima do cache (TTL) é 5 minutos. Essa vida útil é atualizada cada vez que o conteúdo em cache é usado.Se você achar que 5 minutos é muito curto, Anthropic também oferece um TTL de cache de 1 hora.
Você pode definir até 4 pontos de interrupção de cache (usando parâmetros cache_control) em seu prompt.
Não, o cache de prompts está atualmente disponível apenas para Claude Opus 4.1, Claude Opus 4, Claude Sonnet 4.5, Claude Sonnet 4, Claude Sonnet 3.7, Claude Sonnet 3.5 (descontinuado), Claude Haiku 4.5, Claude Haiku 3.5, Claude Haiku 3 e Claude Opus 3 (descontinuado).
Prompts do sistema em cache e ferramentas serão reutilizados quando os parâmetros de pensamento mudam. No entanto, alterações de pensamento (ativar/desativar ou alterações de orçamento) invalidarão prefixos de prompt previamente em cache com conteúdo de mensagens.Para mais detalhes sobre invalidação de cache, consulte O que invalida o cache.Para mais sobre pensamento estendido, incluindo sua interação com uso de ferramentas e cache de prompts, consulte a documentação de pensamento estendido.
Para ativar o cache de prompts, inclua pelo menos um ponto de interrupção cache_control em sua solicitação de API.
Sim, o cache de prompts pode ser usado junto com outros recursos da API, como uso de ferramentas e recursos de visão. No entanto, alterar se há imagens em um prompt ou modificar configurações de uso de ferramentas quebrará o cache.Para mais detalhes sobre invalidação de cache, consulte O que invalida o cache.
O cache de prompts introduz uma nova estrutura de preços onde escritas de cache custam 25% mais do que tokens de entrada base, enquanto acertos de cache custam apenas 10% do preço de token de entrada base.
Atualmente, não há como limpar manualmente o cache. Prefixos em cache expiram automaticamente após um mínimo de 5 minutos de inatividade.
Você pode monitorar o desempenho do cache usando os campos cache_creation_input_tokens e cache_read_input_tokens na resposta da API.
Consulte O que invalida o cache para mais detalhes sobre invalidação de cache, incluindo uma lista de alterações que exigem criar uma nova entrada de cache.
O cache de prompts é projetado com medidas fortes de privacidade e separação de dados:
  1. As chaves de cache são geradas usando um hash criptográfico dos prompts até o ponto de controle de cache. Isso significa que apenas solicitações com prompts idênticos podem acessar um cache específico.
  2. Caches são específicos da organização. Usuários dentro da mesma organização podem acessar o mesmo cache se usarem prompts idênticos, mas caches não são compartilhados entre diferentes organizações, mesmo para prompts idênticos.
  3. O mecanismo de cache é projetado para manter a integridade e privacidade de cada conversa ou contexto único.
  4. É seguro usar cache_control em qualquer lugar em seus prompts. Para eficiência de custo, é melhor excluir partes altamente variáveis (por exemplo, entrada arbitrária do usuário) do cache.
Essas medidas garantem que o cache de prompts mantenha privacidade e segurança de dados enquanto oferece benefícios de desempenho.
Sim, é possível usar cache de prompts com suas solicitações da API de Lotes. No entanto, como solicitações de lote assíncronas podem ser processadas simultaneamente e em qualquer ordem, acertos de cache são fornecidos em base de melhor esforço.O cache de 1 hora pode ajudar a melhorar seus acertos de cache. A forma mais econômica de usá-lo é a seguinte:
  • Reúna um conjunto de solicitações de mensagens que têm um prefixo compartilhado.
  • Envie uma solicitação de lote com apenas uma solicitação que tenha este prefixo compartilhado e um bloco de cache de 1 hora. Isso será escrito no cache de 1 hora.
  • Assim que isso for concluído, envie o resto das solicitações. Você terá que monitorar o trabalho para saber quando ele é concluído.
Isso é tipicamente melhor do que usar o cache de 5 minutos simplesmente porque é comum que solicitações de lote levem entre 5 minutos e 1 hora para serem concluídas. Estamos considerando maneiras de melhorar essas taxas de acerto de cache e tornar esse processo mais direto.
Este erro normalmente aparece quando você atualizou seu SDK ou está usando exemplos de código desatualizados. O cache de prompts agora está geralmente disponível, portanto você não precisa mais do prefixo beta. Em vez de:
python client.beta.prompt_caching.messages.create(...)
Simplesmente use:
python client.messages.create(...)
Este erro normalmente aparece quando você atualizou seu SDK ou está usando exemplos de código desatualizados. O cache de prompts agora está geralmente disponível, portanto você não precisa mais do prefixo beta. Em vez de:
TypeScript
client.beta.promptCaching.messages.create(...)
Simplesmente use:
client.messages.create(...)