Forward SMS to Email

This app will allow you to forward SMS text messages (sent to your Plivo number) as emails to your email address. The functionality can be broken down into these steps:

  1. Your friend sends you an SMS to your Plivo Number.
  2. The SMS gets forwarded to your email inbox
    Note: in this example, we are using Gmail as the email provider.

Prerequisites

  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 (optional).
    Note: A phone number is required only for sending SMS to US and Canadian phone numbers. However, country-specific carrier conditions may still apply. You can buy a US or Canadian phone number through the Buy Numbers tab on your Plivo account UI.
  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. Let’s call it, email_sms. Now when we send an HTTP request to http://example.com/email_sms/ this route will be invoked. This route will call the to_email() function, which will send the email.

Note: For PHP, the route will be example.com/email_sms.php.
  1. Copy the relevant code below into a text file and save it. Let’s call it, email_sms.
  2. Insert your email account detials in to user_name and password parameters.
  3. Fill in the following parameters from, to and subject with the sender’s email address, receiver’s email address and the email subject line respectively.
  4. The body of the email is the SMS that was received on your Plivo number.
  5. Next, you will configure this web server URL in your Plivo application.
    Note: Depending on your email provider, you may need to configure your security settings. For example, if you are using Gmail, you may need to turn on access for "less secure apps" in your Google apps settings.

Code

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

import plivo, plivoxml
from flask import Flask, request
import smtplib

app = Flask(__name__)

@app.route("/email_sms/", methods =['GET','POST'])
def receive_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 on your Plivo number
    text = request.values.get('Text')

    # Print the message
    print 'Message received from %s: %s' % (from_number, text)
    # Send the received SMS to your mail account
    return to_email(text, from_number)

def to_email(text, from_number):
    user_name = 'Your email address'
    password = 'Your password'
    from_ = 'From email address'
    to = ['To email address'] # must be a list
    subject = "SMS from %s" % (from_number)
    body = text

    # Prepare actual message
    message = """\From: %s\nTo: %s\nSubject: %s\n\n%s
    """ % (from_, ", ".join(from_), subject, body)
    try:
        server = smtplib.SMTP("smtp.gmail.com", 587)
        server.ehlo()
        server.starttls()
        server.login(user_name, password)
        server.sendmail(from_, to, message)
        server.close()
        print 'successfully sent the email'
    except:
        print "failed to send email"
    return "SMS sent to email"

if __name__ == '__main__':
    app.run(host='0.0.0.0', debug=True)
        

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
28
29
30
31
32
33
34
35
36
37
38
39
40

require 'mail'
require 'sinatra'
require 'plivo'
include Plivo

post '/email_sms/' do
    # The phone number of the person who sent the SMS
    from_number = params[:From]
    # Your Plivo number that will receive the SMS
    to_number = params[:To]
    # The text which was received on your Plivo number
    text = params[:Text]

    # Print the message
    puts "Message received from #{from_number}: #{text}"
    to_email(text, from_number)
end

def to_email(text, from_number)
    options = {
        :address              => "smtp.gmail.com",
        :port                 => 587,
        :user_name            => 'Your email address',
        :password             => 'Your password',
        :authentication       => 'plain',
        :enable_starttls_auto => true
    }

    Mail.defaults do
        delivery_method :smtp, options
    end

    Mail.deliver do
        to 'To email address'
        from 'From email address'
        subject 'SMS from #{from_number}'
        body text
    end
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

var plivo = require('plivo');
var express = require('express');
var nodemailer = require("nodemailer");
var bodyParser = require('body-parser');
var app = express();

app.use(bodyParser.urlencoded({extended: true}));
app.set('port', (process.env.PORT || 5000));
app.all('/email_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 + ': ' + text);

    var smtpTransport = nodemailer.createTransport("SMTP", {
       service: "Gmail",
       auth: {
           user: "Your email address",
           pass: "Your password"
       }
    });

    smtpTransport.sendMail({
        from: "From email address", // sender address
        to: "To email address", // comma separated list of receivers
        subject: "SMS from " + from_number, // Subject line
        text: text // plaintext body
    }, function(error, response){
        if (error) {
            console.log(error);
        } else {
            console.log("Message sent: " + response.message);
        }
    });
});

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
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<?php
    // Pear Mail Library
    require_once "Mail.php";

    // Sender's phone numer
    $from_number = $_REQUEST["From"];
    // Receiver's phone number - Plivo number
    $to_number = $_REQUEST["To"];
    // The text which was received on your Plivo number
    $text = $_REQUEST["Text"];
    // Print the message
    echo("Message received from $from_number: $text");
    to_email($text, $from_number);

    function to_email($text, $from_number){
        $from = 'From email address';
        $to = 'To email address';
        $subject = 'SMS from $from_number';
        $body = $text;
        $headers = array(
            'From' => $from,
            'To' => $to,
            'Subject' => $subject
        );
        $smtp = Mail::factory('smtp', array(
            'host' => 'ssl://smtp.gmail.com',
            'port' => '465',
            'auth' => true,
            'username' => 'Your email address',
            'password' => 'Your password'
        ));
        // Send mail
        $mail = $smtp->send($to, $headers, $body);
        if (PEAR::isError($mail)) {
            echo('<p>' . $mail->getMessage() . '</p>');
        } else {
            echo('<p>Message successfully sent!</p>');
        }
    }
?>
        

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

package com.plivo.test;

import java.io.IOException;
import java.util.Properties;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import com.plivo.helper.exception.PlivoException;
import com.plivo.helper.xml.elements.PlivoResponse;

public class smsToEmail extends HttpServlet{
    private static final long serialVersionUID = 1L;
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        String from_number = req.getParameter("From"); // Sender's phone number
        String to_number = req.getParameter("To"); // Receiver's phone number - Plivo number
        String text = req.getParameter("Text"); // The text which was received on your Plivo number

        // Print the message
        System.out.println("Message received from: " + from_number + ": " + text);

        try {
          String result = smsToEmail.sendEmail(text, from_number);
          resp.getWriter().print(result);
        } catch (Exception ex) {
          ex.printStackTrace();
          resp.getWriter().print("Error");
        }
    }

    public static String sendEmail(String text, String from_number){]
        // Recipient's email ID
        String to = "To email address";
        // Sender's email ID
        String from = "From email address";
        final String username = "Your email address";
        final String password = "Your password";
        String host = "smtp.gmail.com";

        Properties props = new Properties();
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.smtp.host", host);
        props.put("mail.smtp.port", "587");

        // Get the Session object
        Session session = Session.getInstance(props,
        new javax.mail.Authenticator() {
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(username, password);
           }
        });

        try {
            // Create a default MimeMessage object.
            Message message = new MimeMessage(session);
            // Set From: header field of the header.
            message.setFrom(new InternetAddress(from));
            // Set To: header field of the header.
            message.setRecipients(Message.RecipientType.TO,InternetAddress.parse(to));
            // Set Subject: header field
            message.setSubject("SMS from " + from_number);
            // Set the actual message
            message.setText(text);
            // Send message
            Transport.send(message);

            System.out.println("Sent message successfully!");
            return "Sent message successfully!";
        } catch (MessagingException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws Exception {
        String port = System.getenv("PORT");
        if (port==null) port ="8080";
        Server server = new Server(Integer.valueOf(port));
        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/");
        server.setHandler(context);
        context.addServlet(new ServletHolder(new smsToEmail()),"/email_sms/");
        server.start();
        server.join();
    }
}
        

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Net;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using Nancy;
using RestSharp;
using Plivo.API;
using System.Net.Mail;

namespace Send_Email
{
    public class Program : NancyModule
    {
        public Program()
        {
            Post["/email_sms/"] = x =>
            {
                String from_number = Request.Form["From"]; // Sender's phone number
                String to_number = Request.Form["To"]; // Receiver's phone number - Plivo number
                String text = Request.Form["Text"]; // The text which was received on your Plivo number

                // Print the message
                Console.WriteLine("Message received from {0}: {1}", from_number, text);

                // Call the SendEmail function
                string result = SendEmail(text, from_number);
                return result;
            };
        }

        // Send Email function
        protected string SendEmail(string text, string from_number)
        {
            string result = "Message Sent Successfully!!";
            string user_name = "Your email address";// Sender’s email ID
            const string password = "Your password"; //  password here…
            string subject = "SMS from {0}", from_number; // Subject of the mail
            string to = "To email address";
            string body = text; // Body of the mail which the text that was received
            ServicePointManager.ServerCertificateValidationCallback =
                delegate(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
            {  return true; };

            try {
                // Initialize the smtp client
                SmtpClient smtp = new SmtpClient
                {
                    Host = "smtp.gmail.com", // smtp server address here…
                    Port = 587,
                    EnableSsl = true,
                    DeliveryMethod = SmtpDeliveryMethod.Network,
                    Credentials = new System.Net.NetworkCredential(user_name, password),
                    Timeout = 30000,
                };

               MailMessage message = new MailMessage(user_name, to, subject, body);
               // Send the mail
               smtp.Send(message);
            } catch (Exception ex) {
               result = "Error sending email!!!";
            }
            return result;
        }
    }
}

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 'Email SMS'. Enter your server URL (e.g. http://example.com/email_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' to save your application.

Plivo Create Application Email SMS

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 'Email SMS' (name of the app) from the Plivo App dropdown list.
  3. Click on 'Update' to save.

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

SMS Phone Number Search

Test it out

Send an SMS to your Plivo number using a regular mobile phone. Plivo will request the your Message URL which will forward the sms to your gmail account.

  1. Send a Single SMS
  2. Send a Long SMS
  3. Send Multiple (Bulk) SMS
  4. Send an SMS with Alphanumeric Sender ID
  5. Receive an SMS
  6. Reply to an Incoming SMS
  7. Forward an Incoming SMS
  8. Get Details of all Messages
  9. Get Details of a Single Message
  10. Handling SMS Delivery Reports
  11. Forward SMS to Email