TelVox · Connect
Drive a live call, instruction by instruction.
Play audio, gather digits, route, bridge, transfer, conference and queue — from your own code. Each primitive maps to a node in the same 12-node IVR engine and ACD that TelVox Dial ships.
// answer-URL response — a call-control document
{
"instructions": [
{ "play": { "text": "Welcome to Acme support." } },
{ "gather": {
"num_digits": 1,
"timeout": 6,
"action_url": "https://your.app/menu"
} },
{ "dial": {
"queue": "support",
"ring_tone": "us"
} }
]
}The primitive catalog
Twelve nodes, composable from code.
The call-control document is a list of instructions. Each one maps to a real node in the engine — so what you can draw in the visual builder, you can also express programmatically.
IVR node types
- menu
- collect / gather
- play
- business-hours
- api_call
- queue
- agent
- voicemail
- callback
- transfer
- condition
- hangup
Play & gather
Speak prompts and collect DTMF input. The play and gather primitives map straight to the engine's play and collect nodes — build a menu in a handful of instructions.
Live data-dip (api_call)
Call out to your own API mid-call and branch on the answer. The api_call node fetches account context; the condition node routes on it — personalize a flow without leaving the call.
ACD queues
Enqueue callers and distribute to agents with FIFO or longest-idle selection, music-on-hold, max-wait and max-size limits, and overflow audio — the real Redis-backed queue engine.
Conference & bridge
Bridge legs together or drop callers into a conference. Built on the same ARI snoop-and-bridge that powers Dial's supervisor barge, transfer and conference.
Transfer & callback
Hand a call to another number, agent or flow, or schedule a callback so a caller keeps their place without holding the line — both shipped IVR nodes.
Voicemail & business hours
Route to voicemail after hours and gate flows on a business-hours schedule. The voicemail and business-hours nodes are first-class in the engine.
Live data-dip
Look up, then route — mid-call.
The api_call node fetches context from your own systems while the caller waits; the condition node branches on it. Personalize a flow without bouncing the caller out of the call.
// api_call node — branch on an external API mid-call
{
"api_call": {
"method": "GET",
"url": "https://your.app/crm/lookup",
"query": { "phone": "{{call.from}}" },
"timeout": 4,
"save_as": "account"
}
}// branch on what came back
{
"condition": {
"when": "{{account.tier}} == 'gold'",
"then": { "dial": { "queue": "priority" } },
"else": { "dial": { "queue": "support" } }
}
}Honest about what's shipped
Real engine today; programmable markup in preview.
These flows run today on Dial's visual IVR builder, the Redis-backed ACD queue and the ARI bridge/conference engine. The JSON call-control API is in developer preview, and the declarative VoxML markup dialect is roadmap only — every artifact here is illustrative and may differ at GA.
Queues and conferences have their own reference resources. Queue & Members reference
Questions
Call control FAQ
The JSON call-control document is the primary, preview model: your answer URL returns an instructions array (play / gather / dial / record / hangup) and TelVox executes it. VoxML is a declarative XML markup dialect — the genre convention familiar from other CPaaS platforms — and it's roadmap only. Both are illustrative until GA.
Yes. Every primitive here maps to a node in Dial's shipped visual IVR builder — 12 node types including menu, collect, play, business-hours, api_call, queue, agent, voicemail, callback, transfer, condition and hangup — plus the real Redis-backed ACD queue and the ARI bridge/conference engine. What's in preview is the programmable API and markup over the top of them.
The api_call node makes an HTTP request to your endpoint mid-call, with a timeout, and saves the response under a name you choose. A following condition node branches on that data — so you can look up an account in your CRM and route a gold-tier caller to a priority queue, all within the flow.
Yes — Dial's visual IVR builder is shipped and runs the 12-node engine in production. The programmable markup and call-control API described here let you express the same flows from your own code; that API surface is the developer-preview part.
Conferencing and bridging are real, but we don't publish a participant ceiling — that number isn't in our feature catalog, so we won't invent one. Talk to us about your specific topology and we'll tell you what the engine supports.
Build the flow your product needs.
Join the developer preview and we'll map your IVR, queue and conference flows onto the call-control primitives.