Receive SMS

    Plivo supports receiving SMS text messages in 19 countries (see complete SMS API coverage). When an SMS is sent to a Plivo phone number, you can receive the text on your server by setting a Message URL in your Plivo app. Plivo will send the message along with other parameters to your Message URL.

    Getting Started

    1. Sign up for a free Plivo trial account.
    2. Check out our server-side SDKs page and install the right helper based on the programming language you want to use.
    3. Buy a Plivo phone number. A phone number is required to receive and reply to SMS text messages. You can buy a Plivo phone number in over 19 countries through the Buy Numbers tab on your Plivo account UI. Check the SMS API coverage page for all the supported countries.
    4. Use a web hosting service to host your web application. There are many inexpensive cloud hosting providers that you can use for just a few dollars a month. Follow the instructions of your hosting provider to host your web application.
      Note: If you are using a Plivo Trial account for this example, you can only send sms to phone numbers that have been verified with Plivo. Phone numbers can be verified at the Sandbox Numbers page.

    Set up a Web Server

    Let’s assume your web server is located at http://example.com. Below is a snippet to set up a route on your webserver. Now when we send an HTTP request to http://example.com/receive_sms this route will be invoked.

    Note: For PHP, the route will be example.com/receive_sms.php.
    1. Copy the relevant code below into a text file and save it. Let’s call it receive_sms.
      Note: Make sure to use the appropriate file extention for your code (e.g., `receive_sms.py` for Python).
    2. Next you will now have to configure this URL in your Plivo application.

    Code

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    
    from flask import Flask, request, make_response, Response
    
    app = Flask(__name__)
    
    
    @app.route('/receive_sms/', methods=['GET', 'POST'])
    def inbound_sms():
        # Sender's phone number
        from_number = request.values.get('From')
        # Receiver's phone number - Plivo number
        to_number = request.values.get('To')
        # The text which was received
        text = request.values.get('Text')
        # Print the message
        print('Message received - From: %s, To: %s, Text: %s' %(from_number, to_number, text))
    
        return 'Message Recevived'
    
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', debug=True)
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    
    require "sinatra"
    
    post "/receive_sms/" do
      # Sender's phone number
      from_number = params[:From]
      # Receiver's phone number - Plivo number
      to_number = params[:To]
      # The text which was received
      text = params[:Text]
      # Print the message
      puts "Message received - From: #{from_number}, To: #{to_number}, Text: #{text}"
    end
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    
    var express = require('express');
    var bodyParser = require('body-parser');
    var app = express();
    
    app.use(bodyParser.urlencoded({
        extended: true
    }));
    app.use(function (req, response, next) {
        response.contentType('application/xml');
        next();
    });
    app.set('port', (process.env.PORT || 5000));
    app.all('/receive_sms/', function (request, response) {
        // Sender's phone number
        var from_number = request.body.From || request.query.From;
        // Receiver's phone number - Plivo number
        var to_number = request.body.To || request.query.To;
        // The text which was received
        var text = request.body.Text || request.query.Text;
        //Print the message
        console.log('Message received - From: ' + from_number + ', To: ' + to_number + ', Text: ' + text);
    });
    app.listen(app.get('port'), function () {
        console.log('Node app is running on port', app.get('port'));
    });
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    <?php
        require 'vendor/autoload.php';
        // Sender's phone numer
        $from_number = $_REQUEST["From"];
        // Receiver's phone number - Plivo number
        $to_number = $_REQUEST["To"];
        // The SMS text message which was received
        $text = $_REQUEST["Text"];
        // Prints the message
        echo("Message received - From $from_number, To: $to_number, Text: $text");
    ?>
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    
    import static spark.Spark.*;
    
    public class ReceiveSms {
        public static void main(String[] args) {
            get("/receive_sms", (request, response) -> {
                // Sender's phone number
                String from_number = request.queryParams("From");
                // Receiver's phone number - Plivo number
                String to_number = request.queryParams("To");
                // The text which was received
                String text = request.queryParams("Text");
    
                // Print the message
                System.out.println(from_number + " " + to_number + " " + text);
    
                return "Message Received";
            });
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    
    package main
    
    import (
    	"net/http"
    
    	"github.com/go-martini/martini"
    )
    
    func main() {
    	m := martini.Classic()
    	m.Get("/receive_sms", func(w http.ResponseWriter, r *http.Request) string {
    		w.Header().Set("Content-Type", "application/xml")
    		fromnumber := r.FormValue("From")
    		tonumber := r.FormValue("To")
    		text := r.FormValue("Text")
    		print("Message Received - ", fromnumber, " ", tonumber, " ", text)
    
    		return "Message Received"
    	})
    	m.Run()
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    
    using Nancy;
    using System;
    using System.Collections.Generic;
    using System.Reflection;
    
    namespace NancyStandalone
    {
      public class FunctionsModule : NancyModule
      {
        public FunctionsModule()
        {
          Post("/receive", parameters =>
          {
              // Sender's phone number
              String from_number = Request.Form["From"];
              // Receiver's phone number
              String to_number = Request.Form["To"];
              // The text which was received
              String text = Request.Form["Text"];
              // Print the message
              Console.WriteLine("Message received - From: {0}, To: {1}, Text: {2}", from_number, to_number, text);
    
              return "Message received";
          };
        }
      }
    }
    

    Create an Application

    1. Create an Application by visiting the Application Page and click on New Application or by using Plivo’s Application API.
    2. Give your application a name. Let’s call it Receive SMS. Enter your server URL (e.g. http://example.com/receive_sms) in the Message URL field and set the method as POST. See our Application API docs to learn how to modify your application through our APIs.
    3. Click on Create Application to save your application.

    Create Application

    Assign a Plivo number to your app

    1. Navigate to the Numbers page and select the phone number you want to use for this app.
    2. Select Receive SMS (name of the app) from the Plivo App dropdown list.
    3. Click on Update Number to save.

    Assign Phone Number to Receive SMS App

    If you don’t have a number, go to the Buy Number page to purchase a Plivo phone number.

    Buy New Number

    Test and validate

    Send an SMS to your Plivo number using a regular mobile phone. Plivo will send a request to your Message URL with the parameters listed in the XML Request - Messages Documentation.