Artigo AI·Inteligência Artificial·13 min de leitura

Como Economizar Tokens no ChatGPT, Claude e Gemini

APIs de IA cobram por token — cada palavra enviada e recebida tem custo real. Em escala, vira a maior linha de despesa. Veja 12 técnicas comprovadas para reduzir consumo em 40–80% sem perder qualidade, com estimativas reais e exemplos prontos.

Por Vitor Morais

Fundador do MochaLabz · publicado em 18 de abril de 2026

🧮

Conte tokens antes de enviar

Estime custo do prompt para GPT, Claude e Gemini — evita surpresa na fatura.

Contar tokens →

APIs de IA cobram por token — cada fragmento de palavra processado, tanto no input quanto no output. Em aplicações de pequena escala isso é irrelevante. Em qualquer sistema que faz milhares de chamadas por dia, o custo de tokens vira a maior linha de despesa de infraestrutura. Boa notícia: com algumas técnicas comprovadas, dá para reduzir o consumo em 40 a 80% sem sacrificar qualidade. Este guia cobre 12 técnicas práticas com exemplos e estimativas reais.

Quanto cada modelo custa em 2026

Preços por 1 milhão de tokens (referenciais 2026)
Critério	Input	Output	Cached input
GPT-5	~US$ 5–15	~US$ 30–60	50% off
GPT-5-mini	~US$ 0,15	~US$ 0,60	50% off
Claude Opus 4.7	~US$ 15	~US$ 75	10% off
Claude Sonnet 4.6	~US$ 3	~US$ 15	10% off
Claude Haiku 4.5	~US$ 0,80	~US$ 4	10% off
Gemini 2.5 Pro	~US$ 1,25–2,50	~US$ 5–10	Próximo de 25%
Gemini Flash	~US$ 0,07–0,15	~US$ 0,30	—

Output custa 3–5× mais que input

Em quase todos os modelos, tokens de output são significativamente mais caros que de input. Otimizar o tamanho da resposta é tão importante quanto otimizar o prompt — e às vezes mais.

Técnica 1 — Prompts concisos e diretos

Cada palavra desnecessária no prompt é dinheiro queimado. Remova introduções, polidez excessiva e instruções óbvias:

❌ Verboso (52 tokens):
"Olá! Espero que você esteja bem. Eu gostaria de pedir
que você, por gentileza, me ajudasse a resumir o texto a
seguir de forma clara e concisa, se possível..."

✅ Conciso (8 tokens):
"Resuma em 3 bullets:"

Economia: ~85% no prefixo.

Cuidado para não cortar contexto que melhora a qualidade. Conciso é diferente de incompleto.

Técnica 2 — Limite explícito de output (max_tokens)

Sem limite, o modelo pode derivar e gerar respostas longas desnecessárias. Defina o teto:

// Resposta curta para classificação
await openai.chat.completions.create({
  model: 'gpt-5-mini',
  messages: [...],
  max_tokens: 50,    // garantia: não passa de 50 tokens
});

// Resposta média para resumo
max_tokens: 300

// Resposta longa para artigo (ainda assim com teto)
max_tokens: 2000

Técnica 3 — Stop sequences para parar quando completo

Quando o output tem formato previsível, defina um delimitador que para a geração assim que aparece:

await openai.chat.completions.create({
  messages: [...],
  stop: ['</answer>', '---FIM---', '\n\nQ:'],
  max_tokens: 500,
});

// Casos típicos:
// - Q&A: para no próximo "Q:"
// - JSON: para no fechamento da estrutura
// - Tags: para em </tag> específica

Técnica 4 — Prompt caching (Anthropic e OpenAI)

Quando você reutiliza grandes blocos de prompt (system prompt longo, documento de referência, lista de exemplos), prompt caching reduz drasticamente o custo dos tokens cacheados:

// Anthropic — Claude com cache_control
const response = await anthropic.messages.create({
  model: 'claude-opus-4-7',
  system: [
    {
      type: 'text',
      text: SYSTEM_PROMPT_LONGO,  // 5000 tokens
      cache_control: { type: 'ephemeral' },  // cacheia
    },
  ],
  messages: [
    {
      role: 'user',
      content: [
        {
          type: 'text',
          text: documento,                        // 20000 tokens
          cache_control: { type: 'ephemeral' },   // cacheia
        },
        { type: 'text', text: pergunta_atual },   // 50 tokens
      ],
    },
  ],
});

// Primeiro request: paga 25050 tokens normais (escreve cache)
// Requests seguintes: paga ~2555 tokens equivalentes (10% dos cacheados)
// Economia: ~90% nos tokens cacheados, ~80% no total da chamada

Cache TTL

Anthropic mantém cache por 5 minutos por padrão (refresh a cada hit). OpenAI tem cache automático em prompts > 1024 tokens. Em sistemas com chamadas frequentes para mesmo contexto, é a economia mais alta sem trade-off de qualidade.

Técnica 5 — Modelos menores em cascata

Não use Claude Opus para tudo. Use modelo menor (e barato) para tarefas simples e o modelo grande só para a etapa que realmente exige raciocínio:

// Pipeline em cascata: classificador → especialista
async function processar(query) {
  // 1. Roteador barato (Haiku ~US$ 0,80 / 1M tokens)
  const tipo = await haiku.classify({
    prompt: query,
    categorias: ['simples', 'complexa', 'criativa'],
  });

  // 2. Encaminha para o modelo certo
  if (tipo === 'simples') {
    return haiku.complete(query);    // mantém Haiku, super barato
  } else if (tipo === 'criativa') {
    return sonnet.complete(query);   // Sonnet, médio custo
  } else {
    return opus.complete(query);     // Opus só para complexas
  }
}

// Em volume típico (60% simples, 30% médio, 10% complexo):
// Custo médio cai 70–80% vs usar Opus em tudo

Técnica 6 — Compressão de histórico em chat longo

Em chats que crescem indefinidamente, sumarize turnos antigos em vez de carregar tudo:

// A cada N turnos (ex: 10), comprime histórico antigo
async function compactarHistorico(messages, MAX = 10) {
  if (messages.length <= MAX) return messages;

  const antigas = messages.slice(0, -MAX);
  const recentes = messages.slice(-MAX);

  const resumo = await haiku.complete(`
Resuma esta conversa em até 200 palavras, preservando
decisões e fatos importantes:

${antigas.map(m => `${m.role}: ${m.content}`).join('\n')}
`);

  return [
    { role: 'system', content: `Contexto da conversa anterior:\n${resumo}` },
    ...recentes,
  ];
}

// Reduz contexto de 50k para ~5k tokens em chat de longa duração.

Técnica 7 — RAG em vez de despejar contexto

Em vez de mandar 100 páginas inteiras no prompt, busque os 5–10 trechos relevantes via embedding e injete só eles:

// Sem RAG: prompt de 100k tokens (caro e lost-in-the-middle)
const resposta = await opus.complete(documentoInteiro + pergunta);
// Custo: ~US$ 1,50 por chamada com Opus

// Com RAG: busca vetorial + prompt enxuto
const trechos = await vectorDB.search(pergunta, { topK: 5 });
const prompt  = `Use APENAS os trechos abaixo:
${trechos.map(t => t.texto).join('\n\n')}

Pergunta: ${pergunta}`;
// Prompt total: ~5k tokens
// Custo: ~US$ 0,075 por chamada (95% mais barato)

Técnica 8 — Estruture output em JSON enxuto

Pedir XML ou Markdown verboso gasta tokens em formatação. JSON compacto é mais econômico:

❌ Verboso (75 tokens):
"# Análise

## Sentimento
positivo

## Confiança
alta (92%)

## Justificativa
O texto contém palavras de aprovação..."

✅ Compacto (28 tokens):
{"sent":"pos","conf":0.92,"why":"aprovação"}

Quase 3× menos tokens, mesma informação.

// Use response_format: { type: 'json_object' } para garantir JSON.

Técnica 9 — Batch API (50% off)

Para processamento offline (não interativo), Batch API da OpenAI e Anthropic oferece desconto:

// OpenAI Batch API — 50% off em troca de SLA até 24h
const file = await openai.files.create({
  file: fs.createReadStream('requests.jsonl'),
  purpose: 'batch',
});

const batch = await openai.batches.create({
  input_file_id: file.id,
  endpoint: '/v1/chat/completions',
  completion_window: '24h',
});

// Casos ideais:
// - Re-processar conteúdo histórico
// - Gerar embeddings em massa
// - Content moderation em backlog
// - Análise diária de logs

Técnica 10 — Reduza few-shot exemplos

Few-shot prompting é poderoso mas custa caro em escala. Cada exemplo é input fixo cobrado em toda chamada. Estratégias:

Use 3 exemplos em vez de 8 — geralmente o ganho marginal é pequeno depois de 3.
Coloque exemplos no system prompt com cache ativado.
Migre para fine-tuning quando o padrão é usado em escala — custo inicial maior, zero exemplos por chamada depois.

Veja o guia de few-shot prompting para escolher a quantidade ideal.

Técnica 11 — Use função/tool em vez de string parsing

Pedir resposta estruturada via function calling (tool use) é mais eficiente que pedir texto formatado e fazer parse depois:

// Tool definition (cacheia bem se reutilizado)
const tools = [{
  type: 'function',
  function: {
    name: 'classify_sentiment',
    parameters: {
      type: 'object',
      properties: {
        sentiment:  { type: 'string', enum: ['pos', 'neg', 'neu'] },
        confidence: { type: 'number', minimum: 0, maximum: 1 },
      },
      required: ['sentiment', 'confidence'],
    },
  },
}];

// Modelo retorna estrutura compacta diretamente, sem text framing.

Técnica 12 — Monitore e otimize iterativamente

Sem medição, otimização é palpite. Sempre rastreie:

Tokens médios por chamada (input e output separados)
Custo por endpoint / use case
Cache hit rate (se usa prompt caching)
Distribuição de uso por modelo
Tokens desperdiçados em chamadas que falharam ou foram canceladas

Ferramentas de observabilidade

Helicone, Langfuse, OpenTelemetry com exporters de IA integram nativamente com providers e dão dashboards de custo. Para projeto simples, log estruturado em arquivo já basta.

Estimativa de economia combinada

Economia típica por técnica (combinadas em pipeline real)
Critério	Economia estimada
Prompts concisos + max_tokens + stop sequences	10–30%
Prompt caching (hit rate 80%)	50–90% nos tokens cacheados
Modelos menores em cascata	60–80% de custo médio
RAG em vez de contexto inteiro	80–95% em casos com corpus grande
Compressão de histórico em chat	40–70% em conversas longas
Batch API para processamento offline	50% direto
Output em JSON enxuto	20–50% nos tokens de saída
Combinado (pipeline real otimizado)	60–85%

O que NÃO compensa otimizar

Cuidado com micro-otimização

Trocar palavras por sinônimos curtos (“utilizar” → “usar”) — economia irrelevante, prejudica clareza.
Comprimir abreviando ao máximo — modelo entende mal, qualidade cai.
Trocar modelo grande por pequeno em tarefa crítica só por economia — baixa qualidade acontece, custos de erro são maiores que economia.
Skip testes em produção — economia ilusória se quebra acaba custando suporte e refazimento.

Estratégia em 5 passos para reduzir custo já

Meça primeiro: instrumente para saber quanto cada endpoint gasta hoje.
Identifique o top 20% de endpoints que consomem 80% dos tokens.
Aplique técnicas de maior ROI primeiro: prompt caching, modelos em cascata, RAG.
Teste em staging: garanta que qualidade não regrediu.
Itere mensalmente: custos de IA mudam, modelos novos surgem, sempre tem ganho.

Checklist de aplicação otimizada em IA

✅ Tokens contados antes de enviar (evita estouros).
✅ max_tokens definido em toda chamada.
✅ Stop sequences quando formato é previsível.
✅ Prompt caching ativo em system prompts longos reutilizados.
✅ Cascata de modelos: roteador classifica complexidade.
✅ RAG sempre que o corpus excede 10k tokens.
✅ Histórico comprimido em chats acima de 10–20 turnos.
✅ Output em formato compacto (JSON minimal).
✅ Batch API para tudo que não exige resposta imediata.
✅ Few-shot limitado a 3–5 exemplos; fine-tuning em escala.
✅ Function calling em vez de parsing de texto.
✅ Observabilidade ativa: dashboards de custo por endpoint.

Perguntas frequentes

Quanto custa um token em 2026?+

Varia muito por modelo. GPT-5 input ~US$ 5–15 / 1M tokens; Claude Opus 4.7 ~US$ 15 / 1M; Claude Sonnet 4.6 ~US$ 3 / 1M; Gemini 2.5 Pro ~US$ 1,25–2,50 / 1M; modelos menores (GPT-5-mini, Haiku, Gemini Flash) custam de 5 a 30× menos. Output sempre custa 3–5× mais que input. Em escala (milhões de chamadas), os tokens viram linha relevante na fatura.

Vale a pena usar prompt caching?+

Vale, especialmente quando você reutiliza grandes contextos (system prompts longos, documentos de referência, definições de ferramentas). Anthropic e OpenAI suportam: marca-se a parte cacheável e em cache hit o input cacheado custa 10% (Anthropic) ou 50% (OpenAI) do preço normal. Em sistemas com hit rate alto, a economia chega a 70–90% nesses tokens.

Modelo menor sempre vence em custo?+

Em custo por token, sim — modelos menores são 5–30× mais baratos. Mas a qualidade da resposta importa. Use modelos menores para subtarefas simples (extrair, classificar, formatar) e reserve o modelo grande só para a etapa que realmente precisa de raciocínio. O padrão chama-se cascading: roteador classifica complexidade, encaminha para o modelo certo.

RAG economiza tokens?+

Sim, drasticamente, quando você tem corpus grande. Em vez de despejar 100 páginas no prompt (custosíssimo), você faz busca vetorial e injeta só os 3–5 trechos relevantes. Custo do input cai de 100k tokens para 5k. Bonus: qualidade frequentemente melhora (sem lost-in-the-middle). Custo extra: infra de embeddings + busca vetorial — mas vale a pena em qualquer escala.

Quanto vale economizar 30% em tokens?+

Depende da escala. Para um SaaS pequeno com 100 mil chamadas/mês, ~US$ 50/mês economizados — relevante mas não crítico. Para uma plataforma com 100 milhões de chamadas/mês, US$ 50 mil/mês economizados — muito relevante. A regra prática: comece a otimizar quando a fatura mensal de IA passar de US$ 500/mês.

Streaming reduz custo?+

Não reduz custo do token gerado, mas reduz custo PERCEBIDO pelo usuário (latência menor) e permite cancelar geração no meio se a resposta sair errada. Combine com max_tokens explícito e stop sequences para limitar gasto se o modelo começar a derivar. Especialmente útil em chat ao vivo.

Devo escolher temperature baixa para economizar?+

Não diretamente — temperature não afeta custo de tokens. Mas afeta consistência: temperature 0–0.3 produz respostas mais previsíveis, geralmente mais curtas e diretas, o que indiretamente reduz tokens de output. Para tarefas determinísticas (extração, classificação), temperature 0 é o padrão.

Batch API vale a pena?+

Sim, quando latência não importa. OpenAI Batch API e Anthropic Batch oferecem 50% de desconto em troca de processamento assíncrono em até 24h. Ideal para: re-processar dados históricos, gerar embeddings em massa, análise offline, content moderation em backlog. Não serve para chat em tempo real.

#tokens#chatgpt#claude#gemini#custo ia#prompt caching#rag#batch api#otimização#openai

Continue lendo

Inteligência ArtificialAI13 min de leitura

O Que São Tokens em IA (2026): Guia Completo para LLMs como GPT e Claude

Tokens explicados: o que são, como a tokenização funciona, custo por token nos principais modelos, como contar antes de enviar e estratégias para reduzir consumo.

17 de abril de 2026

Ler artigo

#tokens#ia#llm

Inteligência ArtificialAI12 min de leitura

Janela de Contexto em IA: Guia Completo (2026) com Limites por Modelo

A janela de contexto define quanto texto um LLM consegue processar de uma vez. Conheça os limites de GPT-5, Claude, Gemini e Llama em 2026, lost-in-the-middle, RAG, chunking e prompt caching.

18 de abril de 2026

Ler artigo

#janela contexto#context window#tokens

Inteligência ArtificialAI14 min de leitura

Chain-of-Thought Prompting: O Guia Completo (2026) com Exemplos

Chain-of-Thought (CoT) é a técnica de prompt que faz LLMs raciocinarem passo a passo, melhorando acurácia em até 60% em problemas complexos. Aprenda zero-shot, few-shot, Self-Consistency e Tree-of-Thoughts, com exemplos para ChatGPT, Claude e Gemini.

18 de abril de 2026

Ler artigo

#chain of thought#prompt engineering#chatgpt

Inteligência ArtificialAI13 min de leitura

Few-Shot Prompting: Como Ensinar Padrões à IA com Exemplos (2026)

Few-shot prompting é a técnica mais confiável para garantir formato e consistência em saídas de LLMs. Aprenda zero-shot vs one-shot vs few-shot, quantos exemplos usar, combinação com Chain-of-Thought e quando migrar para fine-tuning.

18 de abril de 2026

Ler artigo

#few shot#prompting#ia