Pular para o conteúdo principal

Reduza Seu Uso de Tokens (e o Custo)

Intermediário

Você paga por cada token de entrada e por cada token de saída. A boa notícia: a maioria das cargas de trabalho reais carrega peso morto — prompts de sistema inchados, contexto reenviado, respostas prolixas, o modelo errado para uma tarefa fácil. Corte isso e a conta cai sem mexer na qualidade. Esta página é o kit de ferramentas para usuários avançados, ordenado mais ou menos por alavancagem.

What you'll learn
  • Onde os tokens realmente vazam — entrada vs saída vs contexto reutilizado
  • O estilo enxuto / 'caveman': o que ele realmente economiza, e onde fracassa
  • Cache de prompt e processamento em lote para economias estruturais reais
  • Dimensionar corretamente o modelo (Haiku para tarefas baratas) e saída estruturada em vez de prosa
  • Medir antes de publicar com o endpoint de contagem de tokens

Primeiro, descubra para onde vão os tokens​

Antes de otimizar, divida seu gasto em três categorias — cada uma tem uma correção diferente:

As três categorias de tokens
Pressione Enter ou Espaço para virar o cartão. Use as setas esquerda e direita para navegar entre os cartões.Termo exibido.
1 / 3

As correções se encaixam de forma clara: coloque em cache o contexto reutilizado, enxugue a entrada, encurte a saída, dimensione corretamente o modelo e agrupe em lote o que não for urgente.

O estilo enxuto / "caveman" (economia na saída)​

A jogada viral é dizer ao Claude para abandonar enchimentos e responder em fragmentos — popularizada pela skill open-source caveman para Claude Code (licença MIT, por Julius Brussee), cujo lema é "why use many token when few token do trick" (por que usar muitos token quando poucos token resolvem). Ela força frases curtas, verbos no infinitivo e zero amabilidades.

A conclusão honesta dos testes independentes: o estilo não custa nada no conteúdo (código, termos técnicos e JSON ficam exatos), mas a economia depende inteiramente da sua linha de base. Se seus prompts já dizem "seja conciso", a maior parte do ganho já está garantida. As grandes reduções (40–65%) aparecem em respostas com muita explicação; extração estruturada quase não muda.

Bloco de instrução enxuto — cole no seu prompt de sistema

Answer terse. Cut filler, hedging, and pleasantries.
Drop articles (a/an/the) and softeners (just, really, basically, actually).
No preamble, no restating the question, no "happy to help."
Fragments are fine. Keep technical terms and code blocks exact.
Pattern per point: [thing] [action] [reason]. Next step if any.
Pro tip
  • Coloque a regra de enxugamento uma vez no prompt de sistema, não em cada turno do usuário — repeti-la paga novamente o custo de entrada a cada chamada.
  • Nunca comprima código, identificadores, JSON ou números. Comprima apenas a prosa.
  • 'Be concise. Return JSON only.' já representa ~60% da economia de saída alcançável — escreva isso antes de buscar truques mais sofisticados.
Watch out
  • O estilo enxuto reduz apenas a SAÍDA. Não faz nada por um prompt de sistema de 20k tokens que você reenvia a cada chamada — isso é um problema de entrada/cache.
  • Em tarefas com pensamento estendido, os tokens de raciocínio não são afetados; você só reduz a resposta visível final.

Coloque em cache o prefixo reutilizado (economia na entrada)​

Se muitas chamadas compartilham um grande trecho imutável — um prompt de sistema longo, um catálogo de ferramentas, um documento de referência — o cache de prompt o processa uma vez e o reutiliza a uma fração do preço de entrada em cada chamada posterior. Esta é a mudança estrutural de maior alavancagem para cargas de trabalho de chat e agentes, porque se paga em cada turno.

A única regra: o prefixo em cache deve ser byte por byte idêntico entre as chamadas. Um timestamp perdido ou uma lista de ferramentas reordenada perto do topo derruba silenciosamente sua taxa de acerto a zero. A mecânica completa, o trecho cache_control para copiar e colar, e como verificar os acertos estão em Cache de Prompt e Otimização de Custo.

Guided walkthrough1 of 3
  1. Mova o prompt de sistema, as ferramentas e os documentos para o início; mantenha o turno variável do usuário no final.

Enxugue o contexto que você envia​

O cache reutiliza o contexto de forma barata, mas o token mais barato é aquele que você nunca envia. Audite o que realmente está na janela:

  • Pode o prompt de sistema. Blocos de instrução longos acumulam entulho. Corte exemplos que não justificam mais seus tokens; mantenha um exemplo forte em vez de cinco medíocres.
  • Recupere, não despeje. Em vez de colar um documento inteiro, busque apenas as passagens relevantes (RAG). Enviar um PDF de 50 páginas para responder uma única pergunta é o desperdício mais comum.
  • Compacte sessões longas. Quando uma conversa cresce, substitua os turnos antigos por um breve resumo corrente em vez de carregar todas as mensagens para sempre. O histórico são tokens de entrada que você repaga a cada chamada.
  • Dimensione corretamente o catálogo de ferramentas. Cada definição de ferramenta são tokens de entrada em cada requisição. Exponha apenas as ferramentas que a tarefa atual precisa.

Dimensione corretamente o modelo​

Não pague tarifas de Opus por uma tarefa de nível Haiku. Classificação, extração, formatação simples e roteamento geralmente funcionam ótimo no menor modelo a uma fração do preço por token. Reserve os modelos maiores para raciocínio genuinamente difícil e considere o roteamento: um modelo barato lida com a maioria fácil, escalando apenas os casos difíceis. Veja Escolhendo um Modelo e Tokens, Contexto e Preços para os tradeoffs.

Prefira saída estruturada em vez de prosa​

Pedir JSON (ou outro schema enxuto) em vez de um parágrafo explicativo corta tokens de saída e elimina a adivinhação de parsing mais à frente. Dizer ao Claude para retornar apenas um objeto compacto como {"label": ..., "score": ...} gera uma fração dos tokens de uma resposta tagarela — e você pula inteiramente o preâmbulo do tipo "Aqui está o resultado:". Detalhes em Saída Estruturada.

Agrupe em lote o que não for urgente​

Para trabalho offline em que você não precisa de uma resposta em segundos — avaliações, classificação em massa, rotulagem de datasets, resumo de um arquivo — a API de Lotes de Mensagens da Anthropic executa requisições de forma assíncrona com 50% de desconto tanto nos tokens de entrada quanto nos de saída, com resultados normalmente retornados em até 24 horas.

Combine isso com cache e um modelo corretamente dimensionado, e o desconto conjunto em um grande trabalho offline é dramático.

Meça — não adivinhe​

Otimize contra números, não contra sensações. O endpoint de contagem de tokens da Anthropic retorna a contagem exata de tokens de entrada de uma requisição antes de você enviá-la — com o mesmo formato de uma chamada Messages, e é gratuito (com limite de taxa). Use-o para comparar um prompt inchado com um enxugado, para tomar decisões de roteamento de modelo e para manter os prompts dentro da janela de contexto.

Conte tokens antes de enviar (SDK Python)

import anthropic

client = anthropic.Anthropic()

resp = client.messages.count_tokens(
  model="claude-opus-4-8",
  system="You are a scientist",
  messages=[{"role": "user", "content": "Hello, Claude"}],
)
print(resp.input_tokens)  # exact input count, no charge for counting
Pro tip
  • Não use o tokenizador de outro modelo (ex.: tiktoken) — as contagens diferem por família de modelo. Use o endpoint da Anthropic.
  • Tokenizadores mais novos podem produzir ~30% mais tokens para o mesmo texto do que modelos antigos — reconte ao migrar, não reutilize estimativas antigas.
  • Leia input_tokens, cache_read_input_tokens e output_tokens no uso da resposta para confirmar que a economia chegou à produção.

Veja Tokens, Contexto e Preços para as regras de contagem e a fórmula de estimativa de custo.

Um antes/depois, de ponta a ponta​

Um assistente de triagem de suporte executa o mesmo prompt de sistema de 4.000 tokens + catálogo de ferramentas em cada ticket e escreve uma resposta tagarela de 600 tokens.

Guided walkthrough1 of 4
  1. ~4.000 tokens de entrada reenviados a preço cheio em cada chamada + ~600 tokens de saída prolixos, em um modelo grande. Nada em cache, síncrono, respostas em prosa.

Cada alavanca é multiplicativa: entrada em cache × modelo menor × saída mais enxuta × desconto em lote se compõem em uma grande redução total — enquanto a qualidade da resposta nessa tarefa fácil permanece inalterada. Meça cada etapa com count_tokens para que você possa provar o ganho em vez de assumi-lo.

Teste-se

0/4
  1. O estilo 'caveman' / enxuto reduz principalmente quais tokens?
  2. Você reenvia o mesmo prompt de sistema de 10k tokens em cada chamada. Melhor solução?
  3. Qual carga de trabalho é a mais adequada para o desconto de 50% da API de Lotes de Mensagens?
  4. Como você deve verificar se uma mudança de prompt realmente economizou tokens?
Key takeaways
  • Divida o gasto em entrada, saída e contexto reutilizado — cada categoria tem uma correção diferente.
  • O estilo enxuto/'caveman' corta apenas a saída; os ganhos são grandes em prosa e pequenos em tarefas estruturadas já concisas.
  • Coloque o prefixo estável em cache (byte por byte idêntico) para economia real na entrada em cada chamada.
  • Enxugue o contexto, dimensione corretamente o modelo e prefira JSON em vez de prosa — ganhos baratos e cumulativos.
  • Agrupe em lote o trabalho não urgente para 50% de desconto, e sempre meça com count_tokens em vez de adivinhar.

Fontes e leitura adicional​

Próximos​