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.

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 a Laravel 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.
• Laravel and Plivo PHP packages.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

{{cta-style-1}}

Create a Laravel application to receive incoming calls and play a TTS message

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 receive_calls --prefer-dist. This will create a receive_calls directory with the necessary folders and files for development. Then change to the newly created “receive_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 ReceivecallController 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 Speak XML element to play a text-to-speech message to the caller. Use this code:

<?php

namespace App\Http\Controllers;

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

class ReceivecallController extends Controller
{
   // Speak XML to handle your first incoming call
   public function receiveCalls()
   {
       $response = new Response();
       $speak_body = "Hello, you just received your first call";
       $response->addSpeak($speak_body);
       Header('Content-type: text/xml');
       echo $response->toXML();
   }
}

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

Route::match(['get', 'post'], '/receive_calls',
 'App\Http\Controllers\ReceivecallController@receiveCalls');

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 = [
       '/receive_calls'
   ];
}

Test the code locally

Now the ReceivecallController is ready to handle incoming calls to your Plivo number using Laravel and 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/receive_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 receive calls (8000 in this case, as our local Laravel application is running there):

$ ./ngrok http 8000

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://6e4d127bf930.ngrok.io/receive_calls) in a browser. We used 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 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://6e4d127bf930.ngrok.io/receive_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 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 PHP SDK and a Laravel 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.

If you read our blog post from a couple of months ago, you’re already familiar with STIR/SHAKEN — Secure Telephone Identity Revisited (STIR) and Signature-based Handling of Asserted Information Using toKENs (SHAKEN). They’re technical frameworks that fight call spoofing by authenticating the calling number.

The US Federal Communications Commission (FCC) has directed carriers to implement STIR/SHAKEN by June 30, 2021. Plivo will be ready; we’re already running a successful pilot program.

When we roll out STIR/SHAKEN support for inbound calls, we’ll validate attestation of calls to Plivo DIDs and toll-free numbers in the US, irrespective of whether they’re used for Voice or Zentrunk. For calls through the Voice API, we’ll pass the STIR/SHAKEN verification level as part of webhook requests to various URLs — answer_url, fallback_url, hangup_url, etc. For both Voice and Zentrunk calls, we’ll also show verification levels on the Plivo console and in Call Detail Reports.

Going in the other direction, we’ll sign all Voice and Zentrunk outbound calls to the US — unless a customer violates the rules:

1. The calls breach the Plivo Fair Usage Policy.
2. The calls are identified as unsolicited robocalls.
3. Plivo gets a traceback request from the Industry Traceback Group about calls made by the customer.
4. The calls have invalid caller IDs — for instance, if they don’t adhere to E.164 format or  have too many digits.

In these scenarios, Plivo may stop signing all calls initiated by the customer. That could lead to lower answer rates, because calls won’t be marked as Verified. Worst case, they could be marked as spam by receiving networks.

Verification levels for outbound calls

In the STIR/SHAKEN framework, a secure telephony identity (STI) governance authority issues digital certificates. STIR/SHAKEN provides three attestation levels that can be assigned by an STI authentication service, which represent how confident a service provider is in that the number’s owner is truly the one placing the call.

Plivo will sign outbound calls as Verified (attestation A) for calls that use a Plivo DID as caller ID. The DID used should be rented by the same Plivo account that originates the outbound calls. All other outbound calls, assuming they are signed at all, are signed Not Verified (attestation B or C).

We strongly encourage customers to use Plivo DIDs as caller ID to improve their STIR/SHAKEN verification levels.

How verification status maps to STIR attestations

For both outbound and inbound Voice API calls, Plivo will display the verification status of a call as a parameter called Stir Verification, which can have one of three values:

• Verified means the call is from a Verified caller who has authorized access to the customer’s caller ID, and hence should be treated with confidence. Verified is equivalent to attestation level A.
• Not Verified means that, for this call, either the caller is not Verified, or it’s uncertain whether they have access to the caller ID used, or both. Not Verified means the call received attestation level B or C.
• Not Applicable means STIR/SHAKEN doesn’t apply to this call, as would be the case if a call is not addressed to a US number or if it’s a cloud call (WebRTC or SIP).

How to access verification status

Voice and Zentrunk customers have several ways to access STIR verification statuses.

Voice API

Plivo Voice customers can access verification values on the Voice > Calls page of the console as part of call logs, as part of CDR exports, and via Voice APIs in several ways:

Webhook Callbacks

We’ve added a new STIRVerification parameter as part of status update JSON code sent to these callback URLs:

• answer_url
• fallback_url
• hangup_url

We’ve also added the parameter as part of call_status_callback_url for multiparty call events:

Voice API Call Object

You can also access STIR verification as part of the response of the Get CDR API call:

Zentrunk

Zentrunk customers will be able to see STIR verification values in the several ways:

Console

On the Zentrunk > Logs page as part of Call Detail Records (CDR).

Custom SIP header

As part of a new SIP header:

P-Asserted-ID Header

Zentrunk customers can also use the SIP verstat parameter as part of the P-Asserted-ID header:

Upcoming attestation refinements

Soon, Plivo will start taking into consideration more factors to determine the attestation level for outbound calls, including (but not limited to):

1. Results of Know Your Customer (KYC) validation, a feature coming to the Plivo console and API in the near future.
2. Customers’ own DIDs sourced from other providers and whitelisted with Plivo. We plan to enable whitelisting through the Plivo console and the API in the near future.
3. The confidence Plivo has in customer traffic patterns not constituting fraudulent and unsolicited robocall traffic.

Looking forward to less spoofing

We believe STIR/SHAKEN will have a big impact in preventing caller ID spoofing and containing unsolicited robocalls, and we’re excited to join the fight. Talk to a Plivo expert for help getting started.