Resources · Make integration

Twilio Make integrationAutomate Twilio with Make.

Twilio sends the message, Make decides when. The Twilio Make integration gives you 26 modules, the bricks you assemble to handle texts, calls and recordings without code. It fits support and ops teams. This page covers linking your account, then your first build.

Try the Twilio integration on MakeSee the 26 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What does the Twilio Make integration actually do?

It means Twilio becomes one of the apps you drive from a scenario, the automation you build in Make by chaining modules on a canvas. You link your Twilio account once, that link is the connection, and every Twilio module reuses it. From there, 26 modules cover messages, calls, recordings, transcriptions, alerts and Studio executions.

Three shapes cover most of what teams build here. The reply that sends itself: Watch Messages picks up an incoming text and Create a Message answers it, with nobody on duty. The log that fills itself: Watch Calls catches each new call, Get a Call adds the detail, and the row lands in your spreadsheet. The archive: Watch Recordings notices a new recording and Download a Recording Media drops the file where your team can find it.

What Make will not do is invent capacity you do not have in Twilio. A free Twilio account only reaches numbers you have verified, which is the first thing to check when a test run looks silent. Availability also depends on the region you pick when you create the connection, so a module that works for one account can be missing for another. And alerts do not stay queryable forever, so Watch Alerts is a habit to set up early rather than a rescue tool.

Twilio also exists in n8n, the other tool this site covers, and neither choice is wrong. The n8n vs Make comparison sets out the criteria, and the Twilio n8n integration page covers the same ground on the n8n side. If the canvas is new to you, Make training is a shorter road than trial and error.

Connect

How do you connect Twilio to Make?

  1. 01

    Copy your SID and auth token

    You need a Twilio account first, created at login.twilio.com/u/signup. Log in there, open the Dashboard, go to the Developer tab, and copy the account SID and auth token from the Account info section.

  2. 02

    Start the connection in Make

    Back in Make, add any Twilio module to a scenario and click Create a connection. Name it in the Connection name field if you like, then pick your area in the Region field.

  3. 03

    Paste the two keys

    Put the account SID in the SID field and the auth token in the Auth Token field, then confirm access if Twilio asks you to. The connection is saved once, and every Twilio module in the scenario picks it up from there.

First scenario

Your first scenario: a text that answers itself

GoalWhen a new message arrives in Twilio, Make reads it and sends a reply with Create a Message.

  1. 01

    Create the scenario

    Open the Scenarios page in Make, create a new scenario, and click the + to add the first module. That first module is the one that decides when everything else runs.

  2. 02

    Add Watch Messages as the trigger

    Search Twilio by name, pick Watch Messages from the list, then click Create a connection to link your account. Fill the fields the module asks for, and Make reads back what your account can see.

  3. 03

    Add Create a Message after it

    Click the + on the right of the trigger, search Twilio again, and choose Create a Message. Take the number and the text from the bundle the trigger produced instead of typing values by hand.

  4. 04

    Test with Run once

    Click Run once to run the scenario a single time, then send yourself a message. Each module shows the bundles it received, which is where you see whether the data travelled as you expected.

  5. 05

    Schedule it and switch it on

    Click the clock on the first module to set the schedule, every 15 minutes by default, then flip the scenario on. From there it runs on its own, and Run once is still there whenever you change something.

Triggers

What starts a Twilio scenario

6 modules start a scenario when something happens in Twilio. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Twilio as soon as it happens.

Twilio1Watch Messages

Watch Messages

Scheduled trigger

In Make“Triggers when a new message is created.”

Watch Messages hands your scenario every message created on your Twilio account, one message per bundle, which is the unit of data that travels from one module to the next. Whatever it brings back becomes material for the modules you put behind it.

How it fires
scheduled, so Make checks Twilio on the scenario's schedule rather than being pushed anything.
When to use it
a shared number where every incoming text has to reach a human, a ticket or a spreadsheet row.
Watch out
anything landing between two checks waits for the next one, so the interval you set is also the delay your customer feels.
Twilio2Watch Calls

Watch Calls

Scheduled trigger

In Make“Triggers when a new call is created.”

Every new call recorded on the account can start a run here. Watch Calls picks up the call as it appears in Twilio and passes it on, so the rest of the scenario works from a real call instead of a manual export.

How it fires
scheduled, Make looks at Twilio at the rhythm you set on the first module.
When to use it
a sales line where nobody wants to retype who called and when.
Watch out
a call that ends just after a check sits until the next one, so treat this as a log filler, not as a live alarm.
Twilio3Watch Recordings

Watch Recordings

Scheduled trigger

In Make“Triggers when a new recording is created.”

A recording appears in Twilio and this trigger puts it at the top of your scenario, ready to be moved, renamed or sent elsewhere. It is the usual pairing with Download a Recording Media, which turns the reference into an actual file.

How it fires
scheduled, Make polls Twilio on the schedule of the scenario, hence the clock badge on the module.
When to use it
a support team that reviews calls and wants each new recording filed outside Twilio without anyone clicking.
Watch out
a recording is a file, and on the Free plan Make handles files up to 5 MB with 512 MB of transfer, worth checking before you plan an archive.
Twilio4Watch Transcriptions

Watch Transcriptions

Scheduled trigger

In Make“Triggers when a new transcription is created.”

Text beats audio when you need to search later. Watch Transcriptions starts the scenario as soon as a new transcription exists in Twilio, so the words of a call can travel to a CRM note, a database row or a review queue.

How it fires
scheduled, Make checks Twilio on the scenario's schedule and brings back what appeared since the previous pass.
When to use it
an ops lead who reads call write-ups rather than listening to them.
Watch out
the trigger only sees transcriptions Twilio has produced, so nothing shows up if the call was never transcribed.
Twilio5Watch Alerts

Watch Alerts

Scheduled trigger

In Make“Triggers when a new alert (notification) is issued.”

Watch Alerts is the trigger for things going wrong. When Twilio issues a new alert, your scenario starts and can push it where your team actually looks: a chat channel, an inbox, a board.

How it fires
scheduled, Make queries Twilio on the scenario's schedule, so alerts arrive in batches rather than one by one.
When to use it
a number carrying order confirmations, where a silent failure costs more than the message itself.
Watch out
Twilio keeps alerts queryable for a limited window only, so an alert nobody collected in time cannot be fetched later.
Twilio6New Message Status Event

New Message Status Event

Instant trigger

In Make“Webhook for status callback field in a create message action. Triggers for outgoing messages.”

This one reports back on what you sent. New Message Status Event is the webhook, the address Twilio calls to reach Make, wired to the status callback field of a create message action. It fires when an outgoing message moves to queued, failed, sent, delivered or undelivered.

How it fires
instant, Twilio calls Make through a webhook as soon as the status changes, with no schedule to wait for.
When to use it
a campaign where the failures need separating from the deliveries before anyone follows up by phone.
Watch out
it covers outgoing messages only, and it assumes the status callback was set on the message you created, so plan it together with Create a Message.
Modules

What Twilio can do inside Make

Twilio gives you 20 modules in 6 groups. For each one: what it does for you, when to reach for it, and what to watch out for.

Messages

6 modules
Twilio1

Create a Message

Action

In Make“Sends a message.”

Create a Message is the module that actually sends the text. You give it the number and the content, Make sends it through your Twilio account, and the rest of the scenario carries on with the result.

When to use it
the confirmation a customer expects two minutes after paying, sent by the scenario instead of by a person.
Watch out
a free Twilio account can only reach numbers you have verified, which is the usual reason a test looks like it did nothing.
Twilio2

List Messages

Search

In Make“Returns a list of messages associated with your account.”

Need the history rather than a single message? List Messages is a search, so it returns zero, one or several messages, each as its own bundle for the modules that follow.

When to use it
a recap of what went out over a period, dropped into a sheet without anyone opening Twilio.
Watch out
every bundle runs the rest of the scenario once, and every module run counts as an operation, the unit Make bills against your plan, so filter before you list.
Twilio3

Get a Message

Action

In Make“Returns details of a message.”

One message, all its details. Get a Message pulls a single record from its reference, which is what you want when an earlier module only gave you an identifier and the scenario needs the rest.

When to use it
right after New Message Status Event, to fetch the full record of the message that just failed.
Twilio4

Delete a Message

Action

In Make“Deletes a message record from your account.”

Delete a Message removes a message record from the account. The scenario keeps running afterwards, the record does not come back.

When to use it
a retention rule that says old texts leave the account once they have been copied to storage you control.
Watch out
nothing in Make undoes this, so put it behind a filter and test the branch with Run once before you switch the scenario on.
Twilio5

List Message Media

Search

In Make“Returns a list of media associated with your message.”

Pictures and files sent with a message live apart from its text. List Message Media searches the media attached to one message and returns them as bundles, so you know what there is before touching any of it.

When to use it
a claims process where the customer sends a photo and the scenario has to know how many arrived.
Watch out
it lists, it does not fetch, so pass the result to Download a Media Resource to get the file itself.
Twilio6

Download a Media Resource

Action

In Make“Downloads a media resource from the message.”

Here the file finally enters the scenario. Download a Media Resource takes the media attached to a message and hands the following modules something they can store, convert or forward.

When to use it
a photo sent by text that has to end up in the customer folder, not in a phone.
Watch out
the Free plan of Make caps files at 5 MB and transfer at 512 MB, so heavy media is a paid plan question.

Calls

4 modules
Twilio7

Create a Call

Action

In Make“Calls a specified phone number and executes specified instructions.”

Create a Call places a call to a number and runs the instructions you give it, so a scenario can reach someone by voice and not only in writing.

When to use it
a delivery slot to confirm with someone who never reads their messages.
Watch out
same rule as for texts on a free Twilio account, the number has to be verified first, and each run of the module costs an operation.
Twilio8

List Calls

Search

In Make“Returns a list of calls associated with your account.”

List Calls goes through the calls on the account and returns them one by one. A search like this can also come back with nothing, a normal result that is worth handling in the scenario.

When to use it
a review of call volume built without an export, straight into the tool your team already reads.
Twilio9

Get a Call

Action

In Make“Returns call resource of an individual call.”

Behind a reference there is a whole call, and Get a Call is what fetches it. It completes Watch Calls and List Calls, which tell you a call exists without telling you everything about it.

When to use it
a CRM record that has to carry the call itself, not just a line saying somebody phoned.
Twilio10

Delete a Call

Action

In Make“Deletes a call record from your account.”

Delete a Call takes a call record out of the account. Like its message twin, it is a one way door: the scenario continues, the record is gone.

When to use it
a cleanup branch that runs once the call has been archived somewhere you control.
Watch out
point this at a test number while you build, because Run once on a real record deletes it for good.

Recordings

2 modules
Twilio11

Download a Recording Media

Action

In Make“Downloads a recording media file.”

Download a Recording Media turns a recording that lives in Twilio into a file inside your scenario, ready for a drive, a bucket or an email.

When to use it
a quality review where the audio has to sit next to the ticket, so nobody hunts for it later.
Watch out
audio gets heavy, and the Free plan of Make stops at 5 MB per file with 512 MB of transfer.
Twilio12

List Recording Transcriptions

Search

In Make“Returns a set of transcriptions available for a recording.”

Ask a recording what text exists for it. List Recording Transcriptions returns the set of transcriptions available for that recording, as separate bundles, or as nothing at all when none were made.

When to use it
after Watch Recordings, to attach the written version to the same ticket as the audio.
Watch out
plural name, plural results, the rest of your scenario runs once per transcription unless you group them first.

Execution

4 modules
Twilio13

Create an Execution

Action

In Make“Creates a new execution.”

Twilio Studio runs flows of its own, and an execution is one run through one of those flows. Create an Execution starts that run from your scenario, so Make hands the conversation over instead of scripting it step by step.

When to use it
a lead that has to enter a scripted call flow the moment a form comes in.
Twilio14

Get an Execution

Action

In Make“Returns details of selected execution.”

Get an Execution returns the details of the execution you select, so the scenario can look at where a Studio run stands before deciding what to do with it.

When to use it
a branch that checks the state of a flow and only writes to your database when it is worth writing.
Twilio15

Update an Execution

Action

In Make“An active Execution can be updated to ended using the REST API. Once ended, subsequent widgets in the Flow are not processed, and any new events that Studio receives for that Execution are rejected.”

An execution that is still active can be moved to ended, and this is the module that does it. Once it has ended, the widgets further down the Studio flow stop being processed and new events for that execution are rejected.

When to use it
a customer who replies by email while a call flow is still running, and the flow should stop talking.
Watch out
ended is a final state for that execution, so branch on Get an Execution first if you are unsure.
Twilio16

Delete an Execution

Action

In Make“Deletes a selected execution.”

Nothing survives this one. Delete an Execution wipes the record of a run, which is not the same thing as ending a run that is still going.

When to use it
housekeeping on test runs that pile up while a flow is being built.
Watch out
there is no recovery step, so keep this module out of any branch that can fire on real traffic.

Other

3 modules
Twilio17

Make an API Call

Action

In Make“Performs an arbitrary authorized API call.”

Some things the Twilio API does are covered by none of the modules above. Make an API Call reaches any authorized endpoint of that API with the same connection, so the scenario can go where the ready made bricks stop.

When to use it
an endpoint listed in the Twilio API documentation that has no module of its own in Make.
Watch out
the request is yours to write, and it is the Twilio API documentation that says what goes in it, not Make.
Twilio18

Make an API Call for Studio

Action

In Make“Performs an arbitrary authorized API call.”

Studio has its own corner of the Twilio API, and this module opens it. Make an API Call for Studio sends an authorized request there with your existing connection, past the point where the four execution modules stop.

When to use it
a flow operation the Execution group does not expose, once you have found the endpoint in the Twilio API documentation.
Twilio19

Make an API Call for Lookup

Action

In Make“Performs an arbitrary authorized API call.”

The Lookup side of the API gets one ready made module in this app, Get Line Type. Make an API Call for Lookup reaches the rest of it, using the same connection and the endpoint you name yourself.

When to use it
a number check that goes further than the line type, with the endpoint taken from the Twilio API documentation.

Other modules

1 module
Twilio20

Get Line Type

Action

In Make“Returns details of selected line type of a phone number.”

Before you spend a message, you can ask what kind of line you are writing to. Get Line Type gives back what Twilio knows about the line behind a number, and the scenario can branch on that answer instead of blasting a whole list.

When to use it
an import of contacts, where texting a number that cannot receive texts is wasted budget.
Watch out
it answers about one number at a time, so a long list means one run per number and the operations add up.
Need help

Need help automating Twilio with Make?

A person reads every message.

FAQ

Questions that come up next

01Is the Twilio Make integration free?
Yes on the Make side, within the limits of the Free plan. Twilio is a standard app, and standard apps are included on every plan, more than 3000 of them. The Free plan gives you 2 active scenarios, a minimum of 15 minutes between two scheduled runs, 5 minutes of execution time, files up to 5 MB and 512 MB of transfer. Paid plans bring the minimum interval down to 1 minute, lift the cap on active scenarios and allow 40 minutes of execution. Usage is counted in credits, one per operation, over the month.
02What do you need to connect Twilio to Make?
A Twilio account and two values taken from it. Create the account at login.twilio.com/u/signup if you do not have one, then open your Twilio Dashboard, go to the Developer tab, and copy the account SID and the auth token from the Account info section. In Make, add any Twilio module to a scenario and click Create a connection. Give the connection a name if that helps you, select your Region, paste the SID and the Auth Token, then confirm access if Twilio asks for it. Every Twilio module in that scenario reuses the same connection.
03Do Twilio triggers fire in real time in Make?
It depends on the trigger. Five of the six are scheduled: Watch Messages, Watch Calls, Watch Recordings, Watch Transcriptions and Watch Alerts. For those, Make checks Twilio on the schedule of the scenario, and the shortest interval is 15 minutes on the Free plan, 1 minute on a paid plan. One trigger is instant, New Message Status Event, which Twilio calls through a webhook as soon as an outgoing message changes status. If you need a reaction with no waiting, build on that one; the scheduled triggers stay fine for logs and archives.
04What if a Twilio module is missing in Make?
Use Make an API Call. It reaches any authorized endpoint of the Twilio API with the connection you already set up, and the app ships two focused variants, Make an API Call for Studio and Make an API Call for Lookup. Endpoint names come from the Twilio API documentation, not from Make. Two limits are worth a look before you blame a module: a free Twilio account only reaches numbers you have verified, and some Twilio functionality depends on the region you selected on the connection.
05Make or n8n for Twilio?
Both tools handle Twilio, so the decision comes down to the team rather than the feature list. In Make, each Twilio brick sits on a canvas and connects to the next one with a click, 26 of them for this app, with the schedule set on the first step of the flow. n8n ships its own Twilio node, and a team that already lives there has no reason to rebuild a scenario that already works. What actually decides it is who picks up this scenario later: a visual flow reads faster for someone who has never opened either tool. The comparison page on this site walks through the rest of the criteria.
Hack'celeration Lab

Get our weekly automation tips.

No spam. Unsubscribe anytime.

Same platform

Other docs you might need on this stack.

Browse all integrations