AI Voice Agent Cost Per Call: A 2026 Engineering Breakdown

If you've priced out a voice AI build by multiplying an advertised per-minute rate by expected call volume, you've already made the mistake that blows up most first-quarter budgets. The advertised rate is almost never the number that shows up on your invoice, and the gap between the two only shows up once real calls start hitting your stack.

This is a builder's breakdown of what an AI voice agent actually costs per call in 2026 — the five layers that make up that cost, how to compute it yourself instead of trusting a vendor's marketing page, and the code to track it in production. We'll use Vapi, ElevenLabs, and Cloudflare Workers as the reference stack, since that's the combination most small teams reach for first.

Why the advertised per-minute rate isn't your per-call cost

Vapi's listed starting price is $0.05 per minute. That number covers exactly one thing: the orchestration layer that routes audio between your telephony provider, your speech-to-text engine, your language model, and your text-to-speech engine. It does not include any of those four services, all of which bill separately and land on top of the base fee.

Once you add a transcription engine, an LLM, and a voice model, the real all-in cost for a production Vapi deployment typically lands between $0.15 and $0.40 per minute, not $0.05. That's a 3x-8x gap between the number on the pricing page and the number on your invoice, and it's the single most common reason teams blow through their first-quarter voice AI budget.

The other thing the per-minute framing hides: minutes and calls are not the same unit. A call includes hold music, silence while a caller looks something up, IVR menu time if you're bridging from an existing system, and the wrap-up seconds after the caller hangs up but before the platform closes the session. Two calls with identical minute counts can have very different costs if one spent 40% of its duration on a reasoning-heavy LLM turn and the other was mostly silence.

The five-layer cost stack

Every AI voice agent call, regardless of platform, is built from the same five billable layers. Understanding each one separately is what lets you actually model cost instead of guessing from a vendor's blended number.

Telephony

Twilio, the most common PSTN provider behind these stacks, charges roughly $0.0085/minute for inbound calls to a US local number and $0.014/minute for outbound calls. Toll-free inbound runs closer to $0.022/minute. A local phone number itself costs about $1.15/month; toll-free numbers run about $2.15/month. This layer is the cheapest part of the stack and the least variable.

Speech-to-text (STT)

Real-time transcription, commonly via Deepgram, runs approximately $0.01/minute. This cost is fairly flat regardless of call complexity since you're paying for continuous audio-to-text conversion, not for how hard the caller's request is to understand.

LLM inference

This is the layer with the widest range: roughly $0.02 to $0.20 per minute depending on model choice. A fast, cheap model handling simple appointment bookings sits at the low end. A frontier model like Claude or GPT-4-class models doing multi-step reasoning, function calling, and longer context windows sits at the high end. This is also the layer most sensitive to prompt design — a bloated system prompt re-sent on every turn multiplies cost linearly with turn count.

Text-to-speech (TTS)

ElevenLabs and comparable voice engines run about $0.04 to $0.08 per minute for real-time conversational output. ElevenLabs' Turbo model targets roughly 300ms of generation latency, low enough to feel conversational rather than robotic; its Flash tier pushes model inference closer to 75ms for short utterances. Latency and cost trade off here — higher-fidelity voices and larger models cost more per minute and can add tens of milliseconds to time-to-first-audio.

Orchestration

The platform fee — $0.05/minute on Vapi's base tier — covers session management, the logic that pipes audio between the other four layers, call recording, and end-of-call reporting. If you build the orchestration layer yourself on Workers instead of paying a managed platform, you eliminate this fee but take on the engineering cost of building and maintaining it.

Caller (PSTN)
   |
   v
Twilio trunk .................. $0.0085-0.014/min
   |
   v
Vapi orchestration layer ....... $0.05/min
   |-- Deepgram STT ............ ~$0.01/min
   |-- Claude/GPT LLM .......... $0.02-0.20/min
   |-- ElevenLabs TTS .......... $0.04-0.08/min
   |
   v
end-of-call-report webhook
   |
   v
Cloudflare Worker (cost calculator)
   |
   v
D1 database (cost_per_call log)

Building a cost calculator you can trust

Rather than trusting a blended per-minute quote, model the five layers directly. This lets you plug in your actual model choices and see where your money goes before you've placed a single call.

interface CallCostInputs {
  durationSeconds: number;
  telephonyRatePerMin: number;   // e.g. 0.0085 for Twilio inbound local
  sttRatePerMin: number;          // e.g. 0.01 for Deepgram
  llmRatePerMin: number;          // e.g. 0.02-0.20 depending on model
  ttsRatePerMin: number;          // e.g. 0.04-0.08 for ElevenLabs
  orchestrationRatePerMin: number; // 0 if self-hosted, 0.05 for Vapi base
}

interface CallCostBreakdown {
  telephony: number;
  stt: number;
  llm: number;
  tts: number;
  orchestration: number;
  totalPerCall: number;
  effectiveRatePerMin: number;
}

function computeCallCost(inputs: CallCostInputs): CallCostBreakdown {
  const minutes = inputs.durationSeconds / 60;

  const telephony = minutes * inputs.telephonyRatePerMin;
  const stt = minutes * inputs.sttRatePerMin;
  const llm = minutes * inputs.llmRatePerMin;
  const tts = minutes * inputs.ttsRatePerMin;
  const orchestration = minutes * inputs.orchestrationRatePerMin;

  const totalPerCall = telephony + stt + llm + tts + orchestration;

  return {
    telephony,
    stt,
    llm,
    tts,
    orchestration,
    totalPerCall,
    effectiveRatePerMin: minutes > 0 ? totalPerCall / minutes : 0,
  };
}

// Example: a 3-minute appointment-booking call on a Vapi + ElevenLabs stack
const example = computeCallCost({
  durationSeconds: 180,
  telephonyRatePerMin: 0.0085,
  sttRatePerMin: 0.01,
  llmRatePerMin: 0.04,
  ttsRatePerMin: 0.06,
  orchestrationRatePerMin: 0.05,
});

console.log(example);
// { telephony: 0.02550, stt: 0.03, llm: 0.12, tts: 0.18, orchestration: 0.15,
//   totalPerCall: 0.5055, effectiveRatePerMin: 0.1685 }

That single example call cost just over 50 cents for three minutes — an effective rate of about $0.17/minute, squarely inside the $0.15-$0.40 real-world range and nowhere near the $0.05 advertised figure. Run this function across a week of call logs with your actual durations and model rates, and you get a real cost baseline instead of a guess.

Real cost per call across three volume tiers

Low volume: 200 calls/month

At an average call length of 2.5 minutes and a blended rate of $0.17/minute, that's roughly $85/month in usage cost. Add a managed platform's monthly minimum or seat fee and you're likely at $150-$300/month all-in. At this volume, the engineering time to build and maintain your own orchestration layer almost never pays for itself.

Medium volume: 2,000 calls/month

Same rate and call length puts usage cost around $850/month. This is the tier where the math starts to shift: the $0.05/minute orchestration fee alone is now roughly $250/month, which is meaningful enough to justify evaluating a self-hosted orchestration layer if you already have Workers experience on the team.

High volume: 10,000+ calls/month

At this scale, usage cost alone is in the $4,250+/month range, and the orchestration fee is over $1,250/month by itself. This is where most teams that started on a managed platform begin migrating orchestration in-house, keeping the managed STT/LLM/TTS vendors but replacing the middle layer with a Worker-based call router to cut the $0.05/minute fee.

Instrumenting cost tracking in production

Whichever stack you run, you want per-call cost logged automatically, not reconstructed from a monthly invoice after the fact. Vapi fires an end-of-call-report webhook with duration and per-layer usage data; the handler below computes cost with the same function from above and writes it to D1.

interface Env {
  DB: D1Database;
  VAPI_WEBHOOK_SECRET: string;
}

interface VapiEndOfCallReport {
  type: 'end-of-call-report';
  call: {
    id: string;
    durationSeconds: number;
  };
  costBreakdown?: {
    transport: number;
    stt: number;
    llm: number;
    tts: number;
  };
}

export default {
  async fetch(request: Request, env: Env): Promise {
    const signature = request.headers.get('x-vapi-signature');
    if (signature !== env.VAPI_WEBHOOK_SECRET) {
      return new Response('Unauthorized', { status: 401 });
    }

    const payload = await request.json();

    if (payload.type !== 'end-of-call-report') {
      return new Response('Ignored', { status: 200 });
    }

    const minutes = payload.call.durationSeconds / 60;
    const breakdown = payload.costBreakdown;

    const totalCost = breakdown
      ? breakdown.transport + breakdown.stt + breakdown.llm + breakdown.tts
      : 0;

    // Cloudflare Workers gives you up to 30 seconds of CPU time per request
    // on paid plans -- writing one row to D1 uses a fraction of that, so
    // there's no need to queue this unless you're batching many calls.
    await env.DB.prepare(
      `INSERT INTO call_costs (call_id, duration_seconds, cost_total, cost_llm, cost_tts, cost_stt, created_at)
       VALUES (?, ?, ?, ?, ?, ?, datetime('now'))`
    )
      .bind(
        payload.call.id,
        payload.call.durationSeconds,
        totalCost,
        breakdown?.llm ?? 0,
        breakdown?.tts ?? 0,
        breakdown?.stt ?? 0
      )
      .run();

    return new Response('OK', { status: 200 });
  },
};

Point this Worker at your Vapi assistant's server URL and you get a running ledger of actual cost per call, queryable by day, by assistant, or by average handle time — the numbers you need to catch a cost regression before it shows up as a surprise on next month's bill.

Vapi managed cost vs bring-your-own-stack

The $0.05/minute orchestration fee is what you're paying Vapi to not build the piece that routes audio between STT, LLM, and TTS and handles turn-taking, interruption handling, and call state. Building that yourself on Workers is genuinely doable — it's a WebSocket relay with some state management — but it is not free engineering time, and it comes with an ongoing maintenance cost every time one of the underlying provider APIs changes.

A rough breakeven: if your orchestration fee is costing more per month than one engineer's time to build and maintain the equivalent Worker-based router, self-hosting starts to make sense. For most teams that threshold lands somewhere in the medium-to-high volume tier above, not before it. Vapi's own average first-response time, cited around 10 seconds from call start to the assistant speaking, is also a benchmark worth holding your own build to before you commit to replacing a managed layer that already meets it.

Production gotchas

A handful of cost surprises show up only after you're live, not in a pricing calculator:

Concurrency caps cost money before you hit them. Vapi's default plan includes 10 concurrent call lines; each additional line is $10/month regardless of whether it's ever used. If your call volume is bursty (a lunch-hour spike for a restaurant, a Monday-morning spike for a dental office), you'll provision for peak concurrency, not average.

HIPAA compliance is a flat add-on, not a percentage. Vapi charges roughly $1,000/month for HIPAA-eligible infrastructure, independent of call volume. For a low-volume medical practice, that fee alone can dwarf usage cost.

LLM cost is prompt-shape sensitive, not just model-choice sensitive. A system prompt re-sent on every conversational turn multiplies with turn count. Two assistants on the identical model can have a 3x cost difference purely from context length and how much conversation history gets re-sent per turn.

Webhook retries can double-count cost if you're not idempotent. Vapi retries webhook deliveries on timeout. If your handler doesn't check for an existing call_id before inserting, a retried end-of-call-report creates a duplicate row and silently inflates your reported cost.

Minute rounding compounds at volume. Some layers bill in whole-second increments, others round up to the nearest 6 or 60 seconds. At 200 calls/month the rounding is noise; at 10,000 calls/month it's a real line item.

When this is NOT the right solution to build yourself

If you're under roughly 500 calls/month, the engineering time to build, test, and maintain your own orchestration layer, cost-tracking pipeline, and webhook handling will cost more than the $0.05/minute fee you're trying to avoid. That fee is genuinely cheap insurance against having to be the on-call engineer when a provider API changes shape at 2am.

If your team doesn't already have someone comfortable owning a WebSocket relay in production, don't make your first voice AI project also your first real-time infrastructure project. Get the managed version live, measure real cost per call with the calculator above, and only migrate orchestration in-house once the math in the volume-tier section actually favors it.

If compliance is in scope — HIPAA for a medical practice, a state bar's client-confidentiality rules for a law firm — the flat compliance fee from a managed platform is usually far cheaper than building and auditing that yourself. For teams in Bend and Central Oregon evaluating whether to build in-house or hand this off, we cover the underlying webhook architecture in more depth in our Vapi webhook architecture guide, and if you'd rather have a working, cost-monitored voice agent live without owning the infrastructure, you can book a demo and we'll walk through what it costs for your actual call volume.

Caller (PSTN)
   |
   v
Twilio trunk
   |
   v
Vapi orchestration layer
   |-- Deepgram STT
   |-- Claude/GPT LLM
   |-- ElevenLabs TTS
   |
   v
end-of-call-report webhook
   |
   v
Cloudflare Worker (cost calculator)
   |
   v
D1 database (cost_per_call log)

Frequently asked questions