Skip to content
Expedify
4 min

Voice Inbound Call

The phone rings and a workflow decides what happens next — an AI agent that already knows who is calling, or a transfer to a person. The node pauses the run for the length of the call.

A call arrives. Before anyone picks up, there is a moment in which a workflow could look up the number, find the customer, check whether they have an open ticket, and decide what to do about it. This node is what happens at the end of that moment.

It is an action, not a trigger, and that is the whole design. The trigger tells you the phone is ringing; this node handles the call. Everything between them — a CRM lookup, a condition, a knowledge base search — runs while the caller is still hearing the ring tone. By the time an AI agent speaks, it can already know their name and what they bought.

No workflow on this page, and the source for this lesson was never written. Inbound voice needs a telephony provider and a claimed number, and the tutorial organisation has neither — the validator rejects the trigger outright. This lesson is written from the node itself.

The fields

call_sid

What it holds
Call SID from Voice Inbound Trigger node

call_type

What it holds
How to handle the call: AI agent or human transfer One of: ai · human Defaults to ai.

ai_call_config

What it holds
AI agent configuration

human_call_config

What it holds
Human transfer configuration

call_timeout_minutes

What it holds
Workflow wait timeout: How long the workflow should wait for call to complete (answer/fail/hangup) before moving to next step. Does NOT limit active call duration - use Voice Agent's 'Max Conversation Duration' for that. Default: 30 min. Critical for preventing stuck workflows. Defaults to 30.

Two of those five are required and one comes from the trigger. call_sid identifies the call and you fill it with a reference like {{voiceinboundtrigger_1.call_sid}} — it is how this node knows which ringing phone it is answering. Get it wrong and the node has nothing to act on.

Everything else follows from call_type. Set it to ai and you must name a Voice Agent node in ai_call_config; set it to human and you must give human_call_config a number to forward to. The panel hides whichever half does not apply.

Handing the agent what it already knows

The AI configuration has a variables map, and it is the reason this node is an action rather than part of the trigger. Whatever you put in it — a name from a CRM lookup, an account status, the last order — is available to the Voice Agent as it speaks.

That is the difference between “thanks for calling, can I take your name” and “hello Priya, is this about the order from Tuesday”. The lookup happened while the phone was ringing. Nothing about the agent is cleverer; it was simply handed the answer.

The timeout is not what it sounds like

call_timeout_minutes does not limit how long the call may last. It is how long the workflow waits for the call to finish before giving up and moving on. Set it to five and a nine-minute call still runs to nine minutes — the workflow just stopped waiting at five and carried on without the result. To cap the conversation itself, use the Voice Agent's own maximum duration.

It runs from 1 to 60 minutes and defaults to 30. The default is deliberately generous, because the failure it exists to prevent is a workflow that waits forever on a call that ended badly. Set it a comfortable margin above your longest real call rather than tight.

Two other things belong to the Voice Agent and not here, which the node's own schema takes the trouble to say: recording the call, and the maximum length of the conversation. If you are looking for either in this panel, you are in the wrong node.

The workflow pauses for the whole call

When this node runs it returns immediately with workflow_paused set and a reason of voice_call_wait, and the execution stops there. Nothing is running while the conversation happens. When the call ends the workflow resumes at this node, and only then does the output gain what the call produced.

{{alias.action}}

When it appears
Immediately. Which route was taken — connecting an agent, or transferring to a person.

{{alias.workflow_paused}} · {{alias.pause_reason}}

When it appears
Immediately. True and voice_call_wait while the call is live.

{{alias.call_completed}} · {{alias.resumed}}

When it appears
After the call ends. The signal that everything below is now populated.

{{alias.output}}

When it appears
After the call ends. The transcript or result — what the rest of the workflow was waiting for.

{{alias.calls}}

When it appears
After the call ends. One object per call, carrying duration, status and why it finished.

That split matters when you are reading an execution. A run sitting on this node is not stuck; it is on the phone. A run that passed through it in a second either failed early or was never connected.

What breaks

“Completed” does not mean “answered”. Every call ends, including the ones that rang out, hit a busy tone, or went to voicemail. Each of those resumes the workflow with a completed call and an empty transcript. The field that tells them apart lives inside the call record — the sub-status — and it names exactly which of those happened. Branch on it. A follow-up task that fires for “no answer” and for “had a ten-minute conversation” alike is worse than no follow-up.

A wrong call_sid fails quietly rather than loudly. It is a template, so a typo in the trigger's alias resolves to nothing rather than to an error, and the node has no call to attach to. When an inbound flow does nothing at all and the log looks clean, check this field first.

Human transfer is not the Transfer Call node. Setting call_type to human here decides who answers in the first place. Transfer Call — two lessons from now — moves a conversation that is already happening, usually because an AI agent decided it should. Both send a call to a person; only one of them interrupts something.

Try it

  1. With a number claimed and a provider connected, build the smallest inbound flow: the trigger, then this node with call_type set to human and your own mobile in forward_to. Call the number.
  2. Now put a CRM search between the two, looking up the caller by phone. Switch call_type to ai, point it at a Voice Agent, and pass the contact's name through variables. Call again and listen for your own name.
  3. Watch the execution while the call is live — the run is paused on this node, not finished. Hang up and watch it resume.
  4. Call and let it ring out without answering. Read the call record: the workflow resumed, the call completed, and there is no transcript. That is the case your branching has to handle.

Next: Voice Outbound Call — the same machinery pointed the other way, where the workflow decides to ring somebody and has to be careful about it.

Related lessons