Tokens de entrada vs saída: custo do Claude

Por que os tokens de saída custam mais do que os tokens de entrada

Os tokens de saída custam cinco vezes mais do que os tokens de entrada em todos os modelos Claude do catálogo atual. A causa está na forma como o cálculo é executado. A leitura de um prompt exige uma passagem pelo modelo. A geração de uma resposta exige uma passagem por token, e cada passagem tem de esperar pela anterior.

Essa proporção é igual em todas as linhas da tabela de preços. Portanto, o modelo escolhido não altera quanto da sua fatura corresponde à saída. Isso depende do perfil da carga de trabalho. Uma etapa de agente que lê 60,000 tokens e responde com 800 quase não tem custos de saída. Um trabalho de redação que lê 2,000 tokens e escreve 12,000 quase não tem custos de entrada. Os dois casos são calculados abaixo com base nas tarifas publicadas pela Anthropic em August 2026.

O prefill é executado uma vez; a descodificação é executada uma vez por token

Um servidor de inferência processa um pedido em duas fases com custos muito diferentes. O prefill lê o prompt. A descodificação gera a resposta.

O prefill processa o prompt completo de uma só vez. Todos os tokens do prompt entram na rede na mesma passagem forward, por isso o trabalho de attention e feed-forward transforma-se num pequeno número de multiplicações de matrizes grandes, abrangendo milhares de tokens de cada vez. Uma leitura dos pesos do modelo a partir da memória é suficiente para processar todo o prompt. As unidades de matrizes do acelerador mantêm-se ocupadas, o que significa que o prefill é limitado pelo processamento: o limite é a velocidade a que o chip consegue multiplicar.

A descodificação não pode funcionar dessa forma, porque o token 2 depende do token 1. O token que o modelo acabou de produzir passa a fazer parte da entrada do passo seguinte, por isso os passos não podem ser executados ao mesmo tempo. Cada token de saída tem a sua própria passagem forward, e cada uma dessas passagens lê o conjunto completo de pesos do modelo a partir da memória de alta largura de banda para produzir um único token. Isto torna a descodificação limitada pela memória: o limite é a velocidade a que os pesos podem ser transferidos, não a velocidade a que podem ser multiplicados. O mesmo tráfego de pesos que processou um prompt completo durante o prefill produz um token durante a descodificação.

Os sistemas de serving compensam esta limitação através de batching. Muitos pedidos são descodificados em conjunto, por isso uma leitura dos pesos produz um token para cada pedido no batch. É por isso que a descodificação é viável. O limite continua a ser a memória. Cada pedido em processamento mantém uma KV cache (key/value cache, o estado de attention armazenado para cada token produzido até ao momento). Essa cache cresce a cada token gerado e, quando ocupa todo o acelerador, o batch já não pode crescer.

Nada disso fornece um número exato, e não deve interpretar 5x como uma proporção de hardware medida. É um preço definido pela Anthropic e influenciado por essa assimetria. O que pode verificar por si próprio é a direção, e isso demora cerca de um minuto.

Meça você mesmo a latência de entrada e saída

Instale as ferramentas em qualquer máquina Ubuntu:

sudo apt update && sudo apt install -y curl jq moreutils

Agora transmita um prompt curto que peça uma resposta longa e registe a hora de chegada de cada linha.

curl -sN https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-5","max_tokens":1000,"stream":true,
       "messages":[{"role":"user","content":"Count from 1 to 300, one number per line."}]}' \
  | ts -s '%.s'

ts -s acrescenta a cada linha os segundos decorridos desde o início do comando. Há dois valores importantes nesse resultado. A primeira linha content_block_delta corresponde ao tempo até ao primeiro token, e todo o prefill ocorreu dentro desse intervalo. Cada linha seguinte representa um pequeno passo de decoding, e os valores de tempo continuam a aumentar até chegar message_stop.

Agora inverta o formato. Coloque um documento longo no prompt e limite a resposta a alguns tokens.

curl -sN https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d "$(jq -n --rawfile doc ./long-document.txt \
       '{model:"claude-sonnet-5", max_tokens:16, stream:true,
         messages:[{role:"user", content:("Answer in one word. Is this document about networking?\n\n" + $doc)}]}')" \
  | ts -s '%.s'

O primeiro delta demora mais do que no prompt curto, porque o prefill tem muito mais texto para ler. Quando chega, a resposta termina quase imediatamente, porque restam apenas alguns tokens para o decoding. Entraram dezenas de milhares de tokens e o relógio quase não avançou. Saíram algumas centenas e o relógio esteve a contar durante todo o processo.

Todas as respostas sem streaming terminam com os números usados para calcular a cobrança.

{
  "usage": {
    "input_tokens": 41283,
    "output_tokens": 6,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

Registe os quatro campos de cada pedido. output_tokens inclui o extended thinking, por isso um modelo que pensa antes de responder cobra esse processamento à taxa de saída. Para calcular o preço de um prompt antes de o enviar, POST /v1/messages/count_tokens aceita o mesmo corpo do pedido, devolve {"input_tokens": N} sem executar o modelo e é gratuito.

Quanto custa o Claude por milhão de tokens em agosto de 2026

[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5,
    "output_multiple": 5
  },
  {
    "label": "Sonnet 5 (to 31 Aug)",
    "input_usd": 2,
    "output_usd": 10,
    "output_multiple": 5
  },
  {
    "label": "Sonnet 5 (from 1 Sep)",
    "input_usd": 3,
    "output_usd": 15,
    "output_multiple": 5
  },
  {
    "label": "Opus 5",
    "input_usd": 5,
    "output_usd": 25,
    "output_multiple": 5
  },
  {
    "label": "Fable 5",
    "input_usd": 10,
    "output_usd": 50,
    "output_multiple": 5
  }
]

A última coluna é a saída dividida pela entrada e mostra 5 em todas as linhas. O Haiku 4.5 cobra $1 pela entrada e $5 pela saída. O Opus 5 cobra $5 pela entrada e $25 pela saída. O Fable 5, o mais caro, cobra $10 pela entrada e $50 pela saída, e vale a pena ler o que essas tarifas do Fable 5 permitem fazer antes de descartar essa linha superior. Ao subir na gama, ambos os lados são multiplicados pelo mesmo fator. Isso altera o total, mas mantém exatamente a mesma proporção entre entrada e saída.

O Sonnet 5 aparece duas vezes porque a tarifa introdutória expira. Até 31 de agosto de 2026, cobra $2 pela entrada e $10 pela saída. A partir de 1 de setembro de 2026, aplica-se a tarifa padrão de $3 pela entrada e $15 pela saída, que é 50% mais alta em ambos os lados. Todos os exemplos abaixo usam a tarifa de agosto.

As tarifas mudam, e esta página não é o local onde deve consultá-las. claude.com/pricing é a fonte oficial. O que permanece válido quando os preços mudam é o método.

Há uma ressalva que a tabela de preços não mostra. A documentação da Anthropic afirma que os modelos Claude 4.7 e posteriores usam um tokenizer mais recente, que produz aproximadamente 30% mais tokens para o mesmo texto do que o tokenizer usado no Sonnet 4.6 e anteriores. Comparar dois modelos apenas pelo preço por milhão de tokens favorece o modelo mais recente, porque o mesmo documento resulta em mais tokens nele. Compare o custo por tarefa concluída e contabilize os seus prompts reais no modelo que pretende usar. o que vale, na prática, um milhão de tokens do Claude explica como esse volume se traduz em texto real.

Quando é que a saída começa a dominar os custos?

Com a saída tarifada a 5 vezes o preço da entrada, o ponto de equilíbrio é fácil de calcular mentalmente. Considere I como o número de tokens de entrada e O como o número de tokens de saída. A entrada custa I. A saída custa 5 vezes O. A saída representa mais de metade dos custos quando 5 vezes O é maior que I, o que corresponde a uma proporção de 5 tokens de entrada para 1 token de saída.

Assim, se o seu prompt for mais de cinco vezes maior que a resposta, a entrada representa o maior custo. Abaixo dessa proporção, é a saída.

[
  {
    "label": "100:1",
    "input_share_pct": 95.2,
    "output_share_pct": 4.8
  },
  {
    "label": "75:1",
    "input_share_pct": 93.75,
    "output_share_pct": 6.25
  },
  {
    "label": "20:1",
    "input_share_pct": 80,
    "output_share_pct": 20
  },
  {
    "label": "10:1",
    "input_share_pct": 66.7,
    "output_share_pct": 33.3
  },
  {
    "label": "5:1",
    "input_share_pct": 50,
    "output_share_pct": 50
  },
  {
    "label": "1:1",
    "input_share_pct": 16.7,
    "output_share_pct": 83.3
  },
  {
    "label": "1:6",
    "input_share_pct": 3.2,
    "output_share_pct": 96.8
  }
]

Numa proporção de 100 para 1, a saída representa 4.8% dos custos, e reduzir o prompt é a única intervenção que vale a pena. Numa proporção de 5 para 1, os dois custos são iguais. Numa proporção de 1 para 6, a saída representa 96.8% dos custos e o prompt tem um impacto residual. A maioria das pessoas estima incorretamente a sua própria proporção, por isso obtenha-a a partir dos seus logs antes de otimizar qualquer coisa.

Uma carga de trabalho de agente: contexto longo na entrada, resposta curta na saída

Execute uma etapa de um agente de recuperação: 60,000 tokens de documentos recuperados e histórico da conversa na entrada, e uma resposta de 800 tokens. Isto corresponde a 75 para 1, o que é normal em qualquer processo que lê antes de escrever.

[
  {
    "label": "Haiku 4.5",
    "input_cost": 0.06,
    "output_cost": 0.004,
    "total_cost": 0.064
  },
  {
    "label": "Sonnet 5 (Aug)",
    "input_cost": 0.12,
    "output_cost": 0.008,
    "total_cost": 0.128
  },
  {
    "label": "Opus 5",
    "input_cost": 0.3,
    "output_cost": 0.02,
    "total_cost": 0.32
  },
  {
    "label": "Fable 5",
    "input_cost": 0.6,
    "output_cost": 0.04,
    "total_cost": 0.64
  }
]

A saída representa 6.25% dessa chamada em todos os modelos, porque o rácio é fixo em toda a tabela de preços. A chamada custa $0.32 no Opus 5, $0.128 no Sonnet 5 à taxa de agosto e $0.064 no Haiku 4.5. Duzentas dessas etapas por dia no Opus 5 custam $64 por dia.

A diferença fica evidente quando se separa a entrada da saída. Reduzir a resposta de 800 tokens para 400 poupa cerca de 3% do custo da chamada. Remover 20,000 tokens de contexto obsoleto do prompt poupa cerca de um terço do custo. Reduzir o comprimento da saída num agente orientado para leitura é quase um esforço desperdiçado. onde vão realmente os tokens de um agente de programação explica o que preenche esse prompt.

Uma carga de geração: prompt curto, rascunho longo

Agora inverta a proporção. Um briefing de 2,000 tokens, um rascunho de 12,000 tokens, numa proporção de 1 para 6.

[
  {
    "label": "Haiku 4.5",
    "input_cost": 0.002,
    "output_cost": 0.06,
    "total_cost": 0.062,
    "batch_total_cost": 0.031
  },
  {
    "label": "Sonnet 5 (Aug)",
    "input_cost": 0.004,
    "output_cost": 0.12,
    "total_cost": 0.124,
    "batch_total_cost": 0.062
  },
  {
    "label": "Opus 5",
    "input_cost": 0.01,
    "output_cost": 0.3,
    "total_cost": 0.31,
    "batch_total_cost": 0.155
  },
  {
    "label": "Fable 5",
    "input_cost": 0.02,
    "output_cost": 0.6,
    "total_cost": 0.62,
    "batch_total_cost": 0.31
  }
]

A saída representa 96.8% deste custo. O Opus 5 custa $0.31 por rascunho, contra $0.062 no Haiku 4.5. Essa diferença de cinco vezes vem quase toda da saída, precisamente onde um modelo mais barato permite poupar mais.

A última coluna mostra o mesmo trabalho através da Batch API, que reduz em 50% o custo da entrada e da saída. O Opus 5 passa a custar $0.155 por rascunho. A Batch devolve os resultados no prazo de 24 horas, em vez de imediatamente, por isso é adequada para gerar relatórios durante a noite e para classificação em massa. Não é adequada para tarefas em que uma pessoa fica à espera do resultado.

O encaminhamento entre modelos compensa neste caso, ao contrário do que acontece na etapa do agente. Se a parte extensa do trabalho for mecânica, como reformatar texto ou expandir um esquema já aprovado, o modelo barato produz esses tokens por um quinto do preço. escolher entre Opus, Sonnet e Haiku explica onde está realmente o limite de qualidade.

O cache reduz o custo do input, e apenas do input

O cache de prompts armazena um prefixo do seu prompt no servidor e cobra uma fração da tarifa de input para o ler novamente. Em agosto de 2026, os multiplicadores são 1.25x da tarifa base de input para gravar um cache de 5 minutos, 2x para gravar um cache de 1 hora e 0.1x para ler um cache existente.

O output não está incluído nesse mecanismo. Não existe output em cache. Cada token escrito pelo modelo é cobrado sempre à tarifa total de output, independentemente da quantidade do prompt que tenha sido devolvida a partir do cache.

Considere o mesmo passo do agente no Opus 5, com 55,000 dos 60,000 tokens de input servidos a partir de um cache aquecido.

[
  {
    "label": "No cache",
    "input_cost": 0.3,
    "output_cost": 0.02,
    "total_cost": 0.32
  },
  {
    "label": "55k prefix cache read",
    "input_cost": 0.0525,
    "output_cost": 0.02,
    "total_cost": 0.0725
  }
]

A chamada passa de $0.32 para $0.0725. A linha do output não muda: $0.02 antes e $0.02 depois. O cache reduz a fatura e altera a sua composição. O output representava 6.25% dessa chamada. Agora representa mais de um quarto do total, o que altera qual é a próxima alavanca que vale a pena ajustar.

A primeira chamada paga a gravação. Gravar um cache de 5 minutos custa 1.25x a tarifa base de input, por isso recupera o custo após uma única leitura. Gravar um cache de 1 hora custa 2x, por isso exige duas leituras. os multiplicadores de gravação e leitura e quando o cache deixa de compensar explica essa aritmética.

Quatro variáveis que pode controlar

1. Defina max_tokens no comprimento de saída p95, não no máximo do modelo.
2. Encaminhe as etapas verbosas para um modelo mais barato.
3. Coloque em lote tudo aquilo por que ninguém está à espera.
4. Elimine as instruções que aumentam o comprimento das respostas.

max_tokens é um limite rígido. Defini-lo com um valor alto não tem, por si só, qualquer custo, porque a cobrança é feita pelos tokens produzidos e nunca pelo limite. O que um limite generoso faz é remover a restrição de uma resposta que corre mal. Extraia a distribuição de output_tokens dos seus logs, defina o limite um pouco acima do percentil 95 e trate stop_reason: "max_tokens" no código, continuando a resposta ou repetindo o pedido. Uma truncagem detetada custa menos do que uma resposta de 4,000 tokens que paga e descarta. O raciocínio prolongado também entra em output_tokens, por isso defina esse orçamento com base nos mesmos dados.

O encaminhamento funciona quando a parte dispendiosa de uma etapa é o volume, e não o julgamento. Mantenha o modelo mais forte na decisão e passe a redação para algo mais barato. Primeiro, avalie a versão encaminhada no seu próprio conjunto de avaliação, porque um modelo barato que precisa de duas tentativas custa mais do que uma tentativa com um modelo caro.

O processamento em lote é a única variável que reduz o custo da saída. Tem um desconto de 50% nos dois lados, resultados no prazo de 24 horas e qualquer tarefa agendada é elegível.

A última variável é a que muitas pessoas ignoram. Expressões como "seja exaustivo" e "explique o seu raciocínio" definem o comprimento da saída em todas as chamadas que fizer. Substitua-as pelo formato pretendido: "Responda em no máximo três frases" ou "Retorne apenas o objeto JSON, sem preâmbulo". Um system prompt que acrescenta 300 tokens a cada resposta custa cinco vezes mais do que os mesmos 300 tokens custam no prompt. manter sob controlo os custos de um agente em execução aborda o acompanhamento, e se a API ou uma subscrição fixa é mais barata para o seu padrão é uma decisão que vale a pena tomar antes de passar uma semana a otimizar o custo por token que uma subscrição teria absorvido.

FAQ

Porque é que os tokens de saída custam mais do que os tokens de entrada?

A geração exige muito mais tempo do acelerador por token. Um prompt é processado numa única passagem para a frente sobre todo o conteúdo, pelo que uma única leitura dos pesos do modelo abrange milhares de tokens e o hardware fica limitado pelo débito de multiplicações. Uma resposta é produzida um token de cada vez. Cada token exige a sua própria passagem para a frente, que volta a ler todos os pesos do modelo, pelo que o hardware fica limitado pela largura de banda da memória. A Anthropic cobra cinco vezes mais pela saída do que pela entrada em todo o catálogo atual, desde Haiku 4.5 até Fable 5.

O armazenamento em cache do prompt torna os tokens de saída mais baratos?

Não. O armazenamento em cache do prompt aplica-se apenas à entrada. Em agosto de 2026, uma leitura da cache custa 0.1x a tarifa base de entrada, e as gravações na cache custam 1.25x durante 5 minutos ou 2x durante 1 hora. A saída é faturada à tarifa total em todas as chamadas, independentemente do que aconteceu com a cache. É por isso que o armazenamento em cache altera tanto a estrutura como o valor da fatura: quando o custo da entrada diminui drasticamente, a saída passa a ser a parte que mais compensa reduzir.

Um max_tokens elevado custa-me dinheiro se a resposta for curta?

Não. A faturação baseia-se nos tokens que o modelo produz efetivamente, pelo que max_tokens é um limite máximo, não uma reserva. Ainda assim, este valor é importante porque é o único limite rígido para uma resposta que se prolongue demasiado. Defina-o ligeiramente acima do percentil 95 do seu output_tokens observado e trate stop_reason: "max_tokens" no código, em vez de publicar uma resposta truncada silenciosamente.

Como descubro a minha própria relação entre tokens de entrada e de saída?

Registe input_tokens, output_tokens, cache_read_input_tokens e cache_creation_input_tokens a partir do objeto usage de todas as respostas e divida os totais ao longo de uma semana. Acima de 5 tokens de entrada para 1 de saída, o custo está no prompt. Coloque a parte estável em cache e reduza o restante. Abaixo dessa relação, o custo está na resposta. Limite o seu comprimento e transfira para um modelo mais barato ou para a Batch API os passos que geram a maior parte dela.