Vapi vs Retell vs Self-Hosted Pipecat and LiveKit: Build or Buy Voice Infrastructure

Vapi and Retell cost almost the same once you price the same model stack: about $0.1255 and $0.125 per minute in my October 2026 model. Choose between them on concurrency fees and on where your agent logic lives. Self-hosting Pipecat or LiveKit beats both only above roughly 30,000 to 170,000 minutes a month, depending on what your engineers cost.

1. The decision

The question a CTO or VP of Engineering actually asks is this: for a phone-based voice agent, do we rent a hosted platform (Vapi, Retell, Bland) or run our own pipeline on open-source frameworks (Pipecat, LiveKit Agents)? The owner is usually engineering with finance in the room, and the trigger is almost always one of three things: a pilot is about to become production traffic, a monthly bill has stopped being a rounding error, or a customer's security review has asked where call audio is stored.

This guide is for teams that will operate the agent for years, not for someone shortlisting a vendor for a one-off project. If the question on your desk is "which vendor should I buy", the buying side is covered at voxdonna.com. Here I only deal with how the architecture and the cost curve change as you move from rented to owned.

2. Why it matters

A voice agent has a cost structure that surprises people who have only priced text LLM calls. You pay per minute, for every minute the line is open, in several layers: speech-to-text, the language model, text-to-speech, telephony, and the platform that orchestrates them. The platform layer is the only one you can remove by building, and it is also the layer where the headline prices differ most from the real bill.

The decision is live and contested rather than settled. Hosted platforms change what they sell: Vapi's own migration guide states that its visual Workflows builder was retired on 18 August 2026, with existing workflows no longer running from 19 August (docs.vapi.ai, retrieved 8 October 2026). Vapi's stated direction is Squads, teams of assistants that hand off to each other. That is a vendor withdrawing an abstraction customers had built on, which is the main operational argument for owning more of the stack.

3. Options

There are four real options. Doing nothing is a fifth, and it is the right answer more often than engineers like to admit.

• A. Vapi. You pay a hosting fee per minute and bring your own model providers at their list price. Commits you to assembling and tuning the model layer yourself, on someone else's orchestration.
• B. Retell AI. Component pricing with voice infrastructure included, a visual flow editor, and a single invoice. Commits you to Retell's abstraction layer for call logic.
• C. Bland AI. A flat per-minute rate that includes the model layer, with plan tiers that cap concurrency and daily calls. Commits you to Bland's bundled models and voices.
• D. Self-hosted pipeline. Pipecat or LiveKit Agents, running on your own infrastructure or on LiveKit Cloud, with providers you contract directly. Commits you to owning uptime, deploys, call-quality debugging and the on-call rota.
• E. Defer. Stay on a free tier or a pilot until volume or a compliance requirement forces the question. Viable below roughly 10,000 minutes a month (see section 6).

4. Architecture implications

All four options run the same loop: audio in, speech-to-text, a language model with tools, text-to-speech, audio out, with turn-taking and interruption handling wrapped around it. What differs is who owns each box.

Hosted (A, B, C). The vendor owns the audio transport, turn-taking and scaling. You own the prompt, the tool definitions and the webhooks. Vapi describes its model as orchestration with provider costs passed through at list price; Retell bundles its voice infrastructure and offers its own TTS voices; Bland states that LLM, STT and TTS are included in its per-minute rate. The practical consequence: your agent logic lives in the vendor's dashboard or API, so you must keep prompts and tool schemas in version control yourself or you will not be able to move.

Self-hosted (D). You pick a framework and run the loop. Pipecat is BSD-2-Clause licensed, and its latest GitHub release was v1.12.0 on 26 September 2026. LiveKit Agents is Apache-2.0 licensed, with its latest release, livekit-agents@1.8.5, on 6 October 2026 (both read from the GitHub API on 8 October 2026). Both licences allow commercial use without a fee. You also take on what the platform used to hide: telephony termination (SIP trunk or a provider's numbers), autoscaling of agent workers, voice-activity and interruption tuning, and monitoring of per-call quality.

Latency is the dimension people expect to differ most, and it is the one I did not measure for this guide. Vendors measure it at different points under the same word, which is the problem I compiled in my voice agent latency benchmark post: Vapi's own docs describe about 800ms end-to-end as typical and its engineering blog treats about 1,200ms as where conversational flow breaks down. Retell states about 600ms in its marketing, citing unnamed benchmarks (as reported by CloudTalk, a competing vendor, so treat it as a claim). Run your own script on your own carrier before you trust any of these.

5. Security and compliance

Consent, calling-hour and disclosure rules for outbound or recorded calls attach to you as the caller, not to the platform. None of the four options removes that duty, and I have not re-verified any regulation's current deadline for this guide, so check the current text with counsel before you rely on it.

What the platform does decide is who signs what and where audio is stored. Vapi's pricing page lists a HIPAA add-on at $2,000 a month, covering HIPAA-eligible data handling with a standard Data Processing Agreement and Business Associate Agreement (retrieved 8 October 2026). Retell's own page describes the product as HIPAA and GDPR compliant and SOC 2 Type I and Type II certified; that is the vendor's description of itself, and I have not seen the audit reports. CloudTalk reports that SOC 2, SSO, RBAC, data residency and the uptime SLA sit behind Vapi's higher contract-based plans. I could not confirm that against the current pricing page, which lists a 99% uptime SLA on Pro and 99.9% on Premier. If you self-host, the compliance surface is yours entirely: you choose the region, you sign each provider's data processing terms, and you write the audit evidence.

6. Cost

Published prices, retrieved 8 October 2026

Fact. These figures come from each vendor's pricing page on 8 October 2026. None of the pages carries a date, so treat them as a snapshot.

Sources: vapi.ai/pricing, retellai.com/pricing, bland.ai/pricing, livekit.com/pricing, and, for Retell's TTS-voice and SIP details, CloudTalk's comparison, a competing contact-centre vendor, so a secondary source.

The headline rates are not comparable. Vapi's $0.05 is hosting alone and excludes speech-to-text, the model and text-to-speech. Retell's $0.07 to $0.31 range includes its voice infrastructure. Bland's rate bundles the model layer, but I cannot see which models, so its price is not like-for-like with the others.

ESTIMATE: the same model layer priced on every option

To compare the platforms fairly I held the model layer constant: STT $0.0095/min, LLM $0.04/min (Retell's calculator default, inside Vapi's published OpenAI range), TTS $0.015/min, and carrier telephony $0.011/min (the midpoint of Vapi's published range). I wrote the model as a short Python script and ran it on 8 October 2026. The core of it is:

STT, LLM, TTS, CARRIER = 0.0095, 0.04, 0.015, 0.011
options = {  # name: (per_min, fixed_per_month)
  "Vapi pay-as-you-go": (0.05 + STT + LLM + TTS + CARRIER, 0),
  "Retell (US Twilio)": (0.055 + TTS + LLM + 0.015, 0),
  "Bland Start":        (0.14, 0),
  "Bland Build":        (0.12, 299),
  "LiveKit Ship + own pipeline": (0.01 + 0.004 + STT + LLM + TTS + CARRIER, 50),
}
# monthly = per_min * minutes + fixed
# break-even minutes = (ops_cost + self_fixed - buy_fixed) / (buy_per_min - self_per_min)

It printed:

option                             $/min   10k min   50k min   250k min
Vapi pay-as-you-go                0.1255     1,255     6,275     31,375
Retell (US Twilio)                0.1250     1,250     6,250     31,250
Bland Start                       0.1400     1,400     7,000     35,000
Bland Build                       0.1200     1,499     6,299     30,299
LiveKit Ship + own pipeline       0.0895       945     4,525     22,425

ESTIMATE. Vapi and Retell land within a twentieth of a cent of each other per minute: the cheaper-looking $0.05 headline stops being cheaper once you add the model layer. CloudTalk's comparison makes the same point that the two headline rates are not comparable. The self-hosted line treats every minute as LiveKit Cloud overage at $0.01, which overstates its cost by at most the included minutes ($50 on Ship, $500 on Scale). If you run the framework on your own virtual machines instead, that $0.01 becomes your compute cost, which I did not measure.

ESTIMATE: where self-hosting breaks even

The monthly saving from self-hosting is the per-minute gap times your minutes. The cost is the engineering time to run it, which I cannot know for your team, so I modelled it as three assumptions at $100 per engineer-hour:

 10 h/month ($1,000) -> Vapi: 29,167 min (486 h) | Retell: 29,577 min (493 h)
 30 h/month ($3,000) -> Vapi: 84,722 min (1,412 h) | Retell: 85,915 min (1,432 h)
 60 h/month ($6,000) -> Vapi: 168,056 min (2,801 h) | Retell: 170,423 min (2,840 h)

At 30 engineer-hours a month, the build path only pays for itself above about 85,000 minutes a month, which is roughly 1,400 hours of conversation. Below that, the saving per minute does not cover the people. If a single engineer owns the whole system, 30 hours a month is not a pessimistic number: it is an afternoon a week for deploys, provider changes, call-quality investigations and incidents. Those hours are an assumption. Replace them with your own before you act on the table.

ESTIMATE: concurrency fees, not minutes, can decide it

Hosted platforms bill both per minute and per simultaneous line, and the line fee has nothing to do with how many calls you take. A campaign that fires 100 outbound calls at once pays for 100 lines whether it runs for one hour or one month. Fees only, no usage:

N= 10: Vapi $   29 | Retell $    0 | LiveKit Cloud $  50 | Bland Build cap 50 (OK)
N= 20: Vapi $  129 | Retell $    0 | LiveKit Cloud $  50 | Bland Build cap 50 (OK)
N= 50: Vapi $  429 | Retell $  240 | LiveKit Cloud $ 500 | Bland Build cap 50 (OK)
N=100: Vapi $  929 | Retell $  640 | LiveKit Cloud $ 500 | Bland Build cap 50 (needs Enterprise)
N=300: Vapi $2,929 | Retell $2,240 | LiveKit Cloud $ 500 | Bland Build cap 50 (needs Enterprise)

Vapi's number uses the cheaper of pay-as-you-go ($10 for each line above 4) and Core ($29 including 10 lines, then $10 each). I did not model Pro: it lists 30 lines for a $999 monthly minimum, and its "10% of Vapi hosting fee" pricing needs a sales quote to interpret. These fees are small next to a per-minute bill at 10,000 minutes, and large next to it at spiky, low-volume concurrency: 300 simultaneous lines for a short burst is the case where self-hosted or LiveKit Cloud's Scale tier wins on structure, not on the per-minute rate.

7. Operational complexity

The platform fee buys three things the build path has to replace: someone else holding the pager for audio transport, someone else absorbing provider outages by failing over, and someone else shipping turn-taking improvements. Self-hosting does not make those problems smaller. It moves them onto your rota.

The cost I see underestimated most often is not infrastructure. It is the debugging of a call that went wrong at 2am: you need the audio, the transcript, the model's tool calls and the timing of each stage correlated by call id. Hosted platforms ship a call log with that view. On Pipecat or LiveKit Agents you build it, using their observability hooks and your own logging. Budget for it before you commit, because it is the first thing a production incident asks for.

The other cost is the one Vapi's Workflows retirement illustrates. When you build on a hosted abstraction, the vendor's roadmap becomes your roadmap. When you build on a framework, you own the upgrade schedule instead: Pipecat shipped v1.12.0 and LiveKit Agents shipped 1.8.5 within two weeks of each other, so a fast-moving dependency is part of the price of owning the stack.

8. Scale

The right answer moves with volume and concurrency, not with company size.

• Under about 10,000 minutes a month: any hosted option costs under roughly $1,500 a month in my model. Engineering time spent on infrastructure is worth more than the saving. Buy.
• 10,000 to 85,000 minutes a month: buy, and spend the effort on keeping your prompts, tool schemas and phone numbers portable so the later move is cheap.
• Above roughly 85,000 minutes a month, with a platform engineer already on staff: the self-hosted line starts to win on cost alone, and the gap widens linearly with volume.
• High peak concurrency with low average volume: look at the line fees in the table above before the per-minute rate.
• A data-control requirement (call audio must stay in your region, on your infrastructure): the cost math stops being the deciding factor.

9. Decision matrix

Scores are Low, Medium or High and reflect the reasoning above. Cost is cost at 50,000 minutes a month under the reference configuration. Operational burden is the ongoing engineering load. Lock-in is how hard it is to move your agent logic out.

The Lock-in cell for Retell reflects my reading of how its flow editor works rather than a measured migration, and I have not ported an agent between these platforms. Treat that row as my judgement.

10. Recommendation by scenario

Recommendation (my judgement, not a measurement). I do not give one winner, because the answer flips on volume, concurrency and who is on your team.

• Product team shipping a first voice feature, no platform engineer, under 30,000 minutes a month. Retell, for the single invoice, the 20 free concurrent lines and the visual flow editor. Flip to Vapi if you want the agent defined as configuration in version control and the freedom to swap model providers.
• Engineering-led team that wants model-layer control and has a developer who will own the agent. Vapi, on pay-as-you-go or Core. Keep the prompt and tool schemas in your own repository so the agent is not trapped in the dashboard.
• Outbound-heavy workload, 1,000s of calls, tolerant of bundled models. Price Bland Build against the others with a real call script. Its $299 fee and 50-line cap are the two numbers that decide it.
• Above about 85,000 minutes a month, with a platform engineer already on staff. Run a self-hosted pipeline on Pipecat or LiveKit Agents, starting on LiveKit Cloud and moving to your own compute only once you have measured it.
• Regulated workload where call audio must stay in your region or on your infrastructure. Self-host regardless of the cost curve. This scenario is decided by the data requirement, not by section 6.

Two things flip almost every row: your real concurrency pattern (see the line-fee table) and what your engineers' time is worth. If I had to name one number to measure first, it is peak simultaneous calls over the last 30 days, because that single figure moves the answer more than the per-minute rates do.

11. Migration path

If you are on a hosted platform today and the table suggests you are near the self-hosting range, do not migrate on the strength of a spreadsheet. The sequence I would follow:

1. Measure first. Pull 30 days of minutes, peak concurrency, average call length and failure rate from your current platform's call log. Re-run the script in section 6 with your own numbers in place of mine.
2. Make the agent portable. Move prompts, tool schemas and conversation state into your own repository. Whichever way you go, this step costs little and removes the lock-in.
3. Check phone-number porting. Find out whether your numbers can be ported to a SIP provider, and how long your current provider takes. I have not verified porting timelines for any of these vendors, so ask each one in writing.
4. Pilot one call type. Run a single low-risk flow on Pipecat or LiveKit Agents for two weeks, with a fallback path back to the hosted platform. Compare call completion and the on-call load, not just the per-minute cost.
5. Re-check every price. Every figure in this guide is an 8 October 2026 snapshot, so read the live pricing pages again before you sign anything.

What I did not measure

I did not run calls on any of these platforms for this guide. The costs are modelled from published prices, the latency figures are vendors' own claims, and the engineering-hours inputs are assumptions. I fetched the pricing pages, the Vapi migration notice and the framework release data myself on 8 October 2026; I have not seen any vendor's audit reports. If you want to see how I think about the conversation-design side that this guide leaves out, my builder-lessons post on a French-language voice agent for a manufacturer covers it.

Related decisions sit in the same cluster: the buyer's framework for choosing a voice agent, the cost comparison against a call centre, and the use-case overview. To check whether the savings justify the project, use the ROI calculator, and to see whether your team is ready to operate this, try the AI readiness assessment. The wider set of agent architecture posts is under AI agents.

Need a second pair of eyes on this decision?

Book a free 30-minute call. Bring your minutes, peak concurrency and team size, and we will run the numbers together.

See how I work

Suyash Raj Founder, Voxdonna AI and AiSewak. Writes here about n8n, AI agents, and voice automation.