Build the future of communications.
Start building for free

Is Twilio an ATDS


This is a question I hear regularly from Twilio customers interested in using Twilio’s Programmable SMS API.

For the uninitiated, “ATDS” stands for “Automatic Telephone Dialing System.”  ATDS’s are also sometimes colloquially referred to as “auto-dialers” or “robo-dialers.”  And, in the United States, whether or not your messaging program is subject to the restrictions (and severe monetary penalties) of the Telephone Consumer Protection Act (aka the “TCPA”) depends, in part, on whether or not you use an ATDS to send text messages to end users.  For purposes of the TCPA, ATDS is defined in the law and in the Federal Communications Commission’s rules.

It is probably not an overstatement to say that, for US attorneys, the number one legal concern when reviewing a text messaging program is ensuring it does not run afoul of the TCPA.  With penalties up to $1500 per text message, and the possibility of sending thousands, if not millions, of text messages in a single messaging campaign, the stakes are high for ensuring that a messaging campaign is TCPA-compliant.

As a starting point, to clear the air, remember that just because someone uses an ATDS to send text messages does not mean that the text messages violate the TCPA.  Rather, it just means that there are additional restrictions and compliance requirements when sending those messages.  If you come to the determination that you initiate messaging campaigns using an ATDS, you should work closely with your legal counsel to make sure you’re ticking all the right compliance boxes.  (You might want to also check out some of the Twilio Add Ons that can assist you in building your compliance program, like the Mobile Commons Optout Classifier and Payfone TCPA Compliance.)

Back to the question…is Twilio an ATDS?

If you’ve ever asked someone at Twilio this question, you will hear back a variation of the following- “we cannot provide legal advice but instead recommend that you work with your legal counsel to make that determination.”  Anybody hoping that you’ll get a different answer from this post, sorry to disappoint.  This is still our position. Let’s be frank, it is a loaded legal question asking whether or not something is an ATDS, and it is not our place to give you legal advice. You’ve got your own legal counsel for that.

That said, let me provide you with some information about how Twilio’s Programmable SMS API works.  This information may be helpful to you and your legal counsel in making the determination for yourself.

Let’s take a step back

Twilio’s Programmable SMS is not a complete solution. Rather, it is more like building blocks or components.  Asking whether Twilio an ATDS is kind of like asking if an engine and four tires is a car.  Which leads to my flip answer when asked if Twilio is an ATDS – “I don’t know… what are you planning to build with it?”

My flip answer is not very helpful, but it highlights the difficulty in simply addressing the question of whether or not Twilio is an ATDS.  It’s a bit like comparing apples and oranges.

Twilio, standing alone, doesn’t do anything.  All the fancy cool stuff you want to do to control your communications program, you do that on your side with your software application.  We just take care of the connection between your fancy cool software application and the somewhat arcane world of the telecommunications networks. It is your fancy cool software application that sends instructions to Twilio via Twilio’s Programmable SMS API for Twilio to transmit your communications.

So, let’s address some common questions (and potential misconceptions) about how Programmable SMS works.

Can Twilio send text messages en masse?

In the case of an outbound text message transmitted using Twilio’s Programmable SMS product, the instruction your software application sends to Twilio must include a valid phone number to send the message to, a valid Twilio phone number from which to send the message, and the message body.  Each and every text message requires a separate instruction to Twilio.  The important thing to note here is that you cannot simply feed an instruction to our Programmable SMS API to “transmit this message to this bunch of numbers,” push a button, and have Twilio just transmit a bunch of text messages for you.  If you want to send the same SMS message from your Twilio number to 10 separate recipients, then you must code your software application to initiate 10 separate instructions to Twilio.  Each of those 10 separate instructions your application initiates will be the same except for switching out recipient telephone number.  The same concept applies if you want to send 1 million text messages.

So, yes, if your software application initiates 1 million separate instructions to Twilio to transmit 1 million text messages, we can handle it (with some queuing and rate limiting limitations, of course).  But, it is not like you can load up a database of 1 million telephone numbers into Twilio’s Programmable SMS product, tell us to transmit them each a text message saying “1 day only BOGO sale” and have those messages sent.  That’s just not how Programmable SMS works.

Now, that said, we have an entirely different product called Notify, which is designed to help developers orchestrate notifications to their intended recipients across different communications channels (‘cause let’s be honest, not everyone wants to get a text message – some of us prefer Facebook Messenger or a push notification.)   Unlike Programmable SMS, this product does allow developers to store the contact information for their intended recipients and send communications, including via SMS (but also, potentially, push notifications or messaging apps), using a single instruction.   But that is for a different day.


Can Twilio randomly or sequentially generate numbers for its customers to send text messages to?

Nope.  Can’t do that.  Just not how Twilio’s Programmable SMS works.   As noted above, each and every text message you instruct Twilio’s Programmable SMS to transmit requires a separate instruction from your software application which includes the Twilio number from which the call should originate, the body of the message, and the telephone number to which you want that text message sent.  That recipient number is something that comes from you – not something Twilio can generate for you.  (For the record, Notify can’t do this either – you are in charge of the contact info for your recipients).

Notably, nothing in the instruction from your application to Twilio will indicate to Twilio how you got that recipient number.  It could be that your application pulls that recipient number from a website form where the recipient entered his or her number.  It could be that a developer is writing and then initiating individual instructions in code to Twilio one at a time.  It could be that your application is pulling these phone numbers from a database of your end users who all opted in to receive text messages from you.  Or, it could even be that your application is randomly or sequentially generating numbers, then you initiate each instruction for Twilio to transmit each call.  The point is that, at a technical level, Twilio is agnostic to how you design your application and determine the telephone number to which you are initiating a text message.  Twilio transmits your text messages based on the instructions you initiate.  (Of course, Twilio is not agnostic on a non-technical level in that you should be sure you’re in compliance with all applicable laws in how you use Twilio.)

Can I store lists of numbers with Twilio and dial (or message) them from Twilio?  

Nope.  Can’t do that with Twilio’s Programmable SMS either.  In case you skipped ahead and missed what I wrote in response to the question “Can Twilio send text messages en masse?”,  Twilio’s Programmable SMS does not have the capability of storing numbers for you to be dialed.

After you have initiated a text message to be transmitted by Twilio, Twilio will keep a historical record of the messages transmitted, including to which numbers you instructed Twilio’s Programmable SMS to transmit those text messages.  (Basically, it’s a lot like the records of calls you made that you get on your phone bill each month.)  You can use this information for things like reconciling your bills or analyzing your messaging campaign.  But, you cannot instruct Twilio to just transmit another text message to all the numbers you texted before or even a subset of those numbers.  What’s in the past stays in the past.

If you want to keep a database of numbers you want to send text messages to using Twilio’s Programmable SMS, then you should build that into your application.  (Or, you could consider using Notify instead.)

What about Messaging Copilot? Doesn’t that use logic to select telephone numbers?

Messaging Copilot is a Twilio product that helps companies that use lots of Twilio numbers to run their messaging programs to use smart logic to decide the number to transmit a text message from.  You still have to instruct Twilio on what number you want Twilio to transmit at text message to.

Recall from above, that when using Twilio’s Programmable SMS API, each instruction to to transmit a text message requires you to tell Twilio what Twilio number you want to transmit the message from, the message body, and the number you want Twilio to transmit the message to.  If you have a bunch of different Twilio numbers to choose from when deciding what number the message should come from, you can use Co-Pilot to help you decide so you can optimize things like routing or deliverability.  It is very important to note, though, that Co-Pilot does not have any impact on which numbers Twilio will transmit your messages to. That part is all up to you.

Does Twilio help me determine what to include in the message body?

Most certainly not.  That’s your business, literally.  You know what you want to say to your end users, not us.  At most, we might give you insight into technical limitations like limits on the number of characters you can use, concatenation issues, and the like.  But the substance of your text messages is all you.  Twilio is a platform that can be used to send and receive messages for all sorts of different purposes, but that purpose is up to you.  Our expertise is in running this platform, not in running your messaging program.

Does Twilio decide when messages are sent?

Nope.  That, too, is your business.  As noted above, when using Twilio’s Programmable SMS API, the instruction to Twilio is very simple – recipient number + Twilio origination number +  message body.  Currently, there is no place in there to instruct our Programmable SMS API to transmit a particular message at a particular time.  Instead, as soon as Twilio receives the instruction you initiate, Twilio transmits the message.  The only time that doesn’t happen is when you’re initiating instructions to Twilio faster than the messages can get pushed into the telecommunications network due to rate limitations. In those cases, though, your messages will just queue up like paratroopers jumping out of a plane–as soon as the one before it has pushed into the telecommunications network, the next one will go and so on and so forth until your queue is clear.

Will Twilio write me a software application that uses  Twilio’s platform to send text messages?

Nope. There are lots of really smart software developers out there in this great wide world who you can hire to do that for you if you don’t have someone already in your organization who has those skills.  But, you can’t hire Twilio for that.  That’s just not our jam.  Our developers are focused on making a really awesome platform that other developers can use to integrate communications capabilities into their software applications.  Keeping this thing up and running for you keeps our developers plenty busy.

Does Twilio store the names and/or physical addresses of the recipients of my text messages?

No.  Twilio’s Programmable SMS API has no need for that information.  Our job is to transmit text messages per instructions you initiate from your software application.  To do that, when it comes to your recipients, we only care that you give us a valid telephone number.  The name and/or physical address of your recipients (or that your recipients are even humans) makes no difference to us.


In closing…

Twilio is committed to being transparent with our customers about our products and services.    So… while I did not directly answer the question “Is Twilio an ATDS?”, I hope this provides some helpful insight into how Twilio’s Programmable SMS product works so that you and your legal counsel can come to your own legal conclusion about your use of Twilio’s products.

Sign up and start building
Not ready yet? Talk to an expert.