How to Set Up Programmable Voice — From Your First API Call to an AI Voice Agent

Programmable voice is a cloud API that lets your application place, receive, and control phone calls in code: you send an HTTP request to dial a number, and a set of call-control instructions — play audio, gather a keypress or spoken intent, record, bridge two legs, or hand the call to an AI agent — decides what happens once the call connects. Setting it up is four moving parts you wire once: an account with a phone number, a webhook that points the platform at your application, the call-control logic that runs when a call starts, and the outbound caller ID and compliance you clear before going live. This guide walks through each step, the building blocks you will reach for, how the category term most people search — Twilio Programmable Voice — compares to Orbit, and the questions teams ask most before they ship.

The examples below are provider-neutral in shape — a programmable-voice request looks broadly the same across platforms — with the platform-specific details called out where they matter. Every Orbit capability named here maps to something the platform ships today.

What programmable voice is, and what it replaces

Before a voice API existed, adding a phone call to software meant operating telecom infrastructure: leasing trunks, negotiating carrier interconnects, and speaking SIP or SS7 directly. A programmable voice API absorbs that once and exposes it as an HTTP request. Your code says "call this number and run this flow," and the platform handles number provisioning, carrier termination, media transport, and the delivery of call events back to you.

The defining feature is programmability: the call is not a fixed IVR tree you configure in a portal, it is a flow your application controls turn by turn. When the call connects, the platform asks your webhook what to do; your app answers with call-control instructions; and as the call progresses — a digit pressed, a recording finished, the far end hung up — the platform posts each event back so your code can react. That request-instruct-event loop is the whole model, and it is identical whether the call is a one-line notification or a multi-turn AI voice agent.

How to set up programmable voice in five steps

1. Provision an account and a phone number

Create an account and acquire at least one phone number to send from and receive on. A local number, a toll-free number, or a short code each has different reach, cost, and registration requirements, so pick the one that matches where your callers are. On a usage-based platform you buy the number and start paying per minute and per number rather than committing to a seat licence up front.

2. Point a webhook at your application

Configure the number (or your account) with a webhook URL — the endpoint the platform calls the moment a call connects or an inbound call arrives. This is the single most important wiring step: without a reachable, low-latency webhook, the platform has nothing to ask when a call starts. In development, tunnel a local server to a public URL; in production, put the endpoint behind the same authentication and monitoring as the rest of your API.

3. Script the call flow with call-control instructions

Decide what the call should do and express it as call-control instructions. A minimal flow answers, plays a message, and hangs up; a real one gathers input, branches on it, records, or bridges the caller to an agent. Two ways to author this coexist on most platforms: a markup or JSON call-control document your webhook returns turn by turn, or a visual flow builder a non-developer can drag together. Keep the logic in your application wherever the branching depends on your own data — a customer record, an order status, an account balance.

4. Place your first outbound call

Trigger an outbound call with a single request that names the destination, the caller ID to present, and the flow to run. In shape it looks like this across providers:

POST /v1/calls
{
  "to": "+15551234567",
  "from": "+15557654321",
  "webhook": "https://app.example.com/voice/inbound"
}

The platform dials the number, and when it connects it calls your webhook for the first instruction. From there the same request-instruct-event loop drives the rest of the call.

5. Go live: caller ID, compliance, and monitoring

Before real traffic, clear the operational gates. Verify or register the caller ID you present so your calls are not marked as spam, confirm you have consent and honor opt-outs for outbound campaigns, and set up event logging so you can see connection rate, answer rate, and failures per destination. Programmable voice fails quietly if you skip this — calls connect but get flagged, or dead numbers burn spend — so treat caller-ID reputation and per-destination monitoring as part of the setup, not an afterthought.

The building blocks of a programmable voice API

Most flows are assembled from the same small set of primitives:

• Call control — answer, play audio or text-to-speech, gather digits or speech, record, bridge, transfer, and hang up.
• IVR and menus — route a caller by the key they press or the intent they speak, either from a returned call-control document or a visual builder.
• Recording and transcription — capture a leg or the whole call and get a text transcript and summary back as an event.
• SIP trunking and bring-your-own-carrier — connect an existing PBX or carrier over SIP so you keep your numbers while gaining programmable control.
• Conferencing — join multiple legs into one room with per-participant mute, hold, and moderation.
• Real-time AI voice agents — stream the caller's speech to a model and stream a spoken reply back, so the flow reasons about what the caller says instead of matching a fixed menu.
• Webhooks and events — the delivery mechanism that reports every state change back to your app so it can react rather than poll.

Twilio Programmable Voice vs Orbit: how the two compare

Twilio Programmable Voice is the reference point most teams search for, so it is worth a direct, honest comparison. Both platforms cover the programmable-voice core; the differences are in how AI voice agents, the other channels, and the underlying network are packaged.

"You can build the same call flows on either platform. The difference Orbit is built around is that AI voice agents, every other channel, and the wholesale voice network sit inside one account instead of across several products and several bills."

The honest read: if all you need is a programmable-voice API, both do the job. Orbit's argument is consolidation — the AI voice agent runs on the same terminated call path as the raw calling API, and messaging, email, and video are metered on the same invoice rather than integrated as separate products.

How Orbit implements programmable voice

Orbit's CPaaS exposes programmable voice as one channel among many behind a single API and a single pay-as-you-go account. The call-control and telephony surface — a drag-and-drop visual IVR builder, SIP-trunk bring-your-own-carrier, ACD call queues, and voicemail with transcription — lives under Orbit's cloud phone system, so you can script a flow in code or build it visually without writing dial-plan by hand.

Where Orbit differs from an API-only toolkit is that the AI voice agent runs on the same call path as the programmable-voice API, not as a bolted-on layer: an agent answers, reasons mid-call, scores its own quality in real time, and warm-transfers to a human with a context note, all on one terminated leg. Orbit publishes the per-stage latency budget those agents are engineered against on its voice-agent latency benchmark, rather than leaving turn latency to a marketing headline.

Underneath, outbound calls terminate over Devotel's own wholesale softswitch, which connects directly to 500+ global carriers rather than reselling an aggregator hop — the same owned backbone that powers the AI voice agents and the cloud phone system, so both run on one terminated path instead of two vendors. See Orbit vs Twilio for the full head-to-head, or voice pricing and the pricing overview for current per-minute rates.

Frequently asked questions

What is programmable voice?

Programmable voice is an API that lets your application place, receive, and control phone calls in code. Instead of configuring a fixed IVR in a portal, your code sends a request to dial or answer a call, and the platform asks your webhook for call-control instructions — play audio, gather input, record, bridge, or hand off to an AI agent — turn by turn, reporting each call event back so your app can react.

How do I make my first outbound call?

Provision a phone number, point a webhook at your application, and send a single request that names the destination, the caller ID to present, and the flow to run. The platform dials the number and calls your webhook for the first instruction when it connects. Before sending real traffic, verify or register your caller ID and confirm you have consent for outbound calling.

Do I need to run my own telecom infrastructure?

No. That is the point of the category. The provider holds the carrier interconnects, number inventory, and compliance registrations, and exposes them as an HTTP API and SDKs. You wire a webhook and write call-control logic; the platform handles termination, media transport, and event delivery.

Can a programmable voice API run an AI voice agent?

Yes. A real-time AI voice agent is a programmable-voice flow that streams the caller's speech to a model and streams a spoken reply back, reasoning about what the caller says instead of matching a fixed menu. On Orbit the AI voice agent runs on the same call path as the raw calling API, so you do not stitch a separate voice-AI product onto your telephony provider yourself.

How is programmable voice billed?

Almost all platforms meter voice per minute plus a monthly charge per phone number, on a pay-as-you-go basis rather than per seat. On a consolidated platform like Orbit, voice usage lands on the same invoice as messaging, email, and video instead of a separate contract per product. Current per-minute rates are published on the pricing page.

Which is better, Twilio Programmable Voice or Orbit?

Both cover the programmable-voice core — outbound and inbound calling, call control, recording, and SIP trunking. Twilio sells voice, messaging, email, and AI as separate products on separate bills; Orbit puts AI voice agents, every other channel, and its own wholesale voice network in one account on one pay-as-you-go bill. If you want an AI-first, all-in-one platform rather than several products to integrate and reconcile, Orbit is the closer fit.

The takeaway

Programmable voice comes down to one loop repeated for every call: your app requests an action, the platform asks your webhook what to do, and it reports back each event so your code can react. Set it up by provisioning a number, pointing a webhook at your application, scripting the flow, placing a test call, and clearing caller-ID and compliance before you go live — then the same primitives that answer a one-line notification also power a full AI voice agent. Whatever platform you build on, evaluate it on the substance that matters here: call-control flexibility, how cleanly AI voice agents sit on the call path, network ownership, and whether the rest of your channels share one account and one bill.

Published 18 July 2026.