Quanto Custa Claude Sonnet 4.6: Preços e Custos Reais

Em Resumo:

O Claude Sonnet 4.6 custa $3 por milhão de tokens de entrada e $15 por milhão de tokens de saída — o mesmo preço do Sonnet 4.5, enquanto entrega um desempenho quase Opus. Com cache de prompt, as leituras de cache caem para $0.30/MTokens (90% de economia). A API em Lote reduz os custos pela metade para $1.50/$7.50 por MTokens. A janela de contexto de 1M tokens (beta) aciona preços de contexto longo a $6/$22.50 por MTokens para solicitações acima de 200K tokens.

Preços Base do Claude Sonnet 4.6

O Claude Sonnet 4.6 mantém o mesmo ponto de preço de seu predecessor, ao mesmo tempo em que oferece resultados significativamente melhores. Aqui está o preço principal em um relance:

MTokens = milhões de tokens. Todos os preços em USD.

A história de valor aqui é difícil de ignorar. Testadores iniciais preferiram o Sonnet 4.6 ao modelo premium anterior Opus 4.5 em 59% das comparações diretas — a 60% do custo.

Para a maioria das tarefas de codificação, análise e agentes, você não precisa mais pagar preços de Opus para obter resultados de nível Opus.

Detalhes Completos dos Preços por Recurso

Preços da API Padrão

As tarifas padrão se aplicam a todas as chamadas de API síncronas feitas através da API da Anthropic:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Summarize this document."}]
)

# Check exact token usage
print(f"Input tokens: {response.usage.input_tokens}")
print(f"Output tokens: {response.usage.output_tokens}")

# Calculate cost
input_cost  = response.usage.input_tokens  / 1_000_000 * 3.00
output_cost = response.usage.output_tokens / 1_000_000 * 15.00
print(f"Request cost: ${input_cost + output_cost:.6f}")

Para uma chamada de API típica com 500 tokens de entrada e 300 tokens de saída, o custo é de aproximadamente $0.0060. Isso é menos de um centavo por solicitação nas taxas padrão.

Preços de Cache de Prompt

O cache de prompt é a alavanca de custo mais impactante do Sonnet 4.6. Ele armazena partes do seu prompt no servidor e cobra dramaticamente menos em acertos de cache.

Taxas de gravação de cache:- Cache de 5 minutos: $3.75/MTokens (1.25× o preço base de entrada) - Cache de 1 hora: $6.00/MTokens (2× o preço base de entrada)

Taxa de leitura de cache:- $0.30/MTokens — um décimo do preço padrão de entrada

Se o seu prompt de sistema tiver 10.000 tokens e você processar 1.000 solicitações por dia: - Sem cache: 10.000 × 1.000 × $3/MTokens = $30/dia- Com cache (gravar uma vez, ler 999×): $3.75 + (999 × 0.30) × 10.000/MTokens ≈ $3.04/dia

Isso representa uma redução de 90% apenas para um prompt de sistema estático.

import anthropic

client = anthropic.Anthropic()

# Mark expensive static content for caching
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "You are a senior code reviewer specializing in Python, FastAPI, and distributed systems. Here are our coding standards and review guidelines: [large block of standards text]...",
            "cache_control": {"type": "ephemeral"}  # Cache this block
        }
    ],
    messages=[{"role": "user", "content": "Review this pull request: [PR content]"}]
)

# Check what came from cache vs fresh tokens
usage = response.usage
print(f"Cache write tokens: {usage.cache_creation_input_tokens}")
print(f"Cache read tokens:  {usage.cache_read_input_tokens}")
print(f"Uncached tokens:    {usage.input_tokens}")

Quando usar cada duração de cache:- Cache de 5 minutos: Chamadas de alta frequência, tráfego intermitente, janelas de conversação curtas - Cache de 1 hora: Pipelines de processamento em segundo plano, trabalhos em lote com intervalos maiores, loops de agentes

Preços da API em Lote

A API em Lote oferece um desconto fixo de 50% nos tokens de entrada e saída em troca de processamento assíncrono (resultados disponíveis em 24 horas, geralmente muito mais cedo).

Melhores casos de uso para a API em Lote:- Pipelines de moderação de conteúdo - Classificação de documentos em escala - Enriquecimento de dados durante a noite - Geração de embeddings ou resumos para grandes conjuntos de dados - Qualquer processamento não interativo onde a latência não importa

A $1.50/$7.50/MTokens, o processamento de um milhão de documentos, cada um com 500 tokens de entrada e 100 tokens de saída, custa: - Entrada: 500M tokens × $1.50/MTokens = $750- Saída: 100M tokens × $7.50/MTokens = $750- Total: $1.500 para 1 milhão de documentos (~$0.0015 por documento)

API em Lote: 50% de Desconto para Cargas de Trabalho Não em Tempo Real

O processamento em lote é direto: envie solicitações, obtenha resultados assincronamente pela metade do preço. A desvantagem é a latência — os resultados chegam em 24 horas, embora geralmente muito mais rápido.

import anthropic, time

client = anthropic.Anthropic()

def batch_classify(texts: list[str]) -> list[str]:
    """Classifica uma lista de textos nas taxas da API em Lote."""

    # Submit batch
    requests = [
        {
            "custom_id": f"item-{i}",
            "params": {
                "model": "claude-sonnet-4-6",
                "max_tokens": 20,
                "messages": [{
                    "role": "user",
                    "content": f"Classify as POSITIVE, NEGATIVE, or NEUTRAL. Reply with one word only.\n\n{text}"
                }]
            }
        }
        for i, text in enumerate(texts)
    ]

    batch = client.messages.batches.create(requests=requests)

    # Poll until complete
    while True:
        status = client.messages.batches.retrieve(batch.id)
        if status.processing_status == "ended":
            break
        time.sleep(60)

    # Collect results in order
    results = {}
    for result in client.messages.batches.results(batch.id):
        if result.result.type == "succeeded":
            results[result.custom_id] = result.result.message.content[0].text.strip()

    return [results.get(f"item-{i}", "ERROR") for i in range(len(texts))]

Preços de Contexto Longo (1M Tokens)

Quando você habilita a janela de contexto de 1M tokens através do cabeçalho beta context-1m-2025-08-07, as solicitações que excedem 200K tokens de entrada são cobradas a uma taxa mais alta.

Tabela de Taxas de Contexto Longo

O limite de 200K é baseado no total de tokens de entrada, que inclui: - input_tokens (entrada padrão) - cache_creation_input_tokens (se estiver usando cache de prompt) - cache_read_input_tokens (se estiver usando cache de prompt)

Se o total exceder 200K, todos os tokens nessa solicitação serão cobrados com a taxa mais alta.

Contexto Longo + API em Lote

O desconto de 50% da API em Lote se acumula com os preços de contexto longo:

O processamento de grandes documentos em massa via API em Lote mantém os custos de contexto longo gerenciáveis.

Preços de Ferramentas e Recursos

Várias ferramentas possuem custos adicionais além dos custos de tokens.

Ferramenta de Busca na Web

$10.00 por 1.000 buscas
+ custos de tokens padrão para conteúdo gerado pela busca

Cada chamada de busca na web conta como um uso, independentemente de quantos resultados são retornados. Nenhuma cobrança se a busca falhar.

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    betas=["code-execution-web-tools-2026-02-09"],
    tools=[{"type": "web_search_20260209", "name": "web_search"}],
    messages=[{"role": "user", "content": "What's the latest LLM benchmark news from this week?"}]
)

usage = response.usage
search_count = getattr(usage, 'server_tool_use', {})
print(f"Web searches used: {search_count.get('web_search_requests', 0)}")
# Cada busca: $0.01

Ferramenta de Execução de Código

Gratuito quando empacotado com busca na web ou web fetch (usando as versões de ferramenta web_search_20260209 ou web_fetch_20260209).

Quando usado de forma independente: - 1.550 horas gratuitas por organização por mês - $0.05 por hora por contêiner além do nível gratuito - Unidade mínima de cobrança: 5 minutos

Para a maioria das cargas de trabalho de desenvolvimento e teste, o nível gratuito é mais do que suficiente.

Ferramenta Web Fetch

Sem cobranças adicionais. Você paga apenas os custos de tokens padrão para o conteúdo que entra na conversa.

Sobrecarga de Uso do Computador

O uso do computador adiciona uma sobrecarga fixa de tokens: - Adição de prompt de sistema: 466–499 tokens - Tokens de definição de ferramenta: 735 tokens por ferramenta (modelos Claude 4.x)

Para uma sessão de uso do computador com 100 turnos a 200 tokens/turno mais capturas de tela: - Sobrecarga da ferramenta: 735 tokens × $3/MTokens = $0.0022 (desprezível) - Os tokens de captura de tela dependem da resolução; planeje ~2.000–5.000 tokens por captura de tela

Claude Sonnet 4.6 vs Todos os Modelos: Comparação Completa

Preços Atuais dos Modelos

Todos os preços em USD por milhão de tokens.

Sonnet 4.6 vs Opus 4.6: A Questão do Valor

Para a vasta maioria das tarefas — codificação, análise, processamento de documentos, fluxos de trabalho de agentes — o Sonnet 4.6 iguala o desempenho do Opus a 60% do preço. O Opus 4.6 vale o prêmio quando você precisa de 128K tokens de saída ou o máximo absoluto em tarefas de raciocínio inovadoras.

Sonnet 4.6 vs Haiku 4.5: Quando Usar Cada Um

O padrão inteligente: use o Haiku 4.5 para roteamento, classificação e extração simples; encaminhe tarefas complexas para o Sonnet 4.6. Essa abordagem híbrida geralmente custa 60–80% menos do que o Sonnet 4.6 para tudo.

Testando Custos com Apidog Antes de Entrar em Produção

Antes de implantar em produção, você quer saber exatamente quanto custa cada solicitação. O cliente de API visual do Apidog permite testar chamadas do Claude Sonnet 4.6, inspecionar a resposta completa, incluindo o objeto usage, e rastrear a contagem de tokens por solicitação.

Configurar Visibilidade de Custos no Apidog

1. Crie uma nova solicitação POST para https://api.anthropic.com/v1/messages
2. Adicione os cabeçalhos: x-api-key, anthropic-version: 2023-06-01, Content-Type: application/json
3. Defina o corpo com seu modelo e mensagens
4. Execute a solicitação — o objeto usage da resposta mostra a contagem exata de tokens

{
  "usage": {
    "input_tokens": 523,
    "cache_creation_input_tokens": 5000,
    "cache_read_input_tokens": 0,
    "output_tokens": 312
  }
}

A partir desses números, calcule o custo real: - Entrada: 523 tokens × $3/MTokens = $0.00157 - Gravação de cache: 5.000 tokens × $3.75/MTokens = $0.01875 - Saída: 312 tokens × $15/MTokens = $0.00468 - Total da primeira chamada: $0.025 (chamadas subsequentes com acerto de cache: ~$0.006)

Você pode salvar essas solicitações como uma coleção no Apidog, compartilhá-las com sua equipe e executar estimativas de custo em diferentes variações de prompt antes de finalizar seu design de produção.

Pronto para começar a construir? Baixe o Apidog gratuitamente para testar visualmente as chamadas da API Claude Sonnet 4.6, inspecionar o uso de tokens por solicitação e dimensionar seus custos com precisão antes de implantar.