Vapi vs ElevenLabs in 2026, Laravel Integration, and How to Make Money With Voice AI

Most people ask "Vapi or ElevenLabs?" as if they are two brands of the same thing. They are not. They overlap, but they sit at different layers of a voice agent.

Think of a phone desk. Vapi is the manager who hires the staff and controls the switchboard. You choose the speech to text engine, the language model and the voice, and Vapi keeps the call flowing between them. ElevenLabs is the voice actor with the best reputation in the business, who also learned to run the whole desk on their own. You get the voice, the brain connection and the phone handling in one platform.

Once you see it that way, the question stops being "which is better" and becomes "how much control do I want, and how much do I want handled for me?" You can even use both, because Vapi lets you plug ElevenLabs in as the voice.

This guide covers the real differences, what each costs in 2026, how to wire both into a Laravel application with working code, how the same pattern applies to other stacks, and how to turn all of it into revenue without getting burned.

What Vapi actually is

Vapi is a developer platform for building voice agents that talk on phone calls or in a browser. It does the orchestration. It listens to the caller, sends the audio to the speech to text provider you picked, passes the text to the language model you picked, sends the reply to the voice provider you picked, and plays it back fast enough that the call feels natural.

The key idea is that Vapi is model agnostic. You can run OpenAI or Anthropic models, Deepgram for transcription, and ElevenLabs or another provider for the voice. That flexibility is the whole point, and it is also the source of most of the complexity.

Vapi talks to your backend through a server URL. Your application receives events such as status updates, transcripts, tool calls, assistant requests and an end of call report. Some of these events are one way notifications. Others expect a real answer from your server, and Vapi uses your response to steer the call.

What ElevenLabs actually is

ElevenLabs started as a text to speech company and became known for voices that sound human. It now covers voice cloning, dubbing, speech to text, music, sound effects and a full conversational agent platform.

For agents, ElevenLabs runs the conversation on its side. You configure the agent, pick a voice and a model, attach tools, and connect a phone number through your own carrier such as Twilio or a SIP trunk. It reaches your systems through server tools, which are webhooks it calls in the middle of a conversation, and through post call webhooks that fire when the conversation ends and the analysis is done.

It also has a plain API for developers who just want speech generated inside their own product, which is a completely different use case from running a call agent.

The real comparison

Architecture. Vapi is a layer that sits on top of other providers. ElevenLabs is a vertically integrated stack. Vapi gives you more places to make choices. ElevenLabs gives you fewer choices and fewer things that can go wrong.

Voice quality. ElevenLabs is the benchmark most people compare against. With Vapi you can pick ElevenLabs as your voice and get the same quality, so this is less of a gap than it looks. The difference is who bills you and who owns the integration.

Control. Vapi wins. Swapping the language model, changing the transcriber or routing different calls to different providers is a configuration change. In a more integrated platform you work within what the platform supports.

Speed to first working agent. ElevenLabs is usually faster for a first demo, because there is less to wire together. Vapi has a powerful but busy dashboard, and reviewers regularly describe it as overwhelming for newcomers.

Latency and consistency. Every extra provider in a chain is another place for delay. Reviewers of Vapi mention latency that can be unpredictable depending on the stack you assemble. An integrated platform has fewer hops to tune. Test both with your real prompts and your real phone numbers before promising a client anything.

Vendor dependency. With Vapi you depend on Vapi plus every provider under it. With ElevenLabs you depend on one company for everything. Neither is ownership. We will come back to how to protect yourself.

Compliance. Healthcare and other regulated work adds cost and paperwork on both sides. HIPAA on Vapi is an enterprise style add on with meaningful extra cost, so price it into any medical project from day one.

What it really costs in 2026

Pricing is where most people get surprised, so here are the numbers as of September 2026. Both vendors change prices often, and ElevenLabs cut prices during 2026, so confirm the live pricing page on the day you quote a client.

Vapi. The platform fee starts at $0.05 per minute, billed to the second, with no monthly commitment on the self serve plan. That fee covers orchestration only. You also pay for transcription, the language model, the voice and the phone carrier, at cost with no markup from Vapi. Once you add those, most production setups land somewhere between $0.13 and $0.32 per minute, and a basic budget stack can sit around $0.14. If you bring your own provider keys, you pay those vendors directly. There is no permanent free tier, only trial credit for new accounts.

ElevenLabs agents. Agent conversations are billed at $0.08 per minute, down from $0.10 after a price cut. The language model usage is billed on top based on the model you choose. Telephony does not add an ElevenLabs fee, but your carrier still bills you directly for the call. Going past your concurrency limit triggers burst pricing at double the normal rate, so plan capacity if you expect spikes.

ElevenLabs API for plain speech. Text to speech runs $0.10 per 1,000 characters on the multilingual models and $0.05 per 1,000 on Flash and Turbo. Speech to text through Scribe is $0.22 per hour. Subscription plans run from a free tier up to $990 a month, plus custom enterprise, and one credit equals roughly one character of speech.

The lesson. The cheapest headline number is rarely the cheapest deployment. Compare total cost per completed task, such as a booked appointment or a qualified lead, not cost per minute. Also budget a 30 percent buffer for volume spikes, because usage billing has no ceiling unless you set one.

Which one should you pick

Choose Vapi when you want control over each component, when you need to swap models as the market moves, when your calls involve heavy custom logic on your own backend, or when you are building a product that other people will use and you need to avoid being locked to one stack.

Choose ElevenLabs agents when you want the best voice with the shortest path to a working agent, when your team is small, when the use case is straightforward such as answering questions and booking, or when voice quality is the main thing your client will judge.

Choose both when you want Vapi's orchestration and ElevenLabs voices. It costs a little more to manage but gives you flexibility and quality together.

Choose neither as your source of truth. This is the part most tutorials skip. Your customer data, call logs, business rules and prompts should live in your own application. Treat the voice platform as a replaceable vendor. If a price change or an outage hits, you should be able to move without rebuilding your business.

How the integration should be structured in Laravel

Whether you use Vapi or ElevenLabs, the pattern is the same. Your Laravel app is the brain. The voice platform is the mouth and ears.

There are four touchpoints:

• Your app starts calls through the platform API, for outbound campaigns or callbacks.

• The platform calls your app mid conversation to look up data or take an action, which is a tool call.

• The platform sends your app a report when the call ends, with the transcript, summary and cost.

• Your app verifies every incoming request so nobody can fake a call event.

Add this to your environment file and configuration.

php

// config/services.php
'vapi' => [
    'key' => env('VAPI_API_KEY'),
    'webhook_secret' => env('VAPI_WEBHOOK_SECRET'),
    'assistant_id' => env('VAPI_ASSISTANT_ID'),
    'phone_number_id' => env('VAPI_PHONE_NUMBER_ID'),
],
'elevenlabs' => [
    'key' => env('ELEVENLABS_API_KEY'),
    'webhook_secret' => env('ELEVENLABS_WEBHOOK_SECRET'),
    'tool_secret' => env('ELEVENLABS_TOOL_SECRET'),
    'agent_id' => env('ELEVENLABS_AGENT_ID'),
    'agent_phone_number_id' => env('ELEVENLABS_AGENT_PHONE_NUMBER_ID'),
    'voice_id' => env('ELEVENLABS_VOICE_ID'),
],

Start an outbound call with Vapi

A small service class keeps the vendor details out of your controllers, which makes a future swap painless.

php

<?php

namespace App\Services;

use Illuminate\Support\Facades\Http;

class VapiService
{
    public function startOutboundCall(string $number, array $variables = []): array
    {
        return Http::withToken(config('services.vapi.key'))
            ->timeout(15)
            ->post('https://api.vapi.ai/call', [
                'assistantId' => config('services.vapi.assistant_id'),
                'phoneNumberId' => config('services.vapi.phone_number_id'),
                'customer' => ['number' => $number],
                'assistantOverrides' => ['variableValues' => $variables],
            ])
            ->throw()
            ->json();
    }
}

Pass caller specific details such as the customer name or the reason for the call through the variable values, so the prompt can use them without you creating a new assistant for every call.

Handle Vapi webhooks

Set your server URL on the assistant to your Laravel route and add a secret. Vapi sends that secret in a header, and you compare it in constant time.

php

// routes/api.php
Route::post('/webhooks/vapi', \App\Http\Controllers\VapiWebhookController::class);

php

<?php

namespace App\Http\Controllers;

use App\Jobs\StoreCallReport;
use App\Models\Order;
use Illuminate\Http\Request;

class VapiWebhookController extends Controller
{
    public function __invoke(Request $request)
    {
        abort_unless(
            hash_equals(
                (string) config('services.vapi.webhook_secret'),
                (string) $request->header('X-Vapi-Secret')
            ),
            401
        );

        $message = $request->input('message', []);

        return match ($message['type'] ?? null) {
            'tool-calls' => $this->toolCalls($message),
            'end-of-call-report' => $this->endOfCall($message),
            default => response()->json(['ok' => true]),
        };
    }

    private function toolCalls(array $message)
    {
        $results = [];

        foreach ($message['toolCallList'] ?? [] as $call) {
            $args = $call['arguments'] ?? [];
            if (is_string($args)) {
                $args = json_decode($args, true) ?? [];
            }

            $result = match ($call['name'] ?? '') {
                'check_order_status' => $this->orderStatus($args['order_number'] ?? ''),
                default => 'That action is not available.',
            };

            $results[] = ['toolCallId' => $call['id'], 'result' => $result];
        }

        return response()->json(['results' => $results]);
    }

    private function orderStatus(string $number): string
    {
        $order = Order::where('number', $number)->first();

        return $order
            ? "Order {$order->number} is currently {$order->status}."
            : 'I could not find that order number.';
    }

    private function endOfCall(array $message)
    {
        StoreCallReport::dispatch($message);

        return response()->json(['ok' => true]);
    }
}

Two rules matter here. First, the tool response must be fast, and the assistant request event has a hard limit of about 7.5 seconds end to end that you cannot change. Anything slow belongs in a queued job, not in the response. Second, the informational events such as the end of call report should be acknowledged immediately and processed by a queue worker. That report carries the transcript, summary, cost and recording link, so your StoreCallReport job should save it to your own database. That is what makes the data yours.

Verify ElevenLabs post call webhooks

ElevenLabs signs every webhook with an HMAC. The signature header carries a timestamp and a hash, and the hash is computed over the timestamp, a period and the raw request body. The classic mistake is hashing the body alone, which never matches. Use the raw body.

php

<?php

namespace App\Http\Controllers;

use App\Jobs\StoreCallReport;
use Illuminate\Http\Request;

class ElevenLabsWebhookController extends Controller
{
    public function __invoke(Request $request)
    {
        $header = (string) $request->header('ElevenLabs-Signature');

        parse_str(str_replace(',', '&', $header), $parts);
        $timestamp = $parts['t'] ?? '';
        $signature = $parts['v0'] ?? '';

        $expected = hash_hmac(
            'sha256',
            $timestamp . '.' . $request->getContent(),
            config('services.elevenlabs.webhook_secret')
        );

        abort_unless($timestamp && hash_equals($expected, $signature), 401);
        abort_if(abs(time() - (int) $timestamp) > 1800, 401);

        $payload = $request->json()->all();

        if (($payload['type'] ?? '') === 'post_call_transcription') {
            StoreCallReport::dispatch($payload['data']);
        }

        return response()->json(['ok' => true]);
    }
}

The webhook must return a 200 status to count as delivered. If it keeps failing, ElevenLabs will disable it after ten consecutive failures, so watch your logs and never let this endpoint depend on something slow.

Give an ElevenLabs agent a tool

Server tools let the agent call your Laravel app in the middle of a conversation, for example to check a booking. You configure the tool in the agent settings with your URL and an authorization header, and you check that header on your side.

php

Route::post('/tools/elevenlabs/order-status', function (Request $request) {
    abort_unless(
        hash_equals(
            (string) config('services.elevenlabs.tool_secret'),
            (string) $request->header('X-Tool-Secret')
        ),
        401
    );

    $order = \App\Models\Order::where('number', $request->input('order_number'))->first();

    return response()->json([
        'status' => $order?->status ?? 'not_found',
    ]);
});

Start an ElevenLabs phone call and generate speech

If you run agents on ElevenLabs, outbound calls go through the API with your connected phone number. If you only need voice audio inside your app, such as narrating articles or generating voice notes, call the text to speech endpoint and store the file.

php

use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Storage;

// Outbound call through an ElevenLabs agent
Http::withHeaders(['xi-api-key' => config('services.elevenlabs.key')])
    ->post('https://api.elevenlabs.io/v1/convai/twilio/outbound-call', [
        'agent_id' => config('services.elevenlabs.agent_id'),
        'agent_phone_number_id' => config('services.elevenlabs.agent_phone_number_id'),
        'to_number' => '+15551234567',
    ])->throw();

// Plain text to speech saved to storage
$audio = Http::withHeaders(['xi-api-key' => config('services.elevenlabs.key')])
    ->post('https://api.elevenlabs.io/v1/text-to-speech/' . config('services.elevenlabs.voice_id'), [
        'text' => 'Your appointment is confirmed for Thursday at three.',
        'model_id' => 'eleven_flash_v2_5',
    ])->throw();

Storage::put('voice/confirmation.mp3', $audio->body());

Use Flash for anything real time or high volume, because it costs half as much per character. Use the multilingual or v3 models when expressiveness matters more than price.

Production checklist for Laravel

• Run webhook processing on queues with Horizon or a plain queue worker, and keep controllers thin.

• Make handlers idempotent. Vendors retry, so the same call report can arrive twice. Key your storage on the call or conversation ID.

• Store every transcript, summary, cost and outcome in your own tables.

• Log every tool call with its arguments and result so you can audit what the agent did.

• Wrap vendor calls behind an interface such as VoiceProvider, so moving from one platform to another means writing one new class, not rewriting the app.

• Rotate secrets and keep them out of the repository.

The same pattern in other ecosystems

The integration is just HTTP, signatures and JSON, so the pattern moves across stacks unchanged.

Node.js and Express or Next.js. Use a route handler for the server URL. For ElevenLabs, the official JavaScript SDK includes a helper to verify the signature, and you must read the raw request body for it to work, so avoid JSON body parsing on that route. Next.js route handlers are a clean fit for both platforms.

Python with FastAPI or Django. Same structure. Read the raw body, rebuild the timestamp plus body string, and compare the HMAC yourself. Note that the Python SDK does not do webhook verification for you, so write that check manually.

WordPress and WooCommerce. Register a REST route with register_rest_route, verify the secret, and expose tools such as order lookup, booking or lead capture. This is a strong option for local business clients who already run WordPress, because the agent can read WooCommerce orders and write leads straight into the site.

Automation platforms. Tools like n8n, Make and Zapier can receive the webhooks and connect to CRMs, calendars and spreadsheets without code. If you care about owning your infrastructure, self host n8n and keep the automation layer in your control instead of renting it.

Mobile and web apps. Both platforms offer client side SDKs for browser and mobile voice conversations, so the agent can live inside your app instead of only on the phone.

Use cases that actually work

Voice agents are best at narrow, repetitive, high volume conversations where the goal is clear.

• Answering calls for clinics, restaurants, salons, law offices and home service businesses, then booking appointments and capturing details.

• Qualifying inbound leads and pushing them into a CRM with a summary.

• Order status, delivery and refund intake for ecommerce, where the agent gathers the case and a human approves the outcome.

• Appointment reminders and confirmations that reduce no shows.

• Multilingual support where hiring staff for every language is not realistic.

• Voice content such as narrated articles, audiobooks, training material and localized video.

The pattern that fails is the open ended agent with authority to decide anything. Keep the agent's power small and specific.

How to make money with Vapi and ElevenLabs

This is the part everyone wants, so here it is with honest numbers. The examples below are illustrative, not guarantees, and your results depend on your niche, your sales skill and your delivery quality.

1. The AI receptionist retainer. Build a voice agent for a local business, connect it to their calendar and CRM, and charge a setup fee plus a monthly retainer. Setup fees commonly range from $1,000 to $3,000 for a proper build, with monthly retainers of a few hundred dollars that include a set number of minutes. Your cost is the per minute usage. If a clinic uses 800 minutes a month at an all in cost of about $0.15 per minute, you spend roughly $120 and can charge $400 to $600 for the service, which includes monitoring, prompt tuning and reporting. That last part is what clients are really paying for.

2. Per minute resale. Charge clients a per minute rate above your cost, for example $0.30 to $0.50 against a real cost of $0.12 to $0.20. It scales with usage but exposes you to cost swings, so build in a margin that survives vendor price changes.

3. A vertical product. Package one niche, such as agents for dental practices or real estate teams, with a Laravel dashboard, call logs, appointment sync and billing. Recurring revenue from a focused product beats one off projects. This is where owning your application layer pays off, because you can change voice vendors underneath without your customers noticing.

4. Outbound campaigns done responsibly. Appointment reminders, payment follow ups and lead callbacks with people who have given consent. This can be profitable, but it is also the fastest route to legal trouble if you get consent wrong.

5. Voice content and localization. Use ElevenLabs for narration, audiobooks, course voiceovers and dubbing into other languages. Agencies and publishers pay for turnaround speed and quality. Cloning a voice requires clear permission from the person whose voice it is.

6. Internal savings. If you run a business, the return can simply be cost avoided: fewer missed calls, faster support, and staff freed from repetitive work.

Two pricing rules will save you. Always price on your fully loaded cost, including telephony, the language model, concurrency and your own support time. And never sell unlimited minutes.

Risks you should take seriously

Voice agents talk to real people, so the standards are higher than for a chatbot.

Consent and disclosure. Outbound calling is regulated in many countries, and recording rules vary by location. Get consent, respect do not call lists, and tell callers they are speaking to an AI where the law or basic decency requires it.

Human oversight. Give every agent a clear path to a human. Keep money movements, refunds, medical advice and contract changes behind human approval. Log everything the agent does. Automation should reduce repetitive work, not remove accountability.

Hallucination and scope. A confident wrong answer on a phone call damages trust fast. Restrict the agent to tools and facts you control, and test with adversarial calls before launch.

Data protection. Transcripts and recordings contain personal information. Store them in your own controlled environment, define retention periods and check whether your client needs stronger compliance such as HIPAA.

Cost runaway. Set concurrency limits, monthly spend alerts and maximum call durations, so a loop or a spike does not turn into a shocking invoice.

If you want the fastest route to a great sounding agent with fewer moving parts, start with ElevenLabs. If you want control, flexibility and the ability to swap components as the market shifts, build on Vapi and use ElevenLabs as the voice. In both cases, keep your data, business rules and integrations inside your own application, and treat the platform as a supplier you can replace.

The businesses that make real money here are not the ones with the fanciest voice. They are the ones who pick a narrow problem, connect the agent to real systems, keep a human in the loop and price with honest math. Start with one niche, one workflow and one measurable result, then scale from there