Build a Missed-Call Text-Back Workflow in n8n

A missed call from a prospect is a lost sale unless someone catches it fast. Service businesses know this, which is why tools like the ones charging $99 a month exist purely to text back missed callers. The whole product is three steps: detect the missed call, send an SMS, triage the reply. An n8n missed call text back workflow does the same thing for the cost of Twilio usage.

The reason most guides don't show this isn't the SMS. Sending a text is one node. It's the detection. Twilio docs cover how to send messages and how to receive them, but wiring the missed-call status callback into a trigger is the exact step every page leaves out.

This builds the whole thing, starting with the part that's actually hard.

What you can automate around a missed call

Once the detection trigger works, the follow-up is straightforward:

• Instant text-back to any unanswered call
• AI triage of the reply: is this a hot lead, a wrong number, an existing customer?
• Route hot replies to a sales rep's phone or Slack immediately
• Log the call and outcome to a CRM or Google Sheet
• Schedule a follow-up if the caller doesn't reply within an hour
• Suppress text-backs to numbers already in an active conversation

The value is speed. A caller who gets a text in five seconds is still thinking about you. One who hears back tomorrow has already called a competitor.

The detection trigger nobody shows

Twilio tracks every call's lifecycle and posts a status-callback request to a URL you configure. Each callback carries a CallStatus field. The values that matter for a missed call are no-answer, busy, and failed. Per the Twilio call resource docs, those statuses mean the call ended without a live connection.

That's the trigger. You point Twilio's status callback at an n8n Webhook node, and you branch on CallStatus. Most tutorials wire the inbound-SMS webhook (the easy half) and hand-wave the call detection, because it requires configuring the callback on the phone number or the TwiML app, not just in n8n.

Here's the opinionated bit: don't try to detect missed calls by polling Twilio's call logs on a schedule. People reach for a Schedule Trigger that lists recent calls and filters for unanswered ones. It's slower, it double-fires on overlapping runs, and it burns API calls. The status callback is push, not poll. It fires once, the instant the call ends. Use it.

The missed-call text-back pipeline

Webhook (Twilio status callback)
  → Filter: CallStatus in [no-answer, busy, failed]
  → Check: caller not already in an open thread
  → Send SMS text-back (Twilio)
  → Wait for reply (inbound SMS webhook)
  → OpenAI: triage reply intent
  → Route: hot → Slack/rep, else → log

Two webhooks, one for the call status and one for the inbound reply, joined by state in a sheet. The first fires the text. The second catches the answer.

1. Catch the missed call

Configure the status callback on your Twilio number to POST to an n8n Webhook node. In n8n, a filter immediately drops anything that isn't no-answer, busy, or failed. Completed calls and ringing events flow in too; you only act on the misses.

// Filter node condition
const s = items[0].json.CallStatus;
return ['no-answer', 'busy', 'failed'].includes(s);

2. Suppress duplicates

Before texting, check a Google Sheet for an open thread with that number. If the caller already got a text-back in the last hour, skip. Without this guard, a flaky line that drops twice sends two texts, and the caller reads that as a bot. Store the from number and a timestamp on every send; gate the next send on it.

3. Send the text-back instantly

The Twilio node sends an SMS from your number to the caller: something human, short, and inviting a reply. "Sorry we missed you, what can we help with?" The whole round trip from missed call to delivered text is usually under five seconds, because the status callback is push-based.

4. Triage the reply with AI

The caller's reply comes in on a second Webhook (Twilio's inbound-SMS callback). An OpenAI node classifies intent: new lead, existing customer, wrong number, spam. Force structured JSON and parse it with a Code node. Skip the parse and the next node reads text where it expects a field, then the routing breaks silently.

5. Route and follow up

Hot leads ping a rep's phone or a Slack channel with the number and the message. Everything else logs to the sheet. If no reply lands within an hour, a Schedule-driven check can fire a single follow-up text. One. Not a drip; this is a missed call, not a campaign.

Implementation patterns

Pattern 1: status-callback trigger. Branch on CallStatus from the call's status webhook. This is the detection step the paid tools charge for.

Webhook(status) → Filter(CallStatus in no-answer/busy/failed) → act

Pattern 2: the duplicate guard. Check open-thread state before sending, write it after. Stops double-texts on flaky lines.

Read sheet(from) → IF no open thread → send + write timestamp

Pattern 3: reply triage. Inbound-SMS webhook into a structured OpenAI classification, then route hot leads to a human. The Review Response Engine uses the same classify-then-route core if you want the AI half pre-built.

n8n nodes you'll use most

Getting started

1. Buy or use a Twilio number and note your account SID and auth token.
2. Add an n8n Webhook node and configure it as the number's status callback URL.
3. Filter incoming callbacks to no-answer, busy, and failed.
4. Add the duplicate-suppression check against a Google Sheet keyed on the caller number.
5. Wire the Twilio SMS send with a short, human text-back.
6. Add a second Webhook for inbound replies, then an OpenAI triage node with a parse step.
7. Route hot replies to Slack and log everything; test by calling your own number and not answering.

A missed-call text-back is the fastest lead-capture automation you can run, but it's one channel. For the form-and-CRM side of capture, see getting web leads into your CRM with n8n, and for the broader case there's lead generation automation in n8n. Nail the status-callback trigger and the rest is plumbing you already know.