n8n Twilio SMS Automation: Send, Receive, and Reply

A customer calls, the line's busy, the call drops, and that lead is gone to whichever competitor picks up first. n8n Twilio SMS automation catches it: the missed call fires a webhook, n8n texts the caller back within seconds, and the conversation continues over SMS instead of evaporating.

Search this query and you get tutorials that send one outbound text from a spreadsheet and stop. None of them handle the reply. None point a webhook at n8n to receive inbound SMS, branch on what the customer said, or record an opt-out. That's the half that turns a notification script into an actual two-way system, and it's the half this post covers, with the exact Twilio node config.

Sending an SMS is the easy 20%. Receiving and routing the reply is the 80% that makes it useful.

What you can automate with Twilio SMS

The Twilio node (n8n-nodes-base.twilio) sends SMS and WhatsApp messages and can place calls. Paired with a Webhook node for inbound messages, it covers the full conversation:

• Text a missed caller back automatically, within seconds of the dropped call
• Send appointment reminders pulled from a calendar or sheet
• Fire order and shipping updates from a store event
• Receive inbound replies and route them by intent (new lead, question, opt-out)
• Send a one-time code for verification flows
• Blast a paced campaign to a contact list without tripping carrier limits

The first three are outbound-only. The fourth is the one that matters most, because a customer who replies and hears nothing back is worse off than one you never texted.

The Twilio SMS pipeline

OUTBOUND:  Trigger → Build message (Set) → Twilio Send SMS → Log

INBOUND:   Twilio webhook → n8n Webhook node
   → Classify reply (IF / OpenAI)
   → Branch: opt-out | lead | answer
   → Reply via Twilio + log + alert owner

Two flows, one number. The outbound flow texts people. The inbound flow listens. Wiring only the outbound half is the most common mistake, and it's why so many "SMS automations" feel like a dead end to the person on the other side.

1. Authenticate and send

Create a Twilio credential with your Account SID and Auth Token. In the Twilio node, set the operation to Send SMS, fill To, From (your Twilio number), and Message. The message field takes expressions, so personalize it: Hi {{ $json.firstName }}, sorry the call dropped. The node returns the message SID at {{$json.sid}}, which you log so you can trace delivery later.

2. Receive inbound messages

This is the step the ranking tutorials omit entirely. In your Twilio console, set the number's messaging webhook to an n8n Webhook node URL (n8n-nodes-base.webhook). When someone texts your number, Twilio POSTs the payload, and the fields you'll read are {{$json.body}} for the message text and {{$json.from}} for the sender. Now your workflow can actually react.

The Webhook node's default response is fine for SMS, but note the 120-second timeout: if your reply logic calls a slow API, the work should finish well inside that window or move to an async pattern.

3. Classify the reply

What did they say? An IF node (n8n-nodes-base.if v2) handles simple keyword routing. For anything fuzzier than keywords, the @n8n/n8n-nodes-langchain.openAi v2.1 node classifies intent, returning its output at $json.output[0].content[0].text. Parse that with a Code node (n8n-nodes-base.code v2, jsCode) before the next node reads it. The model returns text; the next node expects a clean field. Add the parse step every time.

4. Branch and reply

Route the classified reply. A STOP-type message goes to the opt-out branch. A genuine lead gets a reply plus an owner alert. A question gets an answer or a handoff. Each branch can send its own Twilio SMS back, closing the loop the customer started.

5. Record opt-outs and log everything

Twilio honors STOP, UNSUBSCRIBE, and START at the carrier level automatically, which keeps you compliant by default. But record it anyway: an IF branch that catches STOP writes the number to a suppressed list in Google Sheets so your outbound workflows skip it. Log every inbound and outbound message with its SID for an audit trail. The missed-call text-back deep dive walks through the full two-way version of this.

Implementation patterns

Pattern 1 — Missed-call text-back

Twilio Status Callback webhook (call no-answer/busy)
   → IF (status === "no-answer" OR "busy")
       → Twilio Send SMS ("Sorry the call dropped, how can the team help?")
       → Google Sheets log

The IF gate matters: without it, the workflow texts back even on answered calls, which annoys customers you actually talked to. Check the call status before sending.

Pattern 2 — Two-way reply triage

Twilio inbound webhook
   → OpenAI classify (new lead / customer / spam)
   → Code (parse JSON)
   → Switch:
       lead    → Twilio reply + Telegram alert to owner
       spam    → log + drop
       opt-out → suppress number

This is the pattern that earns the "automation" label. The classification plus the parse step turn a raw inbound text into a routed action. Skipping the parse is the silent failure mode: the workflow runs green but the next node reads an empty field.

Pattern 3 — Paced campaign send

Google Sheets (read recipients)
   → Filter out suppressed numbers
   → SplitInBatches (size 1, wait 1s)
   → Twilio Send SMS
   → Sheets update (status = sent)

A standard US long-code number sends roughly 1 SMS per second. Fire 1,000 at once and Twilio queues them anyway, but you lose visibility and risk carrier filtering. Pace with SplitInBatches, or register a Messaging Service for real throughput.

n8n nodes you'll use most

Getting started

1. Create a Twilio credential in n8n with your Account SID and Auth Token.
2. Buy or assign a Twilio number capable of SMS.
3. Build the outbound Send SMS node and test it against your own phone.
4. Add a Webhook node and point your Twilio number's messaging webhook at its URL.
5. Wire reply classification, with a Code node to parse any AI output.
6. Add the opt-out branch and a suppressed-contacts list.
7. Log every message SID so delivery is traceable.

For a complete two-way system that's already wired, the Missed-Call Text-Back Rescue handles both flows out of the box.

Twilio SMS automation is only worth building if it listens as well as it speaks. Send the text, point the webhook back at n8n, classify the reply, and honor the opt-out. For related flows, the appointment reminder automation covers scheduled outbound texts, and the Telegram alerts workflow shows the owner-notification half on a different channel. When you want the conversation handled end-to-end, the Voicemail-to-CRM Summarizer extends the same caller-capture idea to voicemail.