Sending an outbound message using the Plivo SMS platform is easy, but communication should be a two-way street. Customers should be able to text you, and you should acknowledge their messages and address their concerns. To do this, you can build a Go Gin-Gonic application to receive and respond to incoming SMS messages on a Plivo phone number. In this post, we walk you through how to implement this.

Prerequisites

Before you get started, you’ll need:

• A Plivo account — sign up for one for free if you don’t have one already.
• An SMS-enabled Plivo phone number as you want to receive incoming SMS messages. To search for and buy an available number, go to Phone Numbers > Buy Numbers on the Plivo console.
• Golang, Gin-Gonic, and Plivo go packages.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

Create a Gin web application to receive SMS messages

Once you’ve installed Golang, Gin-Gonic, and Plivo go packages, create a simple Gin web application to handle incoming SMS messages on a Plivo number. Use this code:

package main

import (
  "net/http"

  "github.com/gin-gonic/gin"
)

func main() {
  r := gin.Default()
  r.GET("/receive_sms", func(c *gin.Context) {
     fromnumber := c.Query("From")
     tonumber := c.Query("To")
     text := c.Query("Text")
     c.String(http.StatusOK, "Message Received %s %s %s", fromnumber, tonumber, text)
  })
  r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}

Return a Message XML document to reply to incoming messages

To reply to an incoming SMS message, you need to return an XML document from the URL configured as the message_url in the application assigned to the Plivo number. The Go SDK can manage the XML document generation, and you can use the Message XML element to reply to incoming SMS messages. Use this code:

package main

import (
   "github.com/gin-gonic/gin"
   "github.com/plivo/plivo-go/v7/xml"
)

func main() {
   r := gin.Default()
   r.GET("/reply_sms", func(c *gin.Context) {
       c.Header("Content-Type", "application/xml")
       fromnumber := c.Query("From")
       tonumber := c.Query("To")
       response := xml.ResponseElement{
           Contents: []interface{}{
               new(xml.MessageElement).
                   SetDst(tonumber).
                   SetSrc(fromnumber).
                   SetContents("Thanks, we have received your request"),
           },
       }
       c.String(200, response.String())
   })
   r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}

Test the code locally

Save the code in any file — we named the file reply_sms.go. To run the code on the server, go to the folder where the file resides and use the command

$ go run reply_sms.go

You should see your basic server application in action on http://localhost:8080/reply_sms/.

Expose the local server to the internet using ngrok

Once you see the application working locally, the next step is to connect the application to the internet to receive and reply to messages. For that, we recommend using ngrok, which exposes local servers behind NATs and firewalls to the public internet over secure tunnels. Install it and run ngrok on the command line, specifying the port that hosts the application on which you want to receive messages (8080 in this case, as our local Gin web application is running there):

$ ./ngrok http 8080

Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network.

Test the link by opening the ngrok URL(https://6d2adbcd5861.ngrok.io/reply_sms/?From=14156667777&To=14156667778) in a browser to check the XML response from the ngrok URL.

Connect the Gin web application to a Plivo number

The final step is to configure the app as a Plivo messaging application and assign it to a Plivo number on which you want to receive SMS messages.

Go to the Plivo console and navigate to Messaging > Applications > XML, then click on the Add New Application button in the upper right.

Provide a friendly name for the app — we used “App-Incoming-SMS” — and configure the ngrok URL https://6d2adbcd5861.ngrok.io/reply_sms/ as the Message URL. Select the HTTP verb as GET, then click Create Application.

Now go to Phone Numbers > Your Numbers and click on the number to which you want to assign the application. From the Plivo Application drop-down, choose the message application you just created. Finally, click Update Number.

Test the application

Send an SMS to the Plivo number you selected. You should see that the Gin web application automatically sends a reply back to your mobile number.

And that’s how simple it is to receive and respond to incoming SMS messages using Plivo’s Go SDK and a Gin web application.

Haven’t tried Plivo yet? Getting started is easy and only takes five minutes! Sign up today.

Making an outbound phone call using the Plivo Voice platform is easy, but communication should be a two-way street. Customers should be able to call you back, and you should answer the calls and address their concerns. This guide shows you how to receive incoming calls on Plivo numbers and manage the call flow once a call reaches the Plivo voice platform. To see how to do this, we’ll build an ASP.NET MVC application to receive an incoming call and greet the caller with a text-to-speech (TTS) message.

Prerequisites

Before you get started, you’ll need:

• A Plivo account — sign up for one for free if you don’t have one already.
• A voice-enabled Plivo phone number if you want to receive incoming calls. To search for and buy a number, go to Phone Numbers > Buy Numbers on the Plivo console.
• ASP.NET MVC application and Plivo NuGet package.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

Create an ASP.NET MVC application to receive incoming calls and play a TTS message

Once you’ve created the ASP.NET MVC application using this tutorial, you can add the Plivo .NET SDK using the NuGet package manager. Create a Controller, name it ReceiveCalls to handle incoming calls on a Plivo number. To handle an incoming call, you need to return an XML document from the URL configured as the Answer URL in the application assigned to the Plivo number. The .NET SDK can manage the XML document generation, and you can use the Speak XML element to play a text-to-speech message to the caller. Use this code:

using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;

namespace VoiceApps.Controllers
{
    public class ReceiveCallsController : Controller
    {
        // GET: /<controller>/
        public IActionResult Index()
        {
            Plivo.XML.Response resp = new Plivo.XML.Response();
            resp.AddSpeak("Hello, you just received your first call",
                new Dictionary<string, string>() {
                    {
                        "loop",
                        "1"
                    }
                });
            var output = resp.ToString();
            Console.WriteLine(output);
            return this.Content(output, "text/xml");
        }
    }
}

Note: Before starting the app, you have to update Properties/launchSettings.json by setting the applicationUrl as

"applicationUrl": "http://localhost:5000/"

Test the code locally

Save the file and run the application. You should see your basic server application in action on http://localhost:5000/receivecalls/.

Expose the local server to the internet using ngrok

Once you see the application working locally, the next step is to connect the application to the internet to return the XML document to process the incoming call. For that, we recommend using ngrok, which exposes local servers behind NATs and firewalls to the public internet over secure tunnels. Install it and run ngrok on the command line, specifying the port that hosts the application on which you want to handle incoming calls (5000 in this case, as our local ASP.NET MVC application is running there):

$ ./ngrok http 5000

Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network. Test the link by opening the ngrok URL (https://d72221aeec58.ngrok.io/receivecalls/) in a browser. We used HTTPie to check the XML response from the ngrok URL.

Connect the ASP.NET MVC application to a Plivo number

The final step is to configure the application as a Plivo voice application and assign it to a Plivo number on which you want to receive incoming calls.

Go to the Plivo console and navigate to Voice > Applications > XML, then click on the Add New Application button in the upper right.

Provide a friendly name for the application — we used “App-Incoming-call” — and configure the ngrok URL https://d72221aeec58.ngrok.io/receivecalls/ as the Answer URL. Select the HTTP verb as POST, then click Create Application.

Now go to Phone Numbers > Your Numbers and click on the number to which you want to assign the application. From the Plivo Application drop-down, choose the voice application you just created. Finally, click Update Number.

Test the application

Make a phone call to the Plivo number you selected. You should see that the ASP.NET MVC application automatically greets the caller with the text-to-speech message configured in the app.

And that’s how simple it is to receive an incoming call on a Plivo number and handle it using XML documents using Plivo’s .NET SDK and an ASP.NET MVC application. You can implement other use cases on the Plivo Voice platform, such as phone system IVR, call forwarding, and number masking, as your business requires.

Haven’t tried Plivo yet? Getting started is easy and only takes five minutes. Sign up today.

Businesses use call forwarding all the time to route incoming calls to available agents, extensions, or departments that cater to the caller’s needs. Creating a call forwarding app is simple when you use Plivo’s PHP SDK. This guide shows you how to receive incoming calls on Plivo numbers and manage the call flow once a call reaches the Plivo voice platform. To see how to do this, we’ll build a Laravel application to forward the call to a mobile number using the Dial XML element.

Prerequisites

Before you get started, you’ll need:

• A Plivo account — sign up for one for free if you don’t have one already.
• A voice-enabled Plivo phone number if you want to receive incoming calls. To search for and buy an available number, go to Phone Numbers > Buy Numbers on the Plivo console.

• Laravel and Plivo PHP packages.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

Create a Laravel application to forward incoming calls

First, you need to install Laravel if you haven’t installed it already. We suggest using Composer to install it. Add a new Laravel project with boilerplate code with the command composer create-project laravel/laravel forward_calls --prefer-dist. This will create a forward_calls directory with the necessary folders and files for development. Then change to the newly created “forward_calls” project directory and install the Plivo PHP package (composer require plivo/plivo-php).

Once you’ve installed Laravel and the Plivo PHP SDK, run php artisan make:controller ForwardcallController to create a Laravel controller to handle incoming calls on a Plivo number. To handle an incoming call, you need to return an XML document from the URL configured as the answer URL in the application assigned to the Plivo number. The PHP SDK can manage the XML document generation, and you can use the Dial XML element to forward the call to a mobile number. Use this code:

<?php

namespace App\Http\Controllers;
require '../../vendor/autoload.php';
use Plivo\RestClient;
use Plivo\XML\Response;
use Illuminate\Http\Request;

class ForwardcallController extends Controller
{
    // Dial XML to forward the incoming call
    public function forwardCalls()
    {
        $response = new Response();
        $params = array(
            'action' => "https://www.foo.com/dial_status/",
            'method' => "POST",
            'redirect' => "true"
        );
        $dial = $response->addDial($params);
        $number = "14153336666";  // call will be forwarded to this number
        $dial->addNumber($number);
        $xml_response = $response->toXML();
        return response($xml_response, 200)->header('Content-Type', 'application/xml');
    }
}

Now, you need to add a route for the “forwardCalls” function in the ForwardcallController class. Open the routes/web.php file and add this line at the end of the file:

Route::match(['get', 'post'], '/forward_calls'
, 'App\Http\Controllers\ForwardcallController@forwardCalls');

Note: We need to add the route of the app to the “except” array to disable CSRF verification - app/Http/Middleware/VerifyCsrfToken.php`

<?php

namespace App\Http\Middleware;

use Illuminate\Foundation\Http\Middleware\VerifyCsrfToken as Middleware;

class VerifyCsrfToken extends Middleware
{
    /**
     * The URIs that should be excluded from CSRF verification.
     *
     * @var array
     */
    protected $except = [
        '/forward_calls'
    ];
}

Test the code locally

Now the ForwardcallController is ready to handle incoming calls to your Plivo number by forwarding them to a mobile number configured in the Laravel application using Plivo PHP SDK. To run the code on the Laravel server, use the command

$ php artisan serve

You should see your basic server application in action on http://127.0.0.1:8000/forward_calls.

Expose the local server to the internet using ngrok

Once you see the application working locally, the next step is to connect the application to the internet to return the XML document to process the incoming call. For that, we recommend using ngrok, which exposes local servers behind NATs and firewalls to the public internet over secure tunnels. Install it and run ngrok on the command line, specifying the port that hosts the application on which you want to forward incoming calls (8000 in this case, as our local Laravel application is running there):

Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network. Test the link by opening the ngrok URL (https://c872a224048b.ngrok.io/forward_calls/) in a browser or use HTTPie to check the XML response from the ngrok URL.

Connect the Laravel application to a Plivo number

The final step is to configure the application as a Plivo voice application and assign it to a Plivo number on which you want to forward incoming calls.

Go to the Plivo console and navigate to Voice > Applications > XML, then click on the Add New Application button in the upper right.

Provide a friendly name for the application — we used “App-call-forward” — and configured the ngrok URL https://c872a224048b.ngrok.io/forward_calls/ as the Answer URL. Select the HTTP verb as POST, then click Create Application.

Now go to Phone Numbers > Your Numbers and click on the number to which you want to assign the application. From the Plivo Application drop-down, choose the voice application you just created. Finally, click Update Number.

Test the application

Make a phone call to the Plivo number you selected. You should see that the Laravel application automatically forwards the call to the phone number configured in the call forwarding app.

And that’s how simple it is to receive an incoming call on a Plivo number and forward it using XML documents using Plivo’s PHP SDK and a Laravel application. You can implement other use cases on the Plivo Voice platform, such as phone system IVR, receive DTMF/Speech inputs, and number masking, as your business requires.

Haven’t tried Plivo yet? Getting started is easy and only takes five minutes. Sign up today.

Sending an outbound message using the Plivo SMS platform is easy, but communication should be a two-way street. Customers should be able to text you, and you should acknowledge their messages and address their concerns. To do this, you can build an ASP.NET MVC application to receive and respond to incoming SMS messages on a Plivo phone number. In this post, we walk you through how to implement this.

Prerequisites

Before you get started, you’ll need:

• A Plivo account — sign up for one for free if you don’t have one already.
• An SMS-enabled Plivo phone number as you want to receive incoming SMS messages. To search for and buy an available number, go to Phone Numbers > Buy Numbers on the Plivo console.
• ASP.NET MVC application and Plivo NuGet package.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

{{cta-style-1}}

Create an ASP.NET MVC application to receive SMS messages

Once you’ve created the ASP.NET MVC application using this tutorial, you can add the Plivo .NET SDK using the NuGet package manager. Create a Controller, name it ReceiveSMS to handle incoming SMS messages on a Plivo number. Use this code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
using System;
using Microsoft.AspNetCore.Mvc;

namespace ReceiveSms.Controllers
{
    public class ReceiveSMSController : Controller
    {
        [HttpPost]
        public String Index(String From, String To, String Text)
        {
            String Content = "Message received - From:" + From + ", To:" + To + ", Text:" + Text;
            Console.WriteLine(Content);

            return Content;
        }
    }
}

Return a Message XML document to reply to incoming messages

To reply to an incoming SMS message, you need to return an XML document from the URL configured as the message_url in the application assigned to the Plivo number. The .NET SDK can manage the XML document generation, and you can use the Message XML element to reply to incoming SMS messages. Create another controller, name it ReplySMS and use this code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;

namespace ReceiveSms.Controllers
{
    public class ReplySMSController : Controller
    {
		[HttpPost]
		public IActionResult Index(String From, String To)
        {
            Plivo.XML.Response resp = new Plivo.XML.Response();
			resp.AddMessage("Thank you, we have received your request.", new Dictionary<string, string>()
			{
				{"src", To},
				{"dst", From},
			});
			var output = resp.ToString();
			Console.WriteLine(output);
			return this.Content(output, "text/xml");
		}
    }
}

Note: Before starting the app, you have to update Properties/launchSettings.json by setting the applicationUrl as

"applicationUrl": "http://localhost:5000/"

Test the code locally

Save the file and run the application. You should see your basic server application in action on http://localhost:5000/replysms/.

Expose the local server to the internet using ngrok

Once you see the application working locally, the next step is to connect the application to the internet to receive and reply to messages. For that, we recommend using ngrok, which exposes local servers behind NATs and firewalls to the public internet over secure tunnels. Install it and run ngrok on the command line, specifying the port that hosts the application on which you want to receive messages (5000 in this case, as our local ASP.NET MVC application is running there):

Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network.

Test the link by opening the ngrok URL(https://f658c94814ca.ngrok.io/replysms/\?From=14156667777\&To=14156667778) in a browser. We used HTTPie to check the XML response from the ngrok URL.

Connect the Spring Boot application to a Plivo number

The final step is to configure the app as a Plivo messaging application and assign it to a Plivo number on which you want to receive SMS messages.

Go to the Plivo console and navigate to Messaging > Applications > XML, then click on the Add New Application button in the upper right.

Provide a friendly name for the app — we used “App-Incoming-SMS” — and configured the ngrok URL https://f658c94814ca.ngrok.io/replysms/ as the Message URL. Select the HTTP verb as POST, then click Create Application.

Now go to Phone Numbers > Your Numbers and click on the number to which you want to assign the application. From the Plivo Application drop-down, choose the message application you just created. Finally, click Update Number.

Test the application

Send an SMS to the Plivo number you selected. You should see that the ASP.NET MVC application automatically sends a reply back to your mobile number.

And that’s how simple it is to receive and respond to incoming SMS messages using Plivo’s .NET SDK and an ASP.NET MVC application.

Haven’t tried Plivo yet? Getting started is easy and only takes five minutes! Sign up today.

Making an outbound phone call using the Plivo Voice API is easy, but communication should be a two-way street. Customers should be able to call you back, and you should answer the calls and address their concerns. This guide shows you how to receive incoming calls on Plivo numbers and manage the call flow once a call reaches the Plivo voice platform. To see how to do this, we’ll build a Java Spring Boot application to receive an incoming call and greet the caller with a text-to-speech (TTS) message.

Prerequisites

Before you get started, you’ll need:

• A Plivo account — sign up for one for free if you don’t have one already.
• A voice-enabled Plivo phone number if you want to receive incoming calls. To search for and buy a number, go to Phone Numbers > Buy Numbers on the Plivo console.
• Sprint Boot and Plivo Java packages — use the Spring Initializr to create a demo project with boilerplate code.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

{{cta-style-1}}

Create a Spring Boot application to receive incoming calls and play a TTS message

Once you’ve created the Spring Boot application using Spring Initializr, you can add the Plivo Java SDK using Maven or Gradle, or Groovy as per the interface selected. Update the Java application in the created project to handle incoming calls on a Plivo number. To handle an incoming call, you need to return an XML document from the URL configured as the Answer URL in the application assigned to the Plivo number. The Java SDK can manage the XML document generation, and you can use the Speak XML element to play a text-to-speech message to the caller. Use this code:

package com.example.Voice.Demo;

import com.plivo.api.exceptions.PlivoXmlException;
import com.plivo.api.xml.Response;
import com.plivo.api.xml.Speak;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController

public class VoiceDemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(VoiceDemoApplication.class, args);
	}

	@RequestMapping(value = "/receive_call/", produces={"application/xml"},
 method = { RequestMethod.GET, RequestMethod.POST })
	public String ReceiveCall() throws PlivoXmlException {
		Response resp = new Response()
				.children(new Speak
("Hello, you just received your first call"));
		return resp.toXmlString();
	}

}

Test the code locally

Save the file and run the application. You should see your basic server application in action on http://localhost:8080/receive_call/.

Expose the local server to the internet using ngrok

Once you see the application working locally, the next step is to connect the application to the internet to return the XML document to process the incoming call. For that, we recommend using ngrok, which exposes local servers behind NATs and firewalls to the public internet over secure tunnels. Install it and run ngrok on the command line, specifying the port that hosts the application on which you want to handle incoming calls (8080 in this case, as our local Spring boot application is running there):

$ ./ngrok http 8080

Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network.

Test the link by opening the ngrok URL (https://6764a0cb5536.ngrok.io/receive_call/) in a browser. We used HTTPie to check the XML response from the ngrok URL.

Connect the Spring Boot application to a Plivo number

The final step is to configure the application as a Plivo voice application and assign it to a Plivo number on which you want to receive incoming calls.

Go to the Plivo console and navigate to Voice > Applications > XML, then click on the Add New Application button in the upper right.

Provide a friendly name for the application — we used “App-Incoming-call” — and configure the ngrok URL https://b51dbc9d904c.ngrok.io/receive_call/ as the Answer URL. Select the HTTP verb as POST, then click Create Application.

Now go to Phone Numbers > Your Numbers and click on the number to which you want to assign the application. From the Plivo Application drop-down, choose the voice application you just created. Finally, click Update Number.

Test the application

Make a phone call to the Plivo number you selected. You should see that the Spring boot application automatically greets the caller with the text-to-speech message configured in the app.

And that’s how simple it is to receive an incoming call on a Plivo number and handle it using XML documents using Plivo’s Java SDK and a Spring boot application. You can implement other use cases on the Plivo Voice platform, such as phone system IVR, call forwarding, and number masking, as your business requires.

Haven’t tried Plivo yet? Getting started is easy and only takes five minutes. Sign up today.

Sending an outbound message using the Plivo SMS platform is easy, but communication should be a two-way street. Customers should be able to text you, and you should acknowledge their messages and address their concerns. To do this, you can build a Java Spring Boot application to receive and respond to incoming SMS messages on a Plivo phone number. In this post, we walk you through how to implement this.

Prerequisites

Before you get started, you’ll need:

• A Plivo account — sign up for one for free if you don’t have one already.
• An SMS-enabled Plivo phone number as you want to receive incoming SMS messages. To search for and buy an available number, go to Phone Numbers > Buy Numbers on the Plivo console.
• Sprint Boot and Plivo Java packages — use the Spring Initializr to create a demo project with boilerplate code.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

Create a Spring Boot application to receive SMS messages

Once you’ve created the Spring Boot application using Spring Initializr, you can add the Plivo Java SDK using Maven or Gradle, or Groovy as per the interface selected. Update the Java application in the created project to handle incoming SMS messages on a Plivo number. Use this code:

package com.example.SMS.Demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController

public class SmsDemoApplication {

  public static void main(String[] args) {
     SpringApplication.run(SmsDemoApplication.class, args);
  }

  @RequestMapping(value = "/receive_sms/"
, method = { RequestMethod.GET, RequestMethod.POST })
  public String ReceiveSms(@RequestParam("From") String fromNumber
, @RequestParam("To") String toNumber, @RequestParam("Text") String Text) {
     String ReceivedParams = fromNumber + " " + toNumber + " " + Text;
     System.out.println(ReceivedParams);
     return ReceivedParams;
  }
}

Return a Message XML document to reply to incoming messages

To reply to an incoming SMS message, you need to return an XML document from the URL configured as the message_url in the application assigned to the Plivo number. The Java SDK can manage the XML document generation, and you can use the Message XML element to reply to incoming SMS messages. Use this code:

package com.example.SMS.Demo;

import com.plivo.api.exceptions.PlivoXmlException;
import com.plivo.api.xml.Message;
import com.plivo.api.xml.Response;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController

public class SmsDemoApplication {

  public static void main(String[] args) {
     SpringApplication.run(SmsDemoApplication.class, args);
  }

  @RequestMapping(value = "/reply_sms/", produces={"application/xml"
}, method = { RequestMethod.GET, RequestMethod.POST })
public String ReplySms(@RequestParam("From") String fromNumber
, @RequestParam("To") String toNumber, @RequestParam("Text") String Text) 
throws PlivoXmlException {
System.out.println(fromNumber + " " + toNumber + " " + Text);
     Response resp = new Response()
           .children(
                 new Message(
fromNumber,toNumber,"Thank you, we have received your request.")
           );
     return resp.toXmlString();
  }
}

Test the code locally

Save the file and run the application. You should see your basic server application in action on http://localhost:8080/reply_sms/.

Expose the local server to the internet using ngrok

Once you see the application working locally, the next step is to connect the application to the internet to receive and reply to messages. For that, we recommend using ngrok, which exposes local servers behind NATs and firewalls to the public internet over secure tunnels. Install it and run ngrok on the command line, specifying the port that hosts the application on which you want to receive messages (8080 in this case, as our local Spring Boot application is running there):

$ ./ngrok http 8080

Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network.

Test the link by opening the ngrok URL(https://80aefe4087cc.ngrok.io/reply_sms/\?From=14156667777\&To=14156667778\&Text=hi) in a browser. We used HTTPie to check the XML response from the ngrok URL.

Connect the Spring Boot application to a Plivo number

The final step is to configure the app as a Plivo messaging application and assign it to a Plivo number on which you want to receive SMS messages.

Go to the Plivo console and navigate to Messaging > Applications > XML, then click on the Add New Application button in the upper right.

Provide a friendly name for the app — we used “App-Incoming-SMS” — and configure the ngrok URL https://80aefe4087cc.ngrok.io/reply_sms/ as the Message URL. Select the HTTP verb as POST, then click Create Application.

Now go to Phone Numbers > Your Numbers and click on the number to which you want to assign the application. From the Plivo Application drop-down, choose the message application you just created. Finally, click Update Number.

Test the application

Send an SMS to the Plivo number you selected. You should see that the Spring Boot application automatically sends a reply back to your mobile number.

And that’s how simple it is to receive and respond to incoming SMS messages using Plivo’s Java SDK and a Spring Boot application.

Haven’t tried Plivo yet? Getting started is easy and only takes five minutes! Sign up today.

The more your business grows, the harder it is to reach all your customers and prospects. But among the many communications channels available to you, one stands out for immediacy, cost-effectiveness, and ease of use.

Reaching customers and prospects in a growing business

Everyone wants a growing business. Having more customers means more revenue and a great chance to make the world a better place with your products or services.

But keeping customers active means keeping in touch with them. Sometimes you want to send them notifications of new products or policies. Sometimes you need to send them alerts about essential services or time-critical events. And sometimes you just want to offer them new information.

The problem is staying in touch cost-effectively at scale. Businesses have multiple options, including:

• SMS
• Voice
• Email
• Postal mail
• Social media
• Advertising
• Word of mouth

They all have pros and cons when it comes to cost, immediacy, and reach. Email, for example, has low cost but only moderate immediacy. Word of mouth has no cost at all but very limited reach. The best combination of low cost, high immediacy, and almost universal reach is SMS, a.k.a. text messaging. It offers global reach and immediate delivery at a low unit cost per message.

SMS can reach just about everyone. According to Pew Research, 96% of Americans owned a cell phone in 2019, and the most commonly used application for mobile phones is text messaging. That means your customers and potential customers already have what they need to get your messages.

A majority of people say text messaging is their preferred communication method, and according to a widely cited figure, SMS open rates run around 98%. That’s better than any other marketing channel.

SMS has higher deliverability than other electronic channels. Many people decline to answer phone calls from numbers they’re not familiar with, and spam filters often catch bulk email messages before they reach recipients’ inboxes.

Bottom line: SMS has the best reach and the lowest costs for sending bulk messages.

We’ve written a white paper on how to optimize your SMS communications. You should download it and read our advice on topics such as when to use long code phone numbers, toll-free numbers, and short codes; how to take advantage of sender IDs for international calls; and how to avoid having carriers tag your messages as spam.

Making an outbound phone call using the Plivo Voice platform is easy, but communication should be a two-way street. Customers should be able to call you back, and you should answer the calls and address their concerns. This guide shows you how to receive incoming calls on Plivo numbers and manage the call flow once a call reaches the Plivo voice platform. To see how to do this, we’ll build an Express.js application to receive an incoming call and greet the caller with a text-to-speech (TTS) message.

Prerequisites

Before you get started, you’ll need:

• A Plivo account — sign up for one for free if you don’t have one already.
• A voice-enabled Plivo phone number if you want to receive incoming calls. To search for and buy a number, go to Phone Numbers > Buy Numbers on the Plivo console.
• Express.js and Plivo npm packages — run npm i -S plivo express body-parser to install them.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

{{cta-style-1}}

Create an Express application to receive incoming calls and play a TTS message

Once you’ve installed Express and the Plivo Node.js SDK, create a simple Express application to handle incoming calls on a Plivo number. To handle an incoming call, you need to return an XML document from the URL configured as the Answer URL in the application assigned to the Plivo number. The Node.js SDK can manage the XML document generation, and you can use the Speak XML element to play a text-to-speech message to the caller. Use this code:

var express = require('express')
var app = express()

app.post('/receive_call/', function(req, res) {
    var plivo = require('plivo');
    var response = plivo.Response();
    var speak_body = "Hello, you just received your first call";
    response.addSpeak(speak_body);
    res.send(response.toXML());
})

app.set('port', (process.env.PORT || 5000));
app.listen(app.get('port'), function() {
    console.log('Node app is running on port', app.get('port'));
});

Test the code locally

Save the code in any file — we named the file receive_call.js. To run the code on the server, go to the folder where the file resides and use the command

$ node receive_call.js

You should see your basic server application in action on http://localhost:5000/receive_call/.

Expose the local server to the internet using ngrok

Once you see the application working locally, the next step is to connect the application to the internet to return the XML document to process the incoming call. For that, we recommend using ngrok, which exposes local servers behind NATs and firewalls to the public internet over secure tunnels. Install it and run ngrok on the command line, specifying the port that hosts the application on which you want to handle incoming calls (5000 in this case, as our local Express application is running there):

$ ./ngrok http 5000

Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network.

Test the link by opening the ngrok URL (https://b51dbc9d904c.ngrok.io/receive_call/) in a browser. We used HTTPie to check the XML response from the ngrok URL.

Connect the Express application to a Plivo number

The final step is to configure the application as a Plivo voice application and assign it to a Plivo number on which you want to receive incoming calls.

Go to the Plivo console and navigate to Voice > Applications > XML, then click on the Add New Application button in the upper right.

Provide a friendly name for the application — we used “App-Incoming-call” — and configure the ngrok URL https://b51dbc9d904c.ngrok.io/receive_call/ as the Answer URL. Select the HTTP verb as POST, then click Create Application.

Now go to Phone Numbers > Your Numbers and click on the number to which you want to assign the application. From the Plivo Application drop-down, choose the voice application you just created. Finally, click Update Number.

Test the application

Make a phone call to the Plivo number you selected. You should see that the Expressjs application automatically greets the caller with the text-to-speech message configured in the app.

And that’s how simple it is to receive an incoming call on a Plivo number and handle it using XML documents using Plivo’s Node.js SDK and an Express application. You can implement other use cases on the Plivo Voice platform, such as phone system IVR, call forwarding, and number masking, as your business requires.

Haven’t tried Plivo yet? Getting started is easy and only takes five minutes. Sign up today.

Sending an outbound message using the Plivo SMS platform is easy, but communication should be a two-way street. Customers should be able to text you, and you should acknowledge their messages and address their concerns. To do this, you can build an Express application to receive and respond to incoming SMS messages on a Plivo phone number. In this post, we walk you through how to implement this.

Prerequisites

Before you get started, you’ll need:

• A Plivo account — sign up for one for free if you don’t have one already.
• An SMS-enabled Plivo phone number as you want to receive incoming SMS messages. To search for and buy an available number, go to Phone Numbers > Buy Numbers on the Plivo console.
• Express and Plivo npm packages — run npm i -S plivo express body-parser to install them.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

Create an Express application to receive SMS messages

Once you’ve installed Express and the Plivo Node.js SDK, create a simple Express application to handle incoming SMS messages on a Plivo number. Use this code:

const express = require('express');
    const bodyParser = require('body-parser');
    const 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 || 3000));
    app.all('/receive_sms/', function (request, response) {
        let from_number = request.body.From || request.query.From;
        let to_number = request.body.To || request.query.To;
        let text = request.body.Text || request.query.Text;
        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'));
    });
    

Return a Message XML document to reply to incoming messages

To reply to an incoming SMS message, you need to return an XML document from the URL configured as the message_url in the application assigned to the Plivo number. The Node.js SDK can manage the XML document generation, and you can use the Message XML element to reply to incoming SMS messages. Use this code:

const plivo = require('plivo');
const express = require('express');
const bodyParser = require('body-parser');
const 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 || 3000));
app.all('/reply_sms/', function(request, response) {
    let from_number = request.body.From || request.query.From;
    let to_number = request.body.To || request.query.To;
    let text = request.body.Text || request.query.Text;
    console.log('Message received - From: ' + from_number + ', To: ' + to_number + ', Text: ' + text);

    //send the details to generate an XML
    let r = plivo.Response();
    let params = {
        'src': to_number,
        'dst': from_number,
    };
    let message_body = "Thank you, we received your request.";
    r.addMessage(message_body, params);
    console.log(r.toXML());
    response.end(r.toXML());
});
app.listen(app.get('port'), function() {
    console.log('Node app is running on port', app.get('port'));
});

Test the code locally

Save the code in any file — we named the file reply_sms.js. To run the code on the server, go to the folder where the file resides and use the command

$ node reply_sms.js

You should see your basic server application in action on http://localhost:5000/reply_sms/.

Expose the local server to the internet using ngrok

Once you see the application working locally, the next step is to connect the application to the internet to receive and reply to messages. For that, we recommend using ngrok, which exposes local servers behind NATs and firewalls to the public internet over secure tunnels. Install it and run ngrok on the command line, specifying the port that hosts the application on which you want to receive messages (5000 in this case, as our local Expressjs application is running there):

Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network.

Test the link by opening the ngrok URL (https://31123bc8f94e.ngrok.io/reply_sms/?From=14156667777&To=14156667778) in a browser. We used HTTPie to check the XML response from the ngrok URL.

Connect the Express application to a Plivo number

The final step is to configure the app as a Plivo messaging application and assign it to a Plivo number on which you want to receive SMS messages.

Go to the Plivo console and navigate to Messaging > Applications > XML, then click on the Add New Application button in the upper right.

Provide a friendly name for the app — we used “App-Incoming-SMS” — and configure the ngrok URL https://31123bc8f94e.ngrok.io/reply_sms/ as the Message URL. Select the HTTP verb as POST, then click Create Application.

Now go to Phone Numbers > Your Numbers and click on the number to which you want to assign the application. From the Plivo Application drop-down, choose the message application you just created. Finally, click Update Number.

Test the application

Send an SMS to the Plivo number you selected. You should see that the Express application automatically sends a reply back to your mobile number.

And that’s how simple it is to receive and respond to incoming SMS messages using Plivo’s Node.js SDK and an Express application.

Haven’t tried Plivo yet? Getting started is easy and only takes five minutes! Sign up today.