Todo mundo fala em integrar IA nos seus produtos. Poucos falam sobre a fatura que chega no final do mês.
Na Soamee, passamos dois anos construindo funcionalidades de IA para clientes de diferentes setores: desde chatbots de suporte até sistemas RAG para processamento de documentos jurídicos. Nesse tempo, aprendemos que o custo real de executar LLMs em produção tem muito pouco a ver com o que se imagina no início. As surpresas, quase sempre, vão na direção errada.
Este é o artigo que eu gostaria de ter tido quando começamos. Números reais, cenários concretos e estratégias que funcionam.
Preços de tokens em 2025-2026: a tabela que você precisa
Antes de falar sobre cenários, precisamos ter claros os preços base. Os modelos relevantes hoje em produção são estes:
| Modelo | Input (por 1M tokens) | Output (por 1M tokens) | Contexto máx. | Notas |
|---|---|---|---|---|
| GPT-4o | $2,50 | $10,00 | 128K | Modelo principal OpenAI |
| GPT-4o mini | $0,15 | $0,60 | 128K | Ideal para tarefas simples |
| o3-mini | $1,10 | $4,40 | 200K | Raciocínio, mais lento |
| Claude Sonnet 4 | $3,00 | $15,00 | 200K | Melhor relação qualidade/preço |
| Claude Haiku 3.5 | $0,80 | $4,00 | 200K | Econômico e rápido |
| Claude Opus 4 | $15,00 | $75,00 | 200K | Capacidade máxima |
| Gemini 2.5 Pro | $1,25 | $10,00 | 1M | Cache de contexto agressivo |
| Gemini 2.5 Flash | $0,075 | $0,30 | 1M | Ultra-econômico |
| Llama 3.3 70B | ~$0,20-0,60 | ~$0,20-0,60 | 128K | Self-hosted ou via Bedrock/Together |
Uma observação importante: o preço por token é o custo dos próprios tokens gerados ou consumidos. Em produção real, o prompt de sistema (que se repete em cada chamada), o histórico de conversa e o contexto RAG inflam enormemente a contagem de tokens de entrada. É o erro mais comum nas estimativas de custo.
Cenários reais: quanto custa exatamente?
Vamos com números concretos para os quatro casos de uso mais comuns.
Cenário 1: Chatbot de atendimento ao cliente (1.000 consultas/dia)
Parâmetros típicos:
- Prompt de sistema: 500 tokens (instruções, tom, FAQ base)
- Histórico de conversa médio: 800 tokens (4-5 turnos)
- Consulta do usuário: 100 tokens
- Resposta do modelo: 300 tokens
Total por chamada: ~1.400 tokens de entrada + 300 tokens de saída
| Modelo | Custo/chamada | Custo/dia (1K chamadas) | Custo/mês |
|---|---|---|---|
| GPT-4o | $0,0064 | $6,40 | ~$192 |
| GPT-4o mini | $0,00039 | $0,39 | ~$12 |
| Claude Sonnet 4 | $0,0087 | $8,70 | ~$261 |
| Claude Haiku 3.5 | $0,0023 | $2,30 | ~$69 |
| Gemini 2.5 Flash | $0,000195 | $0,20 | ~$6 |
Para um chatbot simples com volume baixo-médio, GPT-4o mini, Claude Haiku ou Gemini Flash são opções perfeitamente válidas a custo mínimo. A questão central é se a qualidade das respostas é suficiente para o seu caso de uso.
Cenário 2: Processamento de documentos (500 docs/dia, ~5 páginas cada)
Os documentos mudam radicalmente a equação. Uma página A4 tem aproximadamente 400-500 palavras, o que equivale a cerca de 500-600 tokens.
Parâmetros:
- Documento de 5 páginas: ~2.500 tokens de entrada
- Prompt de instruções: 300 tokens
- Resumo/extração gerada: 500 tokens
Total por documento: ~2.800 tokens de entrada + 500 tokens de saída
| Modelo | Custo/documento | Custo/dia (500 docs) | Custo/mês |
|---|---|---|---|
| GPT-4o | $0,0120 | $6,00 | ~$180 |
| Claude Sonnet 4 | $0,0165 | $8,25 | ~$248 |
| Gemini 2.5 Pro | $0,0085 | $4,25 | ~$128 |
| Gemini 2.5 Flash | $0,00059 | $0,30 | ~$9 |
Para processamento de documentos onde a precisão é crítica (contratos, documentação médica, financeira), Claude Sonnet ou GPT-4o justificam o custo adicional. Para extração de dados estruturados em documentos mais simples, Gemini Flash oferece um ROI imbatível.
Cenário 3: Assistente de código (200 desenvolvedores ativos/dia)
Um assistente de código tem um perfil de tokens bem diferente: os trechos de código são densos em tokens (o código com sua sintaxe consome mais tokens por caractere que o texto natural).
Parâmetros estimados por sessão:
- Contexto de código: 3.000 tokens
- Histórico de conversa: 1.500 tokens
- Prompt de sistema: 400 tokens
- Resposta com código: 800 tokens
- Média: 4 interações/sessão
Total por sessão: ~23.600 tokens de entrada + 3.200 tokens de saída
| Modelo | Custo/sessão | Custo/dia (200 devs) | Custo/mês |
|---|---|---|---|
| GPT-4o | $0,091 | $18,20 | ~$546 |
| Claude Sonnet 4 | $0,119 | $23,80 | ~$714 |
| Gemini 2.5 Pro | $0,062 | $12,40 | ~$372 |
Para assistentes de código em equipes de médio porte, o custo oscila entre $370 e $714/mês dependendo do modelo. Nada exorbitante, mas há margem significativa de otimização com caching do contexto do projeto.
Cenário 4: Sistema RAG (base documental + 2.000 consultas/dia)
Os sistemas RAG adicionam uma camada: o retrieval traz fragmentos relevantes de um banco de dados vetorial que são inseridos no prompt de cada consulta.
Parâmetros:
- Fragmentos recuperados: 3 chunks × 400 tokens = 1.200 tokens
- Prompt de sistema: 600 tokens
- Consulta do usuário: 150 tokens
- Resposta gerada: 400 tokens
Total por consulta: ~1.950 tokens de entrada + 400 tokens de saída
| Modelo | Custo/consulta | Custo/dia (2K consultas) | Custo/mês |
|---|---|---|---|
| GPT-4o | $0,0089 | $17,80 | ~$534 |
| Claude Sonnet 4 | $0,0122 | $24,40 | ~$732 |
| Gemini 2.5 Flash | $0,000267 | $0,53 | ~$16 |
| Llama 3.3 70B (self-hosted) | ~$0,0005 | ~$1,00 | ~$30 |
Em RAG com alto volume, a diferença entre modelos premium e econômicos começa a ser muito relevante.
Os custos ocultos que ninguém menciona
Os tokens são apenas a ponta do iceberg. Em produção real, várias categorias de custo são ignoradas nas estimativas iniciais:
Infraestrutura e observabilidade
- Banco de dados vetorial: Pinecone começa em $70/mês para um índice pequeno. Weaviate Cloud ou Qdrant têm opções mais baratas a partir de $25/mês. Self-hosted adiciona custo de DevOps.
- Monitoramento e rastreabilidade: Ferramentas como LangSmith (a partir de $39/mês), Langfuse (open source com self-hosting) ou Helicone (a partir de $20/mês) são imprescindíveis em produção. Sem elas, depurar um agente que falha é um pesadelo.
- API gateway e rate limiting: Gerenciar rate limits, tentativas e fallbacks requer uma solução SaaS ou tempo de engenharia.
Latência e seu custo indireto
A latência dos LLMs é real e tem custo de negócio:
- GPT-4o: 500-1.500 ms tempo até o primeiro token
- Claude Sonnet 4: 400-1.200 ms
- Gemini 2.5 Flash: 200-600 ms
- Llama 3.3 70B (self-hosted, boa GPU): 300-800 ms
Para interfaces de usuário conversacionais, uma latência superior a 2 segundos tem impacto direto na satisfação do usuário. O streaming mitiga a percepção, mas não o tempo real de resposta.
O custo indireto: se você tem workers processando em batch e a latência média é de 1 segundo por chamada, para 100.000 chamadas/dia você precisa de concorrência suficiente para não criar gargalos. Mais concorrência significa mais infraestrutura.
Tratamento de erros e novas tentativas
Os LLMs falham. As APIs da OpenAI e da Anthropic têm SLAs de uptime altos (>99,9%), mas em produção com milhares de chamadas diárias, os erros acontecem. Um sistema robusto precisa de:
- Lógica de retry com exponential backoff
- Circuit breakers para evitar cascatas de falhas
- Fallback para modelos alternativos quando o principal não está disponível
Essa engenharia tem custo de desenvolvimento (tipicamente 2-4 semanas para fazer direito) e custo de infraestrutura (se você mantém redundância de provedores).
Custo de chamadas com falha
Chamadas que retornam erro, timeout ou resposta inválida também consomem tokens (parcialmente) ou tempo de compute em self-hosted. Em um sistema mal otimizado, 5-10% das chamadas podem ser “desperdício”. Com 10.000 chamadas/dia, isso é 500-1.000 chamadas/dia de perda líquida.
Estratégias de otimização: como reduzir a fatura em 40-70%
Depois de trabalhar em vários sistemas em produção, estas são as estratégias que realmente funcionam:
1. Caching semântico (economia potencial: 30-60%)
O caching semântico vai além do caching tradicional de respostas exatas. Em vez de buscar correspondências exatas de strings, usa embeddings para encontrar consultas similares e reutilizar a resposta se a similaridade superar um limite.
Implementação típica:
- Ao receber uma consulta, gerar seu embedding (custo: fração de centavo)
- Buscar no cache de embeddings se há algo similar (similaridade cosseno > 0,92)
- Se houver hit, retornar a resposta em cache sem chamar o LLM
- Se não houver hit, chamar o LLM e armazenar o resultado em cache
Em chatbots com consultas repetitivas (suporte, FAQs), a taxa de acerto pode chegar a 40-60%. Em sistemas RAG com perguntas mais diversas, 15-25%. Ferramentas como GPTCache ou implementações próprias sobre Redis são opções viáveis.
2. Roteamento de modelos (economia potencial: 40-70%)
Nem todas as consultas precisam do mesmo modelo. Um sistema de roteamento classifica a complexidade de cada consulta e a encaminha para o modelo apropriado:
- Consulta simples (“Qual é o horário?”) → Gemini Flash ou GPT-4o mini
- Consulta média (“Explique as condições do contrato”) → Claude Haiku ou GPT-4o mini
- Consulta complexa (“Analise estes três contratos e me dê as diferenças principais”) → Claude Sonnet ou GPT-4o
O classificador pode ser outro LLM pequeno (custo mínimo) ou um classificador tradicional treinado com exemplos do seu domínio. Em sistemas com distribuição típica de consultas (70% simples, 20% médias, 10% complexas), a economia é enorme.
3. Otimização de prompts (economia potencial: 20-40%)
O prompt de sistema é um dos maiores culpados pela inflação de tokens. Já vimos prompts de 2.000-3.000 tokens que podiam ser reduzidos a 400-600 sem perder eficácia. Algumas técnicas:
- Eliminar redundâncias: “Você é um assistente de atendimento ao cliente profissional e amigável que sempre responde de forma educada e profissional” → “Assistente de suporte. Tom: profissional e direto.”
- Usar estruturas compactas: Listas em vez de parágrafos, YAML em vez de texto descritivo
- Mover informação estática para context caching (Anthropic e Google oferecem preços reduzidos para prompts em cache usados em muitas chamadas)
O context caching da Anthropic cobra o prompt de sistema a preço reduzido (~$0,30/1M tokens vs $3,00/1M no Sonnet) quando usado em múltiplas chamadas consecutivas. Para um prompt de sistema de 1.000 tokens com 10.000 chamadas/dia, a economia é substancial.
4. Batching e processamento assíncrono
Para tarefas que não requerem resposta em tempo real (processamento de documentos, geração de relatórios, análises), o processamento em batch permite:
- Usar a Batch API da OpenAI (50% de desconto em troca de latência de até 24h)
- Otimizar o uso de GPUs em self-hosted evitando subutilização
- Gerenciar melhor os rate limits sem infraestrutura adicional de fila
Para 500 documentos/dia sem necessidade de resultado imediato, a Batch API da OpenAI reduz a fatura pela metade.
5. Otimização do contexto em RAG
Em sistemas RAG, quanto contexto é passado ao LLM é crítico:
- Retrieval preciso: Melhorar a qualidade do retrieval para recuperar apenas os chunks mais relevantes (3 bons chunks > 10 mediocres)
- Chunking otimizado: Chunks menores e mais precisos reduzem tokens sem sacrificar qualidade
- Reranking: Um modelo de reranking barato (ex: Cohere Rerank) melhora a seleção de chunks antes de passá-los ao LLM
Self-hosted vs API: quando cada opção faz sentido
A pergunta que mais nos fazem: “Não seria mais barato hospedar o modelo nós mesmos?”
A resposta honesta: depende, mas para a maioria das empresas a API comercial ganha até volumes altos.
Custos de self-hosting (Llama 3.3 70B como referência)
Para executar Llama 3.3 70B com performance de produção você precisa de:
- GPU necessária: Mínimo 2× A100 80GB ou equivalente para boa throughput
- Custo na AWS: p4d.24xlarge (
$32/hora) ou g5.48xlarge ($16/hora) - Instância dedicada 24/7: $32 × 24 × 30 = ~$23.000/mês (AWS on-demand)
- Com Reserved Instances (1 ano): Pode cair para ~$11.000-14.000/mês
- Alternativa spot: Possível, mas instabilidade em produção requer gestão adicional
Alternativas mais econômicas de self-hosting:
- RunPod ou Lambda Labs: $2-4/hora para A100, versus $8-16 na AWS. Para cargas intermitentes, muito mais viável.
- Ollama + servidor próprio: Para volumes muito baixos ou uso interno, um servidor com 2× RTX 4090 (custo ~$3.000) pode se pagar em 6-12 meses se o volume justificar.
Ponto de equilíbrio
O breakeven entre API e self-hosting (assumindo RunPod a $3/hora para Llama 70B equivalente ao Claude Haiku em qualidade):
- RunPod 24/7: ~$2.160/mês
- Equivalente Claude Haiku: $0,0023/chamada × N chamadas/mês
Breakeven: 2.160 / 0,0023 ≈ 940.000 chamadas/mês (~31.000 chamadas/dia)
Abaixo desse volume, a API comercial é mais econômica quando se conta o custo real do self-hosting (infraestrutura, DevOps, atualizações de modelos, monitoramento). Acima, o self-hosting começa a fazer sentido financeiro.
Há casos em que o self-hosting ganha independentemente do volume:
- Dados altamente sensíveis que não podem sair da sua infraestrutura (saúde, finanças reguladas)
- Latência ultra-baixa onde os milissegundos importam e você tem a GPU próxima ao usuário
- Fine-tuning intensivo onde você precisa de um modelo altamente especializado no seu domínio
O custo real de um projeto de IA completo
Para dar uma perspectiva mais ampla, estes são os intervalos típicos de custo total (não apenas tokens) para diferentes tipos de projetos:
Chatbot de suporte básico (1.000 consultas/dia):
- Tokens: $12-240/mês conforme o modelo
- Infraestrutura (hosting, banco vetorial): $50-100/mês
- Monitoramento: $20-40/mês
- Total: $80-380/mês
Sistema RAG departamental (500 usuários, base de 10K documentos):
- Tokens: $200-800/mês
- Banco vetorial (Pinecone ou similar): $70-200/mês
- Infraestrutura adicional: $100-200/mês
- Monitoramento e observabilidade: $40-80/mês
- Total: $410-1.280/mês
Agente de IA com integrações (200 usuários ativos, múltiplas ferramentas):
- Tokens: $500-2.000/mês (agentes consomem mais tokens pelos tool calls)
- Infraestrutura: $200-500/mês
- Monitoramento avançado: $80-150/mês
- Total: $780-2.650/mês
Esses intervalos assumem arquiteturas otimizadas. Sem otimização, os custos podem ser 2-3× maiores.
Conclusão: a IA é rentável se for bem projetada
A IA em produção não é barata se feita de forma descuidada, mas também não é proibitiva se projetada com critério. As diferenças entre uma implementação ingênua e uma otimizada podem ser de 5-10× em custos.
Os princípios que aplico em todos os projetos:
- Começar com o modelo mais barato que resolve o problema. Escalar para um mais potente apenas com evidências de que é necessário.
- Medir tudo desde o primeiro dia: tokens por chamada, taxa de erro, latência, custo por usuário. Sem métricas, não há como otimizar.
- Implementar caching desde o início, não como melhoria posterior. É a otimização de maior impacto.
- Orçar a infraestrutura além dos tokens: o erro mais comum nas estimativas iniciais.
- Revisar a fatura mensalmente e correlacionar com o uso real. Picos de custo geralmente revelam bugs ou uso inesperado.
Se você está avaliando integrar IA no seu produto ou processo e quer uma estimativa honesta adaptada ao seu caso de uso, na Soamee fazemos exatamente isso. Você pode conferir nossos serviços de IA ou entrar em contato diretamente.
Também pode ser útil nosso artigo sobre como construir um agente de IA personalizado com LLM para atendimento ao cliente se você já tem clareza sobre o caso de uso e quer entender a arquitetura.