Errata publicada em 12/05/2026: versão anterior continha seções duplicadas por erro de edição. Conteúdo corrigido.
Pipecat, LiveKit Agents ou Vapi: a decisão que define custo, latência e controle do seu voice agent
Autor: Mateus Vidal | Pilar: Voice AI | Dificuldade: intermediário
Em meados de 2026, existe um momento específico na vida de todo dev que está construindo voice agents: o PoC funcionou, o cliente aprovou, e agora você precisa decidir arquitetura de produção. É aí que Pipecat, LiveKit Agents e Vapi aparecem nas buscas — às vezes na mesma semana, às vezes na mesma tarde.
Os três resolvem o mesmo problema de superfície: orquestrar um pipeline STT → LLM → TTS com latência aceitável para conversação em tempo real. Mas as propostas são radicalmente diferentes, e a escolha errada custa caro — literalmente.
Este artigo faz o comparativo com os três eixos que importam em produção: custo unitário real em escala, overhead de latência por design de arquitetura, e grau de controle sobre os componentes do pipeline. O objetivo é um framework de decisão explícito, não um “depende” sem critérios.
TL;DR
– Vapi — SaaS gerenciado, sem infra para operar; ideal para PoC/MVP ou volumes abaixo de 10k min/mês sem especialista em streaming
– Pipecat — OSS Python, portabilidade máxima de componentes; escolha para pipeline customizado, dados on-premise por LGPD, ou multi-transport
– LiveKit Agents — OSS + WebRTC nativo; melhor para quem já usa LiveKit para mídia ou precisa de SIP PSTN sem middleware
– Break-even real do self-hosted: 10k–50k min/mês dependendo de engenharia disponível
– Dados de voz em território BR por LGPD: apenas Pipecat ou LiveKit
O que cada framework é de verdade
Antes do comparativo, é preciso entender o que cada ferramenta é — não o que o marketing diz.
Vapi: managed SaaS com abstração total
Vapi (vapi.ai) é um SaaS de orquestração de voice agents. Você não opera infraestrutura: entrega um prompt, escolhe STT/LLM/TTS dentro do catálogo da plataforma, define um número de telefone, e o Vapi gerencia transporte, billing por minuto, transcrições, e dashboard de analytics. A proposta de valor é time-to-market: um agente básico fica no ar em horas, não dias.
A taxa de plataforma é $0,05/min (acessado em 12/05/2026, vapi.ai/pricing). Esse número é o custo de _orquestração_. O custo real de operação soma STT, LLM, TTS e telefonia — mas como esses componentes são provisionados pela Vapi, você não controla nem a escolha de fornecedor nem o pricing negociado com eles.
Enterprise com pricing customizado — SOC2, HIPAA BAA e DPA incluídos. Consulte vapi.ai/pricing para cotação atual.
Pipecat: OSS Python com ecossistema amplo
Pipecat (github.com/pipecat-ai/pipecat, v1.1.0 de 27/04/2026, Daily.co) é um framework Python open source para construir pipelines de áudio em tempo real. A abstração central é o Pipeline: uma cadeia de Processors onde cada componente (STT, LLM, TTS, VAD) é uma peça substituível.
O ponto forte do Pipecat é o ecossistema: mais de 60 integrações com providers de STT (Deepgram, AssemblyAI, Whisper), LLM (OpenAI, Anthropic, Gemini, Ollama), TTS (ElevenLabs, Cartesia, Azure), transports (Daily WebRTC, WebSocket, Twilio, RTVI). Isso significa que você testa Deepgram hoje e migra para Whisper local amanhã sem reescrever a lógica de negócio.
A v1.1.0 introduziu SmartTurn — turn detection semântico baseado em modelo transformer, em vez de só VAD por silêncio. Pipecat Cloud existe como opção gerenciada, mas a maioria dos times usa o framework diretamente.
LiveKit Agents: OSS com transporte WebRTC nativo
LiveKit Agents (docs.livekit.io/agents, v1.5+, acessado em 12/05/2026) é o SDK de agentes da LiveKit — a empresa por trás da infraestrutura WebRTC open source mais usada em produção. O diferencial não é o SDK em si, mas a integração nativa com o LiveKit Server: WebRTC com SFU real, SIP nativo (trunk para PSTN), e suporte a MCP.
A arquitetura padrão é cascade: STT → LLM → TTS, usada em ~90% dos agentes em produção segundo a própria documentação. LiveKit também suporta Speech-to-Speech (S2S) direto via OpenAI Realtime API, Gemini Live ou NVIDIA Riva — casos onde você troca pipeline explícito por latência menor ao custo de lock-in no modelo.
O pricing LiveKit Cloud (acessado em 12/05/2026, livekit.com/pricing):
- Build: gratuito, 1.000 min/mês, 5 sessões concorrentes
- Ship: $50/mês, 5.000 min + $0,01/min excedente, 20 sessões concorrentes
- Scale: $500/mês, 50.000 min + $0,01/min excedente, 600 sessões, HIPAA BAA
- Enterprise: SLA customizado, SOC2
Latência: onde cada plataforma introduz overhead por design
Latência voice-to-voice abaixo de 800ms P95 é o threshold percebido como conversação natural — como detalhamos em como medir latência P95 em voice agents. Acima disso, qualquer truque de UX (filler words, “hmm, deixa eu verificar”) é cosmética.
Nenhum benchmark público verificado com metodologia reproduzível compara Pipecat, LiveKit Agents e Vapi em condições equivalentes com as versões atuais. Em vez de citar números sem hardware, dataset e versão documentados, a análise a seguir é arquitetural: onde cada plataforma introduz overhead por design, independente do provider de STT/LLM/TTS escolhido.
Vapi: hops adicionais por design de managed service
Vapi é um proxy entre o cliente de áudio e os modelos. O fluxo de áudio passa pelos servidores Vapi antes de chegar ao STT — e a resposta do TTS volta pelo mesmo caminho. Isso significa pelo menos dois hops de rede adicionais em relação a um pipeline self-hosted onde o cliente fala diretamente com o STT e recebe TTS diretamente.
Para quem está nos EUA, o overhead de rede é pequeno. Para cliente brasileiro com servidor Vapi nos EUA, o RTT transatlântico aparece em cada etapa do pipeline. A Vapi não divulga localização dos PoPs por região.
O segundo overhead vem do VAD gerenciado: Vapi controla quando considera que o usuário terminou de falar. Isso não é configurável sem plano Enterprise. Times que precisam afinar o threshold de barge-in ou silence detection ficam presos na default.
Pipecat: overhead concentrável, mas sem transporte nativo
Pipecat é framework — não infraestrutura de transporte. Você escolhe o transport: Daily WebRTC (opção padrão nos tutoriais), WebSocket puro, Twilio, ou outro. Isso significa que a latência de rede depende de onde você sobe o servidor Pipecat e qual transport usa.
O overhead arquitetural do Pipecat é que o Pipeline corre em processo Python — cada Frame (chunk de áudio) passa pelos Processors em série. Para pipelines simples (STT→LLM→TTS), o overhead de serialização é negligenciável. Para pipelines complexos com muitos Processors, o Python GIL pode aparecer em STT streaming com chunks pequenos.
SmartTurn (v1.1.0) adiciona uma inferência de modelo transformer para turn detection — o que pode introduzir overhead de inferência adicional em relação ao VAD por silêncio — o changelog v1.1.0 descreve SmartTurn como modelo transformer compacto (CHANGELOG pipecat-ai/pipecat, acessado em 12/05/2026); não há benchmark público reproduzível com hardware documentado para esse componente isolado. SmartTurn reduz cortes prematuros de fala, que costumam custar mais em experiência do que o overhead de inferência.
LiveKit Agents: transporte WebRTC real, mas infraestrutura requerida
O LiveKit elimina o overhead de proxy porque o agente conecta diretamente na sala LiveKit como participante — o mesmo protocolo que o cliente usa. Não há servidor intermediário interpretando o fluxo: o SFU LiveKit roteia pacotes RTP, e o agente processa diretamente.
O custo arquitetural: você precisa de um LiveKit Server rodando. LiveKit Cloud (pago) resolve isso; self-host do LiveKit Server adiciona uma peça de infraestrutura para operar.
Semantic turn detection no LiveKit Agents também usa modelo transformer, com comportamento similar ao SmartTurn do Pipecat.
TCO real: o que você paga de fato em cada escala
Câmbio: R$ 5,80/USD (referência: 12/05/2026). Recalcule com a taxa corrente antes de usar esses números em planilha de decisão.
O custo de um voice agent tem cinco componentes: orquestração, STT, LLM, TTS, e telefonia (se houver número). A maioria das análises de “Vapi vs self-hosted” compara só o custo de orquestração — que é a peça menos cara.
Usando como referência o modelo de custo publicado pela Dograh (blog.dograh.com/self-hosted-voice-agents-vs-vapi-real-cost-analysis-tco-break-even, jan 2026), os valores típicos por componente:
| Componente | Custo estimado |
| STT (Deepgram Nova-3 streaming) | ~$0,0043/min |
| LLM (GPT-4o-mini 8k ctx) | ~$0,02–$0,08/min (depende de tokens) |
| TTS (ElevenLabs Flash) | ~$0,04/min |
| Telefonia SIP inbound (EUA) | ~$0,01/min |
| Stack STT+LLM+TTS+telefonia | ~$0,07–$0,14/min |
Faixa 1: 1.000 min/mês (early stage, validação)
Vapi: taxa de plataforma $0,05/min × 1.000 = $50. Stack STT+LLM+TTS provisionada pela Vapi — você não vê esse custo separado, mas ele está no preço total estimado de $0,15–$0,50/min. Custo total: $150–$500/mês (~R$ 870–R$ 2.900).
Pipecat self-hosted: sem taxa de orquestração. Você paga stack diretamente: ~$0,07–$0,14 × 1.000 = $70–$140/mês (~R$ 406–R$ 812). Mais: servidor para rodar o Pipecat (t3.small na AWS ~$15/mês) e transport WebRTC (Daily.co free tier cobre 1.000 min).
LiveKit Agents: plano Build gratuito cobre 1.000 min. Stack: $70–$140/mês. Custo total: $70–$140/mês (~R$ 406–R$ 812), idêntico ao Pipecat.
Mas: a conta acima ignora engineering overhead. Em 1k min/mês, você está em fase de validação. Gastar 20h configurando LiveKit para economizar R$ 2.000/mês não faz sentido. Vapi ganha aqui por tempo, não por preço.
Faixa 2: 10.000 min/mês (produto em crescimento)
Vapi: $0,15–$0,50 × 10.000 = $1.500–$5.000/mês (~R$ 8.700–R$ 29.000).
Pipecat self-hosted: $0,07–$0,14 × 10.000 = $700–$1.400 (stack) + ~$100 (servidor m5.large + monitoring) = $800–$1.500/mês (~R$ 4.640–R$ 8.700).
LiveKit Agents Ship: $50 (plano) + $0,01 × 5.000 excedentes = $100 (LiveKit Cloud) + $700–$1.400 (stack) = $800–$1.500/mês (~R$ 4.640–R$ 8.700).
Nessa faixa, self-hosted começa a ganhar economicamente — mas só se você já tem o dev que vai operar a stack. Se não tem, contrate um dev sênior a R$ 15.000/mês e a equação muda.
Faixa 3: 100.000 min/mês (escala real)
Vapi: mínimo $15.000/mês pela taxa de plataforma. Enterprise customizado — mas a ordem de grandeza é essa.
Pipecat self-hosted: $7.000–$14.000 (stack) + ~$500 (infra redundante) + custo de engenharia = $7.500–$14.500/mês (~R$ 43.500–R$ 84.100).
LiveKit Agents Scale: $500 (plano) + $0,01 × 50.000 excedentes = $1.000 (LiveKit Cloud) + $7.000–$14.000 (stack) = $8.000–$15.000/mês (~R$ 46.400–R$ 87.000).
Em 100k min/mês, Vapi perde claramente em preço — mas só se você tem eng para operar.
O custo oculto do self-hosted
A análise acima assume que “ops” não custa nada. Na prática:
Engineering overhead: deployar, monitorar, atualizar SDK, investigar regressões de latência — conservadoramente 4–8 horas/mês para dev sênior. No Brasil, R$ 120–180/hora, isso é R$ 480–1.440/mês que não aparece na planilha de infra.
Observabilidade: Vapi entrega call analytics, transcrições e debug de chamada out-of-the-box. Pipecat e LiveKit não — você precisa integrar Datadog, Sentry, ou equivalente. Para uma análise aprofundada de instrumentação de pipeline, veja como medir latência P95 em voice agents. Custo adicional de ~$50–200/mês + horas de setup.
Break-even real: para time com um dev dedicado capaz de operar a stack, o break-even fica em torno de 10k–30k min/mês (vs os 10k que análises simplificadas citam). Para time sem esse perfil, o break-even pode não existir.
Controle e vendor lock-in
Essa é a dimensão mais ignorada em comparativos, e a que mais dói depois de um ano de produção.
| Dimensão de controle | Vapi | Pipecat | LiveKit Agents |
| Trocar STT | Limitado (catálogo Vapi) | Total | Total |
| Trocar LLM | Limitado | Total | Total |
| Trocar TTS | Limitado | Total | Total |
| Configurar VAD/turn detection | Sem acesso (Enterprise) | Total (SmartTurn ou custom) | Total (semantic ou custom) |
| Retenção de áudio on-premise | Não | Sim | Sim |
| Exportar dados de chamada | API própria | Você controla | Você controla |
| SIP trunk com operadora BR | Via Vapi (limitado) | Via transport escolhido | Nativo (PSTN SIP) |
| Deploy na sua infra | Não | Sim | Sim |
Para projetos com requisitos LGPD de áudio on-premise — dados de voz de usuários brasileiros devem permanecer em território nacional — Vapi não é opção. Pipecat e LiveKit permitem rodar tudo em cloud BR (AWS São Paulo, GCP Osasco).
Setup básico: três exemplos comparáveis
Os snippets abaixo mostram o mínimo para um agente de voz com STT, LLM e TTS em cada framework. Todos validados pelo Engenheiro de Conteúdo Técnico em 12/05/2026 (Python 3.13.5) — MESA-110 #codigo-validado.
Pipecat (Python, transport Daily WebRTC)
# Dependências: pip install "pipecat-ai[daily,openai,deepgram,cartesia]==1.1.0"
# Pipecat v1.1.0 — https://github.com/pipecat-ai/pipecat
# Validado: Python 3.13.5, pipecat-ai==1.1.0 — MESA-110 (12/05/2026)
import asyncio
from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.runner import PipelineRunner
from pipecat.pipeline.task import PipelineTask, PipelineParams
from pipecat.services.deepgram.stt import DeepgramSTTService # v1.1.0: submodule .stt
from pipecat.services.openai.llm import OpenAILLMService # v1.1.0: submodule .llm
from pipecat.services.cartesia.tts import CartesiaTTSService # v1.1.0: submodule .tts
from pipecat.transports.daily.transport import DailyTransport, DailyParams # v1.1.0: novo path
async def main():
transport = DailyTransport(
room_url="https://your-domain.daily.co/room",
token="<daily-token>",
bot_name="Agente",
params=DailyParams(audio_out_enabled=True)
)
stt = DeepgramSTTService(api_key="<deepgram-key>", language="pt-BR")
llm = OpenAILLMService(api_key="<openai-key>", model="gpt-4o-mini")
tts = CartesiaTTSService(api_key="<cartesia-key>", voice_id="<voice-id>")
pipeline = Pipeline([transport.input(), stt, llm, tts, transport.output()])
runner = PipelineRunner()
await runner.run(PipelineTask(pipeline, params=PipelineParams())) # v1.1.0: params= keyword-only
asyncio.run(main())
O pipeline encadeia os componentes — trocar DeepgramSTTService por WhisperSTTService (local, OSS) é uma linha de código. Atenção: v1.1.0 mudou os caminhos de import vs. v0.x — use os paths acima ou você obterá ImportError.
LiveKit Agents (Python, transport LiveKit WebRTC)
# Dependências: pip install livekit-agents[openai,deepgram,elevenlabs] livekit-plugins-silero
# LiveKit Agents v1.5 — https://docs.livekit.io/agents/
from livekit import agents
from livekit.agents import AgentSession, Agent, RoomInputOptions
from livekit.plugins import openai, deepgram, elevenlabs, silero
async def entrypoint(ctx: agents.JobContext):
await ctx.connect()
session = AgentSession(
stt=deepgram.STT(language="pt-BR"),
llm=openai.LLM(model="gpt-4o-mini"),
tts=elevenlabs.TTS(voice_id="<voice-id>"),
vad=silero.VAD.load(),
)
await session.start(
room=ctx.room,
agent=Agent(instructions="Você é um assistente de voz em português brasileiro."),
room_input_options=RoomInputOptions(noise_cancellation=True),
)
if __name__ == "__main__":
agents.cli.run_app(agents.WorkerOptions(entrypoint_fnc=entrypoint))
O agente registra-se no LiveKit Server como participante. agents.cli.run_app sobe o worker que recebe jobs do servidor LiveKit quando um usuário entra na sala.
Vapi (REST API, setup via Python)
# Dependências: pip install requests==2.34.0
# Vapi API — https://docs.vapi.ai
# Validado: Python 3.13.5, requests==2.34.0 — MESA-110 (12/05/2026)
import requests
response = requests.post(
"https://api.vapi.ai/call", # endpoint correto para outbound
headers={
"Authorization": "Bearer <vapi-api-key>",
"Content-Type": "application/json" # obrigatório; omitir retorna 400
},
json={
"phoneNumberId": "<seu-numero-vapi>",
"customer": {"number": "+5511999999999"}, # E.164: +55 + DDD + número
"assistant": {
"model": {
"provider": "openai",
"model": "gpt-4o-mini",
"messages": [{"role": "system", "content": "Você é um assistente em pt-BR."}]
},
"voice": {"provider": "elevenlabs", "voiceId": "<voice-id>"},
"transcriber": {"provider": "deepgram", "language": "pt-BR"}
}
}
)
response.raise_for_status()
print(response.json())
Com Vapi, não há framework instalado no seu servidor: você faz uma chamada REST e a Vapi gerencia o resto. Para receber chamadas inbound, você configura webhook na dashboard.
Quando usar cada um
Use Vapi quando:
- Você está em fase de PoC ou MVP e quer validar a hipótese de negócio antes de investir em infra.
- Seu time não tem dev com experiência em streaming de áudio, WebRTC, ou Python assíncrono.
- O volume esperado é abaixo de 10k min/mês nos próximos 3 meses.
- Você precisa de analytics de chamada (duração, transcrição, latência por segmento) sem construir observabilidade do zero.
- O requisito de compliance é SOC2/HIPAA e você não tem capacidade de fazer própria auditoria de infra.
Use Pipecat quando:
- Você precisa de um componente específico que a Vapi não oferece: STT Whisper local, TTS Cartesia com latência menor, ou LLM on-premise (Ollama, vLLM).
- Seu pipeline é complexo: multi-agente, lógica de orquestração customizada, integração com sistemas de telefonia não suportados nativamente.
- Você precisa de portabilidade de transport: hoje Daily WebRTC, amanhã Twilio, depois AudioSocket. Pipecat abstrai isso.
- Requisito de dados on-premise por LGPD (áudio de usuário não pode sair do Brasil).
Use LiveKit Agents quando:
- Você já usa — ou planeja usar — LiveKit para video/audio conferencing. O agente é um participante nativo na mesma sala, sem integração adicional.
- Precisa de SIP PSTN nativo para conectar a tronco telefônico BR sem middleware adicional.
- A escala exige WebRTC com SFU real para muitas sessões concorrentes — LiveKit Server é a infraestrutura mais testada em produção para esse caso.
- Seu caso de uso é S2S (OpenAI Realtime, Gemini Live) e você quer WebRTC como transport.
Quando NÃO usar cada um
Não use Vapi quando:
- O volume projetado ultrapassa 30k–50k min/mês. A taxa de plataforma de $0,05/min vira R$ 8.700–R$ 14.500 só de orquestração — sem stack. Acima disso, autohost recupera o investimento em engenharia em semanas.
- Você tem requisito de retenção de áudio on-premise. Vapi não oferece opção de dados em território brasileiro.
- Você precisa customizar VAD, turn detection ou barge-in. Esses parâmetros não são expostos fora do Enterprise, e mesmo no Enterprise a configuração é limitada.
- O produto precisa trocar de LLM por experimento A/B ou requisito de custo. Lock-in no catálogo Vapi torna isso lento e caro.
Não use Pipecat quando:
- O time não tem um dev Python sênior disponível para operar e atualizar o framework em produção. Pipecat v1.1.0 ainda tem breaking changes entre minor versions — você precisa de alguém que acompanhe o changelog.
- O transporte é exclusivamente SIP PSTN para call center e você quer integração nativa sem configurar Twilio ou Daily no meio. LiveKit é mais direto nesse caso.
- O produto precisa estar em produção em menos de uma semana. O tempo de setup com Pipecat (transport, VAD, testes de latência) raramente fica abaixo de 3–5 dias para alguém sem experiência anterior.
Não use LiveKit Agents quando:
- Você não tem — e não vai ter — experiência com WebRTC em produção. LiveKit Server requer compreensão de como SFU funciona para debugar problemas de conexão, packet loss e fallback de codec. Contratar um dev sem esse background e jogá-lo em LiveKit em produção é receita para incidente.
- O produto não usa LiveKit para nada mais — e você só quer um voice agent simples. Nesse caso, o overhead de operar LiveKit Server (mesmo Cloud) não se justifica. Pipecat com Daily transport é mais direto.
- Você precisa de analytics de chamada out-of-the-box. LiveKit é infraestrutura de transporte, não produto de call analytics. Não tem dashboard de duração, transcrição estruturada, ou latência por segmento sem você construir.
- O projeto começa com número de telefone BR via operadora local sem SIP trunk próprio. O setup de SIP no LiveKit requer trunk configurado — para quem quer só um número para testar, Vapi ou Twilio+Pipecat é mais rápido.
O framework de decisão em uma tabela
| Critério | Vapi | Pipecat | LiveKit Agents |
| Time-to-market | ★★★★★ | ★★★ | ★★★ |
| Custo em 1k min/mês | ★★ | ★★★★★ | ★★★★★ |
| Custo em 100k min/mês | ★ | ★★★★★ | ★★★★ |
| Controle de componentes | ★★ | ★★★★★ | ★★★★★ |
| Dados on-premise (LGPD) | ✗ | ✓ | ✓ |
| Latência (por design) | overhead de proxy | depende de transport | WebRTC nativo |
| Curva de operação | baixa | média | alta |
| SIP PSTN nativo | via Vapi | via integração | nativo |
| Analytics out-of-the-box | ✓ | ✗ | ✗ |
| Multi-agente / orquestração | limitado | Subagents OSS | custom |
Regra de bolso: se o produto vai até 10k min/mês nos próximos 6 meses e você não tem eng para operar stack, use Vapi. Se você já passou de 20k min/mês ou vai chegar lá em 3 meses, projete com Pipecat ou LiveKit Agents — a diferença de custo paga o tempo de setup em semanas. Se o produto já usa LiveKit para conferência ou precisa de SIP trunk direto, use LiveKit Agents.
Nota sobre fontes
A análise de TCO referencia o modelo publicado pela Dograh (jan 2026). A análise arquitetural de componentes de cada plataforma cita a AssemblyAI como fonte secundária (assemblyai.com/blog/vapi-vs-pipecat-vs-livekit, acessado em 12/05/2026). A AssemblyAI é fornecedora de STT com posição de mercado diretamente relacionada ao contexto desse comparativo — Vapi, Pipecat e LiveKit são potenciais clientes ou integradores do serviço deles. As afirmações da fonte foram verificadas contra documentação oficial dos três frameworks; onde divergiam, a documentação oficial prevaleceu.
Fontes primárias utilizadas:
- GitHub pipecat-ai/pipecat v1.1.0 — github.com/pipecat-ai/pipecat — acessado em 12/05/2026
- LiveKit Pricing — livekit.com/pricing — acessado em 12/05/2026
- Vapi Pricing — vapi.ai/pricing — acessado em 12/05/2026
- LiveKit Agents Docs — docs.livekit.io/agents — acessado em 12/05/2026
- Pipecat Docs — docs.pipecat.ai — acessado em 12/05/2026
- Dograh TCO analysis — blog.dograh.com — jan 2026, acessado em 12/05/2026
- AssemblyAI comparativo arquitetural (fonte secundária; ver nota acima) — assemblyai.com/blog — acessado em 12/05/2026
