Voice agent pricing pages quote a per-minute rate, but a phone call on ElevenAgents is billed on three separate lines. The platform minute covers speech to text, text to speech, and orchestration, while the language model is billed on top by token and your carrier bills the phone line. The pricing FAQ says as much, but $0.08 per minute is the number that ends up in the budget.

This guide shows you how to pull the usage for a call from the API, turn it into a cost for all three lines, and bring that cost down. The worked example is one scripted test call, so read it as an example of the method rather than as a benchmark. All the code is in the companion repo, written in TypeScript with the ElevenLabs JS SDK, and prices were checked on 28 September 2026.

Summary

• The conversation details endpoint returns billed minutes, LLM tokens, and LLM price for every call, which is enough to cost the platform and LLM lines.
• On a 92-second test call with Gemini 2.5 Flash, those two lines came to $0.126 at list rates, and the LLM was $0.0026 of that, or 2%.
• Adding a carrier at Twilio's list rate gives an estimated phone-call total of $0.143, although no phone line was actually billed because the test ran over WebSocket.
• Swapping the model changes the LLM line by up to 15x, and past about 55 pages without RAG, a knowledge base costs more than the model choice.
• Prompt caching worked without configuration, and 23% of input tokens were cache reads, billed at $0.
• Priced at raw API list rates, the same usage comes to an estimated $0.070, about half the platform route, before hosting and engineering.

Where the money goes on a voice call

A call passes through four stages but bills on three lines, and Figure 1 shows which of those stages sit inside the platform minute.

Speech to text and text to speech sit inside the platform minute.

Additional platform minutes cost $0.08 on every plan, or $0.16 for calls that burst past your concurrency limit. Silence is billed at 5% of the rate, per the cost optimization guide, so long silences cost less.

The language model is billed by token at the rates on the LLM prices table. On that table, Claude Sonnet 5 is about 10% above Anthropic's own price, while Gemini 2.5 Flash is half of Google's on input and about a quarter on output.

ElevenLabs doesn't charge for the phone line, because your provider bills the carrier side directly. Twilio, for example, charges $0.0085 per minute for an inbound local call in the US, billed in whole minutes.

A worked example

The test agent is a support line for a fictional clothing store. It has a 4,916-character system prompt of about 1,230 tokens, one webhook tool called lookup_order, Gemini 2.5 Flash as the LLM, Flash v2 as the voice, and no knowledge base. Six scripted customer lines were sent to it as audio over the conversation WebSocket, playing a customer who asks for a refund on a late order. The agent looked the order up and agreed to the refund, and the whole call ran for 92 seconds. The agent also read its own closing reasoning aloud, which made up 101 of the 933 characters it spoke.

The table below separates what was measured from what was estimated. The billed minutes and the LLM price come from the call's record, and the platform line prices those minutes at the $0.08 list rate. Because the call never touched a phone network, the phone line is an estimate of what Twilio would charge for the same call.

The test ran on the Free plan, where the record's own cost_fiat was $0.105, since it values the minutes at $0.102 in credits rather than at the list rate. For budgeting, use the list rate, at which the platform is 86% of the estimated total, the phone line 12%, and the LLM 2%.

Estimated phone-call total for the test call, at list rates. The phone line is hypothetical.

Getting the numbers from the API

The four steps below use the companion repo, so run npm install first. Steps 2 to 4 also need your ELEVENLABS_API_KEY in a .env file.

Step 1: Estimate before you deploy

The LLM usage calculator returns a cost per minute for every model based on your prompt length, knowledge-base size, and RAG setting, and you can call it without an API key.

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const el = new ElevenLabsClient({ apiKey: process.env.ELEVENLABS_API_KEY || "none" });
const { llmPrices } = await el.conversationalAi.llmUsage.calculate({
  promptLength: 4916,
  numberOfPages: 0,
  ragEnabled: false,
});

for (const p of llmPrices) console.log(p.llm, `$${(p.pricePerMinute * 4).toFixed(3)} per 4-minute call`);

The repo wraps this call as npm run estimate, with --pages and --rag flags. For Gemini 2.5 Flash it returned $0.0028 a minute, higher than the $0.0017 in the test call's record, so expect its figures to run high.

Step 2: Place a test call

npm run create-agent builds the test agent with its lookup_order tool, and npm run scripted-call -- <agent_id> plays the six customer lines into it and prints the conversation ID. In your own code, you open a signed URL, stream audio in 250 ms chunks, and answer pings.

import WebSocket from "ws";

const { signedUrl } = await el.conversationalAi.conversations.getSignedUrl({ agentId });
const ws = new WebSocket(signedUrl);

ws.on("open", () => ws.send(JSON.stringify({ type: "conversation_initiation_client_data" })));
ws.on("message", (raw) => {
  const e = JSON.parse(raw.toString());
  if (e.type === "conversation_initiation_metadata") conversationId = e.conversation_initiation_metadata_event.conversation_id;
  if (e.type === "ping") ws.send(JSON.stringify({ type: "pong", event_id: e.ping_event.event_id }));
});

// nextChunk() returns the next 250 ms of customer audio, or silence.
setInterval(() => ws.send(JSON.stringify({ user_audio_chunk: nextChunk().toString("base64") })), 250);

Each test call uses about 1.5 call minutes, and the Free-plan test call's record showed free_minutes_consumed of 0.0, so don't count on included minutes to cover your test calls.

Step 3: Read the bill after the call

The conversation details endpoint returns the usage for a finished call. Because the SDK returns fields in camelCase, cost_fiat comes back as costFiat, which is the ElevenLabs total before the phone line.

const conv = await el.conversationalAi.conversations.get(conversationId);
const { callDurationSecs, costFiat, charging } = conv.metadata;

const minutes = charging?.platformUsage?.categoryUsage?.voice?.quantity ?? 0;
const phoneMinutes = Math.ceil((callDurationSecs ?? 0) / 60);

console.log({
  platformAtList: minutes * 0.08,
  llm: charging?.llmPrice,
  phoneEstimate: phoneMinutes * 0.0085,
  elevenLabsRecorded: costFiat,
});

A trimmed SDK response from the test call, with IDs removed, looks like this.

{
  "callDurationSecs": 92,
  "costFiat": 0.1048,
  "charging": {
    "tier": "free",
    "platformUsage": { "categoryUsage": { "voice": { "quantity": 1.5372, "price": 0.1022 } } },
    "llmPrice": 0.00259
  },
  "phoneCall": null
}

npm run call-cost prints the same breakdown as the table in the worked example, marking which lines come from the record and which are estimated.

Step 4: Roll up a week of real calls

npm run report -- <agent_id> --days 7 --csv out/report.csv

The report prints one row per call with billed minutes, each cost line, and cache share, followed by the totals and the estimated cost per minute. With your own numbers in hand, the next question is which choices move them most.

Voice agent cost by model

The calculator gives these costs for the same prompt across six supported models, scaled to a four-minute call.

The same four-minute call with each model. Only the LLM changes.

Choosing Sonnet 5 over Gemini 2.5 Flash adds about 16 cents a call, or $7,800 a month at 50,000 calls. Since the calculator ran high on the measured call, these figures may overstate real costs, and a knowledge base can matter even more.

Adding twelve pages roughly quadruples the LLM line on both models. At 100 pages, RAG cuts it by more than 3x, because without it every generation carries the whole knowledge base. On Gemini 2.5 Flash without RAG, the knowledge base overtakes a model swap at about 55 pages, so past that point you should turn RAG on and trim what the knowledge base holds.

What the platform minute buys

The platform minute pays for turn detection, interruption handling, streaming, tool calling, and hosting. To see what that costs you, price the same call at raw API list rates, using the character and second counts from its record. This is an estimate, not a bill.

The same call priced from the raw APIs, before hosting and engineering.

Off the platform, you pay Google's own Gemini price, more than twice ElevenLabs' rate here. On these estimates, the raw APIs cost 49% of the $0.143 platform total. The gap is about 4.7 cents a minute, or $4,700 a month at 100,000 minutes, and it has to pay for a server, turn-taking and interruption logic, and the engineers who build and run them.

What reduces voice agent cost the most?

If you want a short list to act on, these are the changes that save the most.

Roughly in order of impact, you can use the following methods to reduce the cost of a call:

• Pick a model that fits the job, because an agent that mostly looks up orders doesn't need the most capable one and the LLM line changes by up to 15x between models.
• Keep the start of the prompt stable and dynamic variables out of the top, because caching only works while the opening of the prompt stays the same.
• Turn on RAG once a knowledge base passes about 55 pages, so each generation no longer carries the whole knowledge base.
• Use agent transfer to hand off to a smaller agent, so each stage loads only its own prompt.
• Trim the prompt and tighten the closing instruction, since every extra sentence the agent speaks adds to the call time.

For the caching math, see the repo's README, and for deeper techniques, see the cost optimization guide.

What to measure on your own calls

On real calls, these three numbers tell you where to look first.

• Minutes per call. The platform line is most of the bill, so call length matters most.
• Fresh input tokens per turn. If this is far above your prompt length, the transcript or tool results are driving the cost.
• Cache hit share. Check input_cache_read in the record, since zero on a caching model means your prompt changes between turns, often because a dynamic variable sits at the top.

Build with ElevenAgents

Run npm run estimate from the companion repo on your own prompt and knowledge base, pick a model, and run npm run report over your first ten real conversations. Then compare its estimated cost per minute with the $0.093 here. Get started by using ElevenAgents to create an agent, or contact sales for volume pricing.

FAQs about voice agent cost per call

How much does an AI voice agent cost per call?

On ElevenAgents, the platform minute is $0.08 at list rate, with the LLM billed by token and your carrier billing the phone line on top. The 92-second test call here comes to an estimated $0.143 once you add a hypothetical phone line, or $0.093 a minute. Call length, model, and knowledge base move the cost the most, so run the report on your own calls.

Does the $0.08 per minute include the LLM?

No, LLM usage is billed separately by token. It made up 2% of the test call's estimated total with Gemini 2.5 Flash, but would be about a third of a four-minute call with Claude Sonnet 5 at the calculator's rates.

Why does the record report LLM usage twice?

The record splits LLM usage into two blocks, initiated_generation andirreversible_generation. On the test call, llm_price matched the initiated block. The docs don't define either block, so check both on your own calls.

How is silence billed on a voice call?

Silence is billed at 5% of the platform rate, per the cost optimization guide. That matters most on calls with long holds, where the agent waits on a tool or the caller.

Is the phone line in cost_fiat?

No, your carrier bills the phone line separately. The example adds it as an estimate at Twilio's list rate, because the test call ran over WebSocket and no carrier was involved.

Why does the record show $0.102 for the platform when the table says $0.123?

The test ran on the Free plan, where the record valued the 1.54 minutes at $0.102 in credits. Since the pricing FAQ doesn't say how credits convert to dollars, budget at the $0.08 list rate.