Menu

Rate this page:

Thanks for rating this page!

We are always striving to improve our documentation quality, and your feedback is valuable to us. How could this documentation serve you better?

Send SMS and MMS Messages in Ruby

In this guide, we'll show you how to use Programmable SMS to send SMS and MMS messages in your Ruby web application.

While you can send text-only SMS messages almost anywhere on the planet, sending media is currently only available in the US and Canada. Learn more in this support article.

The code snippets in this guide are written using the Ruby language version 2.0.0 or higher, and make use of the Twilio Ruby SDK. Let's get started!

Sign up for (or log in to) your Twilio account

If you have a Twilio account and Twilio phone number with SMS capabilities, you’re all set! Feel free to jump straight to the code.

Before you can receive phone calls and send messages, you’ll need to sign up for a Twilio account and purchase a Twilio phone number.

If you’re brand new to Twilio, you can sign up for a free trial account to get started. Once you've signed up, head over to your Console and grab your Account SID and your Auth Token. You will need those values for the code samples below.

Get a phone number with SMS (and MMS) capabilities

Sending messages requires a Twilio phone number with SMS capabilities. If you don’t currently own a Twilio phone number with SMS capabilities, you’ll need to buy one. After navigating to the Buy a Number page, check the 'SMS' box and click 'Search':

Buy a SMS-Capable Twilio Phone Number

If you live in the US or Canada and also wish to send MMS messages, you can select the 'MMS' box. When viewing the search results, you can see the capability icons in the list of available numbers:

Buy an SMS and MMS enabled phone number

Find a number you like and click "Buy" to add it to your account.

If you’re using a trial account, you will need to verify your personal phone number via the console so that you can test sending SMSes to yourself.

Learn more about how to work with your free trial account.

Now that you have a Twilio phone number you can start sending messages to mobile devices.

Send an SMS message in Ruby via the REST API

To send an outgoing SMS message from your Twilio account, you’ll need to make an HTTP POST to Twilio's Message resource.

Twilio's Ruby library helps you to create a new instance of the Message resource, specifying the To, From, and Body parameters of your message.

If you don’t already have the Ruby helper library installed you can install it from RubyGems:

gem install twilio-ruby

You can also manually install the library. Instructions are here.

Now, create a file named send_sms.rb and include the following code:

Loading Code Sample...
      
      
      
      

      Replace the placeholder values for account_sid and auth_token with your unique values. You can find these in your Twilio console.

      Please note: it's okay to hardcode your credentials when getting started, but you should use environment variables to keep them secret before deploying to production. Check out how to set environment variables for more information.

      You’ll tell Twilio which phone number to use to send this message by replacing the from number with the Twilio phone number you purchased earlier.

      Next, specify yourself as the message recipient by replacing the to number with your mobile phone number. Both the from and to parameters must use E.164 formatting (+ and a country code, e.g., +16175551212)

      We also include the body parameter, which contains the content of the SMS we’re going to send.

      Once you’ve updated the code sample, you can test it out by running it from the command line:

      ruby send_sms.rb
      

      In just a few moments you should receive an SMS!

      If you’re using a trial account, you'll notice that any messages you send will always begin with “Sent from a Twilio trial account.” Once you upgrade your account, you will no longer see this message. Learn more about sending SMS and MMS messages from a trial account.

      Let’s take a moment to understand what’s going on behind the scenes when you send this request to Twilio.

      Twilio's response

      When Twilio receives your request to send an SMS via the REST API, it will check that you’ve included a valid Twilio phone number in the from field. Twilio will then either queue the SMS or return this HTTP error in its response to your request.

      Outgoing SMS Diagram

      Assuming your request didn't result in any errors, Twilio's HTTP response will include the SID of the new message. This unique identifier will help us reference this message later: in the code above, we printed that SID to the terminal.

      Twilio's JSON response includes a robust amount of data about your message. A sample response might look like this:

      {"sid": "SMxxxxxxxxxxxxxxx", 
       "date_created": "Thu, 09 Aug 2018 17:26:08 +0000", 
       "date_updated": "Thu, 09 Aug 2018 17:26:08 +0000", 
       "date_sent": null, 
       "account_sid": "ACxxxxxxxxxxxxxxxx", 
       "to": "+15558675310",
       "from": "+15017122661",
       "messaging_service_sid": null,
       "body": "This is the ship that made the Kessel Run in fourteen parsecs?", 
       "status": "queued", 
       "num_segments": "1", 
       "num_media": "0",
       "direction": "outbound-api",
       "api_version": "2010-04-01",
       "price": null,
       "price_unit": "USD",
       "error_code": null,
       "error_message": null,
       "uri": "/2010-04-01/Accounts/ACxxxxxxxxx/Messages/SMxxxxxxxxxxxx.json",
       "subresource_uris": {
           "media": null
       }
      }
      

      You can access any of these attributes from your Ruby code, much like we did when we printed the message.sid as a string.

      Try adding a puts statement like puts message.status. Save the file, then run the code with ruby send_sms.rb one more time. You should see the status of your message, "queued", printed to your terminal.

      If you receive an error in response from Twilio or never receive the message, you may want to check out these tips for troubleshooting undelivered messages.

      If you’d like to track the status of your messages in real-time, you’ll need to set up a StatusCallback URL. Learn more in our tutorial on confirming message delivery in Ruby.

      Send a message to multiple recipients

      If you want to send a message to several recipients, you could create an array of recipients and iterate through each phone number in the array:

      numbers_to_message = ['+15558675310', '+14158141829', '+15017122661']
      numbers_to_message.each do |number|
          message = @client.messages.create(
              body: 'Hello from my Twilio number!',
              from: '+15017122661',
              to: number
          )
          puts message.status
      end
      

      This will create a new Message instance for each phone number in the list.

      A note on message rate limiting

      As you send more messages via the API, Twilio will queue them up for delivery at your prescribed rate limit. API requests for messages that exceed the specified rates will be queued and executed as capacity is available.

      If your application tries to enqueue more than 4 hours worth of outbound traffic (e.g., enqueuing more than 14,400 messages to Canada over one long code phone number), the API will start returning 429 errors.

      If you need to enqueue a large volume of messages, you may find that it's helpful to leverage Twilio's Messaging Services. See our guide on how to set up and send messages from a messaging service for more tips.

      Send a message containing media (MMS) in Python

      While you can send text-only SMS messages almost anywhere on the planet, sending media is currently only available in the US and Canada.

      To include media in your Twilio-powered text message, you need to make an addition to the code we wrote above. This time, we need to add the media_url parameter.

      Create a file called send_mms.rb and include the following code:

      Loading Code Sample...
          
          
          
          

          Again, update the from and to parameters to use your Twilio phone number and your mobile phone.

          The new media_url parameter in this code tells Twilio where to go to get the media we want to include. This must be a publicly accessible URL: Twilio will not be able to reach any URLs that are hidden or that require authentication.

          Just as when you send a simple SMS, Twilio will send data about the message in its response to your request. The JSON response will contain the unique SID and URI for your media resource:

          "subresource_uris": {"media": "/2010-04 01/Accounts/ACxxxxxxxx/Messages/SMxxxxxxxxxxxxx/Media.json"}
          

          When the Twilio REST API creates your new Message resource, it will save the image found at the specified media_url as a Media resource. Once created, you can access this resource at any time via the API.

          You can print this value from your Ruby code to see where the image is stored. Add the following line to the end of your send_mms.rb file to see your newly provisioned Media URI:

          puts message.media.instance_variable_get :@uri

          Save the file and run it from the command line:

          ruby send_mms.rb
          

          In just a moment you should receive a text message with an image!

          What's next?

          You've now successfully sent some messages with the Twilio Programmable SMS API and the Ruby helper library.

          Check out these in-depth resources to take your programmatic messaging a step further:

          Agustin Camino Jose Oliveros Jennifer Aprahamian David Prothero Kat King Jarod Reyes

          Need some help?

          We all do sometimes; code is hard. Get help now from our support team, or lean on the wisdom of the crowd browsing the Twilio tag on Stack Overflow.

          Loading Code Sample...