The same backend, rebuilt every time
Adding voice calling to an app sounds like a feature. In practice it is a project.
Pick a provider — Twilio, Plivo, Amazon Chime — and the SDK is the easy part. Before your first call connects, you also need:
- A token service that exchanges your provider credentials for short-lived access tokens the browser SDK can use.
- A webhook endpoint the provider can call, wired to the right app logic, with signature validation so you are not accepting spoofed requests.
- Call control endpoints for hold, mute, transfer, and DTMF.
- A real-time event channel so your UI knows the call is ringing, connected, or ended.
- And then the part everyone underestimates: a dialer UI that feels solid — dial pad, call timer, error states, device permissions.
None of this is your product. All of it stands between you and shipping.
What the existing options get wrong
We looked hard before building anything.
Per-minute AI platforms like Vapi and Retell are great if you want an AI agent answering calls — but you pay a per-minute markup on every call forever, and you are locked into their stack.
Open-source SIP and voice libraries give you a transport layer and stop there. You still build the backend, the token flow, and the entire UI.
Provider SDKs themselves are solid but provider-shaped. Building on @twilio/voice-sdk directly means Twilio concepts leak all over your codebase, and switching providers later is a rewrite.
The gap: nobody offered a drop-in dialer where you bring your own provider keys and pay a flat fee — not per minute.
The Alloqui answer
Alloqui is the "Firebase for Voice" model:
- Sign up and enter your Twilio or Plivo credentials in the dashboard. We encrypt them with AES-256-GCM and auto-configure the provider side (TwiML apps, API keys, webhooks).
- Get a project key:
al_live_...
- Drop one component into your app:
import { Dialer } from "@alloqui/dialer";
<Dialer projectKey="al_live_abc123" />
That's it. Tokens, webhooks, call control, events, and the UI are handled.
The part we care most about: your calls never touch our servers
Alloqui only handles signaling — lightweight JSON that sets calls up and tears them down. The actual audio flows directly between the browser and your provider over WebRTC.
This matters for three reasons:
- Latency. No middleman hop on the media path.
- Privacy. We physically cannot listen to your calls.
- Cost. Because we are not relaying audio, we do not need to charge per minute. Free covers outbound calling; Pro is a flat $15/month for inbound, transfer, recording, and AI features.
Provider-agnostic by design
Under the hood, every provider implements the same interface — on the backend (token generation, call control) and in the browser (a VoiceEngine abstraction that lazy-loads only the SDK your project needs). Your project key resolves to the right provider at runtime.
Today that means Twilio and Plivo. The abstraction is the point: when we add a provider, you switch by changing credentials in the dashboard — not your code.
Where this is going
The roadmap is public and simple: inbound calling and recording on Pro, more providers, and AI transcription and summaries with your own STT/LLM keys — again, no per-minute markup on intelligence either.
If you have rebuilt telephony plumbing more than once, start building — the free tier is genuinely free.