VAPI and LiveKit are the two most popular platforms for building production AI voice agents in 2026. VAPI is a fully managed API platform — you send it a prompt and a phone number and it handles everything. LiveKit is an open-source WebRTC infrastructure platform with an Agent SDK that gives you full control over the media pipeline. After building agents on both, here is our honest comparison.
Platform Philosophy
VAPI is opinionated and managed — optimised for speed to production. You configure the agent via JSON (system prompt, voice, model, tools) and VAPI handles media routing, WebRTC, PSTN bridging, recording, and analytics. LiveKit is flexible and self-hosted — you write Python or Node.js agent code that runs as a worker, and LiveKit handles the media infrastructure. The tradeoff is classic: simplicity vs control.
| Factor | VAPI | LiveKit Agents |
|---|---|---|
| Hosting | Fully managed (VAPI cloud) | Self-hosted agent workers + LiveKit Cloud or self-hosted SFU |
| Setup time | 15–30 minutes to first call | 2–4 hours to first call |
| Agent code | JSON config + webhook handlers | Python/Node.js agent process |
| STT provider | Deepgram, AssemblyAI, OpenAI | Any (Deepgram, Whisper, Azure, Google) |
| LLM provider | OpenAI, Anthropic, Groq, custom | Any (full control) |
| TTS provider | ElevenLabs, Cartesia, Deepgram | Any (ElevenLabs, Cartesia, Azure) |
| PSTN support | Built-in (Twilio, Telnyx) | Via LiveKit SIP connector |
| Open source | No | Yes (LiveKit Server + Agent SDK) |
| Pricing model | Per-minute platform fee + model costs | Infra costs + model costs (no platform fee) |
Latency Benchmark
We built identical agents on both platforms: inbound support agent, GPT-4o as LLM, Deepgram Nova-3 STT, ElevenLabs Turbo v2 TTS. We measured P50 and P95 end-to-end turn latency (VAD cutoff to first TTS audio byte) across 500 calls.
| Platform | P50 Latency | P95 Latency | Notes |
|---|---|---|---|
| VAPI (standard) | 480ms | 750ms | VAPI infrastructure, US East region |
| LiveKit (self-hosted, same region) | 380ms | 610ms | Agent worker co-located with LiveKit SFU |
| LiveKit + GPT-4o Realtime | 260ms | 430ms | Native audio model, eliminates STT→LLM→TTS chain |
| VAPI + Groq (Llama 3.1) | 380ms | 600ms | Groq's fast inference reduces LLM latency to ~50ms |
LiveKit + GPT-4o Realtime API is the fastest AI voice option available today at ~260ms P50. But it requires writing a full agent in Python and self-hosting the infrastructure. VAPI with Groq is a managed option that approaches LiveKit's self-hosted performance.
Cost Per Minute Comparison
| Cost Component | VAPI | LiveKit (self-hosted) |
|---|---|---|
| Platform/infra fee | $0.05/min | ~$0.008/min (VPS amortised) |
| LLM (GPT-4o) | ~$0.018/min | ~$0.018/min |
| STT (Deepgram Nova-3) | Included | ~$0.004/min |
| TTS (ElevenLabs Turbo) | ~$0.012/min | ~$0.012/min |
| Total (est.) | ~$0.080/min | ~$0.042/min |
At 10,000 minutes/month: VAPI costs ~$800, LiveKit self-hosted costs ~$420. The breakeven for investing engineering time in self-hosting is roughly 5,000–8,000 minutes/month, depending on your hourly engineering rate.
Customisation Depth
VAPI offers excellent customisation for a managed platform — webhook interceptors let you modify messages before they reach the LLM, inject context from your database, and call custom tools. But you cannot change the VAD algorithm, the audio codec pipeline, or how RTP is processed. With LiveKit, these are just Python parameters.
PSTN and SIP Integration
VAPI's built-in SIP/PSTN support is its biggest practical advantage over LiveKit. You configure a Twilio or Telnyx number in the VAPI dashboard and it handles all the SIP bridging. With LiveKit, you use the LiveKit SIP connector — which works excellently once configured, but requires setting up a SIP trunk, configuring dispatch rules, and running the SIP worker as a separate service.
Function Calling and Tool Use
Both platforms support LLM function calling — letting the agent look up orders, book appointments, or update a CRM mid-call. The difference is where the tool code runs. With VAPI, you define tools in the assistant JSON and VAPI calls your webhook URL when the LLM triggers them; your server must respond within ~7 seconds or the call stalls. With LiveKit, tools are plain Python functions running inside your agent process — no webhook round-trip, direct database access, and you can stream partial results back to the conversation.
# LiveKit: tools are local async functions — no webhook hop
@function_tool
async def lookup_order(ctx: RunContext, order_id: str) -> str:
"""Look up the status of a customer order."""
order = await db.orders.find_one({"id": order_id})
return f"Order {order_id} is {order['status']}, arriving {order['eta']}"In our production agents, webhook-based tools on VAPI add 200–600ms per tool call (network round-trip + cold start). LiveKit's in-process tools respond in single-digit milliseconds plus your database query time. If your agent calls tools on most turns, this gap compounds fast.
Outbound Calling: Dialling, AMD and Campaigns
Inbound support agents are the easy case — outbound campaigns are where platform differences bite. You need answering machine detection (AMD), retry logic, concurrency throttling, DNC scrubbing, and local caller ID rotation.
| Outbound Feature | VAPI | LiveKit Agents |
|---|---|---|
| Initiate call via API | POST /call (one line) | CreateSIPParticipant API |
| Answering machine detection | Built-in (voicemail detection + hook) | Build your own or use Telnyx/Twilio AMD |
| Voicemail drop | Built-in | Custom implementation |
| Campaign scheduling / retries | Your code via API | Your code via API |
| Concurrency control | Plan-based limits (10 default) | Limited only by your infrastructure |
| DNC / TCPA compliance | Your responsibility | Your responsibility |
For a 10-agent outbound pilot, VAPI's built-in AMD and voicemail drop save weeks of work. For a 200-concurrent-channel dialler, VAPI's concurrency pricing becomes the bottleneck and LiveKit's infrastructure-limited model wins — we have run 500+ concurrent outbound channels on a single LiveKit cluster.
Scaling and Concurrency Limits
| Scaling Factor | VAPI | LiveKit (self-hosted) |
|---|---|---|
| Default concurrent calls | 10 (higher on request) | No platform limit |
| Scaling model | Request limit increases from VAPI | Add agent workers horizontally |
| Per-call infra cost at 100k min/mo | $0.05/min flat | ~$0.005–$0.008/min |
| Multi-region deployment | VAPI-managed regions | Deploy SFU + workers anywhere |
| Cold start on traffic spike | Managed by VAPI | Pre-warm workers yourself |
Migrating from VAPI to LiveKit
The most common migration path we implement is VAPI → LiveKit at the point where monthly volume makes the platform fee hurt. The good news: your prompts, tool definitions, and conversation design transfer directly. The work is in the infrastructure layer.
- Port the system prompt and tool schemas — VAPI assistant JSON maps almost 1:1 to a LiveKit AgentSession configuration
- Rewrite webhook tools as in-process Python functions (usually simplifies the code)
- Set up the LiveKit SIP connector and point your Twilio/Telnyx trunk at it
- Replicate VAD and interruption settings — VAPI's defaults map to Silero VAD with min_silence_duration ≈ 500ms
- Rebuild call recording and analytics (LiveKit Egress for recording; your own dashboards for analytics)
- Run both platforms in parallel for a week, splitting traffic 90/10, then cut over
Budget 2–3 engineering weeks for a clean VAPI → LiveKit migration including parallel testing. At 20,000+ minutes/month the cost savings typically pay that back within the first two months.
How They Compare to Retell AI and Pipecat
VAPI's closest competitor is Retell AI — also a managed per-minute platform, slightly cheaper at scale, with a stronger focus on phone-native use cases but a smaller integration ecosystem. Pipecat (open source, from Daily) is LiveKit's closest competitor — a Python pipeline framework that is excellent for custom media logic but leaves you to bring your own WebRTC/SIP infrastructure, which LiveKit includes. If you are evaluating all four: managed teams shortlist VAPI vs Retell; infrastructure teams shortlist LiveKit vs Pipecat.
Frequently Asked Questions
Is VAPI open source?
No. VAPI is a proprietary managed platform. LiveKit is open source (Apache 2.0) — both the media server and the Agents SDK — and can be fully self-hosted.
Can VAPI use Claude or other non-OpenAI models?
Yes. VAPI supports OpenAI, Anthropic Claude, Groq, Google Gemini, and custom LLM endpoints via its custom-llm option. LiveKit supports any model you can call from Python or Node.js.
Does LiveKit charge per minute?
LiveKit Cloud charges by participant-minutes and egress bandwidth, which works out to roughly $0.002–$0.01 per call minute depending on configuration. Self-hosting the open-source server removes platform fees entirely — you pay only for your servers and AI providers.
Which is better for HIPAA-compliant voice agents?
LiveKit self-hosted is the stronger option for strict compliance — audio never leaves your infrastructure except to your chosen STT/LLM/TTS providers, with whom you can sign BAAs directly. VAPI offers HIPAA-eligible plans, but you are adding one more vendor to your compliance chain.
Can I use my existing Asterisk or FreeSWITCH PBX with either platform?
Yes, both. VAPI accepts SIP trunks from any PBX via its SIP trunking feature. LiveKit's SIP connector registers with or accepts traffic from Asterisk, FreeSWITCH, Kamailio, or any standards-compliant SIP server. We regularly bridge AI agents into existing enterprise PBX deployments on both platforms.
How long does it take to build a production voice agent?
On VAPI: a working prototype in a day, production-ready (tools, error handling, monitoring) in 1–2 weeks. On LiveKit: a prototype in 2–3 days, production-ready in 2–4 weeks. The long pole in both cases is conversation design and edge-case handling, not the platform.
When to Choose VAPI
- You want the fastest path from idea to production voice agent
- You are building an MVP or proof-of-concept under time pressure
- Your monthly call volume is under 5,000 minutes (cost premium is justified by saved engineering time)
- You need built-in call analytics, call recordings, and debugging tools
- Your team prefers configuring JSON over writing Python agent code
When to Choose LiveKit
- You need sub-400ms latency and are willing to engineer for it
- Your monthly volume exceeds 5,000–10,000 minutes and cost optimisation matters
- You need a custom STT, LLM, or TTS provider not supported by VAPI
- Compliance requirements prevent using a managed cloud platform (HIPAA, data residency)
- You want to use GPT-4o Realtime for the lowest possible latency
VAPI and LiveKit serve different needs. VAPI is the right choice for fast prototyping, small-to-medium scale, and teams that want managed infrastructure. LiveKit is the right choice for teams that need full control, maximum performance, and cost efficiency at scale. Many teams start on VAPI and migrate to LiveKit as they grow — and the architectural patterns transfer well between the two. Our AI voice team has built 60+ agents on both platforms and can help you choose and implement the right stack.