A virtual assistant can help your business if you have clients who call your phone number. Interactive voice response (IVR) helps you to automate call reception by routing callers to the most appropriate department or the agent most qualified to meet their needs. Among its many advantages, IVR can provide increased operational efficiency, a stronger brand image, and better customer insights.

A voice-controlled virtual assistant is one step ahead of the legacy Touch-Tone/DTMF controlled one because of the flexibility it allows end-users. They can just speak into their phone’s microphone to provide input to control the call.

Building a voice-controlled virtual assistant using Plivo’s automatic speech recognition (ASR) feature in Python using Flask is simple. This guide shows you how to set up a voice-controlled IVR phone tree to a Plivo number and manage the call flow when the call reaches the Plivo voice platform. To see how to do this, we’ll build a Flask application to receive an incoming call and use the GetInput XML element to capture speech input and implement a simple IVR phone system.

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.

• Flask and Plivo Python packages — run pip install plivo flask to install them.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

How it works

Create a Flask application to create a voice-controlled virtual assistant

Once you’ve installed Flask and the Plivo Python SDK, create a simple Flask 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 Python SDK can manage the XML document generation, and you can use the GetInput XML element to capture speech inputs and implement a simple IVR phone system. Use this code:

from flask import Flask, Response, url_for
from plivo import plivoxml

# Welcome message - firstbranch
welcome_message = "Welcome to the demo app, Say Sales to talk to our 
Sales representative. Say Support to talk to our Support representative"

# This is the message that Plivo reads when the caller does nothing at all
noinput_message = "Sorry, I didn't catch that. Please hangup and try again later."

# This is the message that Plivo reads when the caller inputs a wrong digit.
wronginput_message = "Sorry, it's a wrong input."

app = Flask(__name__)

@app.route('/virtual_assistant/', methods = ['GET', 'POST'])
def virtual_assistant():
    element = plivoxml.ResponseElement()
    response = element.add(plivoxml.GetInputElement()
        .set_action(url_for('firstbranch', _external=True))
        .set_method('POST').set_input_type('speech')
        .set_interim_speech_results_callback(url_for('firstbranch', _external=True))
        .set_interim_speech_results_callback_method('POST')
        .set_redirect(True)
        .add_speak(content = welcome_message))
    response.add(plivoxml.SpeakElement(noinput_message))

    return Response(response.to_string(), mimetype = 'text/xml')

@app.route('/virtual_assistant/firstbranch/', methods = ['GET', 'POST'])
def firstbranch():
    response = plivoxml.ResponseElement()
    speech = request.values.get('Speech')
    from_number = request.values.get('From')
    print("Speech input is:"+str(speech))

    if speech == "sales":
        response = plivoxml.ResponseElement()
        response.add(
            plivoxml.DialElement()
            .add(plivoxml.NumberElement('+14156667777')))

    elif speech == "support":
        response = plivoxml.ResponseElement()
        response.add(
            plivoxml.DialElement()
            .add(plivoxml.NumberElement('+14156667778')))
    else:
        response.add_speak(wronginput_message)
    
    return Response(response.to_string(), mimetype = 'text/xml')

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

Test the code locally

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

$ python virtual_assistant.py

You should see your basic server app in action on http://localhost:5000/virtual_assistant/

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 (5000 in this case, as our local Flask 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(http://fd3a77b913ed.ngrok.io/virtual_assistant/) in a browser or HTTPie to check the XML response from the ngrok URL.

Connect the Flask 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 activate the voice-controlled virtual assistant.

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-Virtual-Assistant” — and configure the ngrok URL http://fd3a77b913ed.ngrok.io/virtual_assistant/ 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 VirtualAssistant Flask application automatically routes the call to the Sales and Support departments based on the speech inputs received on the call.

And that’s how simple it is to set up a voice-controlled virtual assistant on a Plivo number and handle it using XML documents using Plivo’s Python SDK and an Flask 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.

Your company has settled on Plivo to handle its voice and messaging communications, and now it’s your job to start integrating Plivo into your company’s applications. Don’t worry — Plivo has an SDK to help you out. Let’s see how to send and receive MMS through Plivo in a Python application.

Install the Plivo Python SDK

We’ll presume you already have Python installed. Installing the Plivo SDK is as simple as running

$ pip install plivo

If you prefer to install from source code, visit our Quickstart Guide for instructions.

Find your Auth ID and Auth Token

You have to have proper credentials before you can use the Plivo API. We provide an Auth ID and Auth Token in the Account section at the top of the overview page of the Plivo console.

Choose a phone number

You need an MMS-enabled Plivo phone number to send MMS to the US and Canada, the two countries where Plivo supports sending MMS. Check the Phone Numbers screen of your Plivo console to see what numbers you have available and which of them support MMS capabilities. You can also buy numbers from this screen.

Send an MMS message

Now you’re ready to start. Create a file called send_mms.py and paste in this code:

from flask import Flask, Response
from plivo import plivo

app = Flask(__name__)

@app.route('/send_mms/', methods=['GET', 'POST'])
def outbound_mms():
    client = plivo.RestClient('<auth_id>','<auth_token>')
    response = client.messages.create(
        src='+14156667777',
        dst='+14156667778',
        media_ids=['801c2056-33ab-499c-80ef-58b574a462a2'],
        text='Hello, MMS from Python!',
        media_urls=['https://media.giphy.com/media/26gscSULUcfKU7dHq/source.gif'],
        type_='mms')
    return Response(response.to_string())

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

$ python send_mms.py

Replace the placeholders auth_id and auth_token with actual values from your Plivo Console. Save the file and run it with the command

Note: If you’re using a Plivo trial account, you can send messages only to phone numbers that have been verified with Plivo. You can verify a phone number using the Sandbox Numbers page of the console. Also, if you want to upload your media files to Plivo and use them, you can upload the file on the Messaging > MMS Media Upload page of the console.

Receive an MMS message

Of course, sending messages is only half of the equation. Plivo supports receiving SMS text messages in many countries (see our SMS API coverage page, and click on the countries you’re interested in). When someone sends an SMS message to a Plivo phone number, you can receive it on your server by using a Flask web app. Plivo will send the message along with other parameters, including the Media_URL(s), to your Message URL.

First, optionally, set up a virtual environment to keep these packages isolated from others on your system. Then create a file called receive_mms.py (or whatever name you like) with this code in it:

from flask import Flask, request

    app = Flask(__name__)
    
    @app.route('/receive_mms/', methods=['GET', 'POST'])
    def inbound_mms():
    
        from_number = request.values.get('From')
        to_number = request.values.get('To')
        text = request.values.get('Text')
        media_url = request.values.get('Media0')
        print('Message received - From: %s, To: %s, Text: %s, Media: %s'
        %(from_number, to_number, text, media_url))
    
        return 'Message Recevived'
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', debug=True)
    

Run it with the command

$ python receive_sms.py

You should then be able to see your basic server app in action on http://localhost:5000/receive_mms/.

That’s fine for testing, but it’s not much good if you can’t connect to the internet to receive incoming messages and handle callbacks. 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:

./ngrok http [portnum]

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

Now you can create an application to receive MMS messages (follow our Quickstart guide for details).

Conclusion

And that’s all there is to sending and receiving MMS messages using Plivo’s Python SDK. Don’t use Python? Don’t worry — we have SDKs for Java, PHP, Node.js, Ruby, .NET Core, .NET Framework, and Go.

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 Java 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 Java Spring Boot 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.

• 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 forward incoming calls

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 Dial XML element to forward the call to a mobile number. Use this code:

package com.example.CallForward;

    import com.plivo.api.exceptions.PlivoValidationException;
    import com.plivo.api.exceptions.PlivoXmlException;
    import com.plivo.api.xml.Dial;
    import com.plivo.api.xml.Response;
    import com.plivo.api.xml.Number;
    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 CallForwardApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(CallForwardApplication.class, args);
        }
    
        @RequestMapping(value = "/forward_call/", produces = {
            "application/xml"
        }, method = {
            RequestMethod.GET, RequestMethod.POST
        })
        public String ReceiveCall(@RequestParam("From") String from_number) throws 
        PlivoXmlException, PlivoValidationException {
            Response res = new Response()
                .children(
                    new Dial()
                    .callerId(from_number)
                    .children(new Number("14156667777"))
                );
            // Returns the XML
            return res.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/forward_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 forward 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://7ec95b6fd810.ngrok.io/forward_call/) in a browser or use 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 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://7ec95b6fd810.ngrok.io/forward_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 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 Java SDK and a spring boot 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.

A virtual assistant can help your business if you have clients who call your phone number. Interactive voice response (IVR) helps you to automate call reception by routing callers to the most appropriate department or the agent most qualified to meet their needs. Among its many advantages, IVR can provide increased operational efficiency, a stronger brand image, and better customer insights.

A voice-controlled virtual assistant is one step ahead of the legacy Touch-Tone/DTMF controlled one because of the flexibility it allows end users. They can just speak into their phone’s microphone to provide input to control the call.

Building a voice-controlled virtual assistant using Plivo’s automatic speech recognition (ASR) feature in .NET using ASP.NET MVC is simple. This guide shows you how to set up a voice-controlled IVR phone tree to a Plivo number and manage the call flow when the 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 use the GetInput XML element to capture speech input and implement a simple IVR phone system.

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.

How it works

Create an ASP.NET MVC application to create a voice-controlled virtual assistant

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 VirtualassistantController.cs 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 GetInput XML element to capture speech inputs and implement a simple IVR phone system. Use this code:

        
using System ;
    using System.Collections.Generic ;
    using System.Diagnostics ;
    using Microsoft.AspNetCore.Mvc ;
    using Plivo.XML ;
    
    namespace VirtualAssistant.Controllers
     {
        public class VirtualassistantController :Controller
         {
            //  Welcome message - firstbranch
            StringWelcomeMessage = "Welcome to the demo app, Say Sales to talk to our Sales representative. Say Support to talk to our Support representative" ;
            // This is the message that Plivo reads when the caller does nothing at all
            StringNoInput = "Sorry, I didn't catch that. Please hangup and try again later." ;
            // This is the message that Plivo reads when the caller inputs a wrong digit.
            StringWrongInput = "Sorry, it's a wrong input." ;
    
            publicIActionResult Index ()
             {
                arresp =new Response ();
                // This will dynamically assign the ngrok http_host to the action URL and interimSpeechResultsCallback URL.
                 varhostName =Request .HttpContext .Request .Host .Value ;
                Console . WriteLine (hostName );
                GetInputget_input =new GetInput ( "" ,newDictionary < string , string >() {
             {
               "action" ,
               "https://" +hostName + "/virtualassistant/firstbranch/"
             }, {
               "method" ,
               "POST"
             }, {
               "interimSpeechResultsCallback" ,
               "https://" +hostName + "/virtualassistant/firstbranch/"
             }, {
               "interimSpeechResultsCallbackMethod" ,
               "POST"
             }, {
               "inputType" ,
               "speech"
             }, {
               "redirect" ,
               "true"
             },
           });
                resp . Add (get_input );
                get_input . AddSpeak (WelcomeMessage ,newDictionary < string , string >() { });
                resp . AddSpeak (NoInput ,newDictionary < string , string >() { });
    
                 varoutput =resp . ToString ();
                returnthis . Content (output , "text/xml" );
             }
            // First branch of IVR phone tree
            publicIActionResult FirstBranch ()
             {
                Stringspeech =Request .Form [ "Speech" ];
                StringFromNumber =Request .Form [ "From" ];
                Debug . WriteLine ( "Speech Input is :" +speech );
                Dialdial =new Dial (newDictionary < string , string >() {
             {
               "callerId" ,
              FromNumber
             }
           });
    
                 varresp =new Response ();
    
                if (speech == "sales" )
                 {
                    dial . AddNumber ( "14156667777" ,newDictionary < string , string >() { });
                    resp . Add (dial );
                 }
                elseif (speech == "support" )
                 {
                    dial . AddNumber ( "14156667778" ,newDictionary < string , string >() { });
                    resp . Add (dial );
                 }
                else
                 {
                    // Add Speak XML Tag
                    resp . AddSpeak (WrongInput ,newDictionary < string , string >() { });
                 }
    
                Debug . WriteLine (resp . ToString ());
    
                 varoutput =resp . ToString ();
                returnthis . Content (output , "text/xml" );
             }
         }
     }
        

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

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

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

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 (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://b22604cbb5ff.ngrok.io/virtualassistant/) in a browser or 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 activate the voice-controlled virtual assistant.

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-Virtual-Assistant” — and configure the ngrok URL https://b22604cbb5ff.ngrok.io/virtualassistant/ 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 VirtualAssistant ASP.NET MVC application automatically routes the call to the Sales and Support departments based on the speech inputs received on the call.

And that’s how simple it is to set up a voice-controlled virtual assistant 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.

Like the monarch butterflies and their annual flight to Mexico, the Twilio migration is one of nature’s miracles. Every year hundreds of organizations, seeking improvements in their cloud communications software, move from Twilio to greener pastures in places like Plivo. And while many butterflies die of exhaustion or are eaten by birds on their journeys, few business professionals meet the same fate when they migrate from Twilio to Plivo. That’s because Plivo makes the process simple, with feature parity and similar APIs between the two platforms.

One of the lessons we’ve learned in more than 10 years of business is that to be a top alternative to Twilio, we need to offer customers feature parity. Everything you can do in Twilio you can do in Plivo — but we offer more than that.

Twilio can’t match our reliability, call quality, and pricing. Plivo is easier to use, has a wider global reach, and offers better tech support. We’ve written a Twilio migration guide that looks at the common issues that arise when organizations begin to question whether they could improve on their Twilio service, and addresses worries some organizations have about migrating.

One of the biggest challenges with any platform migration is the question of compatibility. No one wants to shred developer-years of work for incremental improvements. Fortunately, Plivo makes things easy. We’ve written a technical guide to migrating from Twilio to Plivo. It shows how similar the two companies’ API structures, implementation mechanisms, XML structure, SMS message processing, and voice call processing are. Read it to see a side-by-side comparison of the two platforms’ specific features and APIs, and code snippets that show the exact code you’d use with each platform to send and receive SMS messages and make and receive voice calls.

Anything you use Twilio for, you can do in Plivo: two-factor authentication (2FA), appointment reminders, account alerts, order notifications, SMS campaigns, click to call, call forwarding, call tracking, IVRs, and call routing. Dare we say anything they can do, we can do better?

If you’re not completely satisfied with Twilio, you don’t have to rip it out and replace it. You can put Plivo in a pilot program for a single use case and see how it seems. If you’re satisfied, you can switch over, or you can use Plivo in parallel with Twilio, or as a backup alternative in case your primary provider experiences downtime.

Either way, you owe it to yourself to explore your alternative. Download the guide, then sign up for a free trial account today and get started.

By the way, we have more Lessons in CPaaS Leadership blog posts: Find out why reliability, a strong carrier network, and consultative customer support make Plivo stand out among cloud communications platforms.

Your company has settled on Plivo to handle its voice and messaging communications, and now it’s your job to start integrating Plivo into your company’s applications. Don’t worry — Plivo has an SDK to help you out. Let’s see how to send and receive MMS through Plivo in a PHP application.

Install the Plivo PHP SDK

We’ll presume you already have PHP and Composer installed. Change to the directory into which you want to install the Plivo PHP release and run

$ composer require plivo/plivo-php

or you can download the source from our GitHub repository, then run

Find your Auth ID and Auth Token

You have to have proper credentials before you can use the Plivo API. We provide an Auth ID and Auth Token in the Account section at the top of the overview page of the Plivo console.

Choose a phone number

You need an MMS-enabled Plivo phone number to send MMS to the US and Canada, the two countries where Plivo supports sending MMS. Check the Phone Numbers screen of your Plivo console to see what numbers you have available and which of them support MMS capabilities. You can also buy numbers from this screen.

Send an MMS message

Now you’re ready to start. Create a file called SendMMS.php and paste in this code:

<?php
    require 'vendor/autoload.php';
    use Plivo\RestClient;
    
    $client = new RestClient("<auth_id>","<auth_token>");
    $client->client->setTimeout(40);
    
    $mediaURLs = ['https://media.giphy.com/media/26gscSULUcfKU7dHq/source.gif'];
    $mediaIDs = ['801c2056-33ab-499c-80ef-58b574a462a2'];
    $response = $client->messages->create(
      [  
           "src" => "+14152345678",
            "dst" => "+14165552222",
            "text"  =>"This is a test message",
            "url"=>"https://<yourdomain>.com/sms_status/",
            "type" => "mms", 
            "media_urls" => $mediaURLs, 
            "media_ids" => $mediaIDs
         ]
    );
    print_r($response);
    ?>
    

Replace the placeholders auth_id and auth_token with actual values from your Plivo Console. Save the file and run it with the command

$ php SendMMS.php

Note: If you’re using a Plivo trial account, you can send messages only to phone numbers that have been verified with Plivo. You can verify a phone number using the Sandbox Numbers page of the console. Also, if you want to upload your media files to Plivo and use them, you can upload the file on the Messaging > MMS Media Upload page of the console.

Receive an MMS message

Of course, sending messages is only half of the equation. When someone sends an MMS message to your US or Canada Plivo phone number, you can receive it on your server by setting a Message URL in your Plivo application. Plivo will send the message along with other parameters, including the Media_URL(s), to your Message URL.

Use this code to start a local server:

<?php
    require 'vendor/autoload.php';
    
    $from_number = $_REQUEST["From"];
    $to_number = $_REQUEST["To"];
    $text = $_REQUEST["Text"];
    $media_url = $_REQUEST["Media0"];
    
    echo("Message received - From $from_number, To: $to_number, Text: $text, Media: 
    $media_url" );
    

Save this code in any file — we’ll call ours receiveMMS.php. To run this file on the server, go to the folder where this file resides and issue the command

$ php -S localhost:8000

That’s fine for testing, but it’s not much good if you can’t connect to the internet to receive incoming messages and handle callbacks. 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:

$ ./ngrok http [portnum]

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

Now you can create an application to receive MMS messages (follow our Quickstart guide for details).

Conclusion

And that’s all there is to sending and receiving MMS messages using Plivo’s PHP SDK. Don’t use PHP? Don’t worry — we have SDKs for Java, Python, Node.js, Ruby, .NET Core, .NET Framework, and Go.

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 Python 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 Flask 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 a number, go to Phone Numbers > Buy Numbers on the Plivo console.

• Flask and Plivo Python packages — run pip install plivo flask to install them.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

Create a Flask application to forward incoming calls

Once you’ve installed Flask and the Plivo Python SDK, create a simple Flask 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 Python 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:

from flask import Flask, request, make_response, Response
    from plivo import plivoxml
    
    app = Flask(__name__)
    
    @app.route('/forward_call/', methods=['GET', 'POST'])
    def forwardcall():
    
       response = plivoxml.ResponseElement()
       response.add(
           plivoxml.DialElement().add_number('14156667777'))
 #call will be forwarded to this number
       return Response(response.to_string(), mimetype="text/xml")
    
    if __name__ == '__main__':
       app.run(host='0.0.0.0', debug=True)
    

Test the code locally

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

$ python forward_call.py

You should see your basic server application in action on http://localhost:5000/forward_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 forward incoming calls (5000 in this case, as our local Flask 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://e4cadf93d5f0.ngrok.io/forward_call/) in a browser or use HTTPie to check the XML response from the ngrok URL.

Connect the Flask 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://e4cadf93d5f0.ngrok.io/forward_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 Flask 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 Python SDK and a Flask 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.

A virtual assistant can help your business if you have clients who call your phone number. Interactive voice response (IVR) helps you to automate call reception by routing callers to the most appropriate department or the agent most qualified to meet their needs. Among its many advantages, IVR can provide increased operational efficiency, a stronger brand image, and better customer insights.

A voice-controlled virtual assistant is one step ahead of the legacy Touch-Tone/DTMF controlled one because of the flexibility it allows end users. They can just speak into their phone’s microphone to provide input to control the call.

Building a voice-controlled virtual assistant using Plivo’s automatic speech recognition (ASR) feature in Node.js using Express.js is simple. This guide shows you how to set up a voice-controlled IVR phone tree to a Plivo number and manage the call flow when the 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 use the GetInput XML element to capture speech input and implement a simple IVR phone system.

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.
• Expressjs 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.

How it works

Create an Express.js application to create a voice-controlled virtual assistant

Once you’ve installed Express.js and the Plivo Node.js SDK, create a simple Express.js 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 GetInput XML element to capture speech inputs and implement a simple IVR phone system. Use this code:

        
var plivo = require('plivo');

var express = require('express');

var app = express();

app.set('port', (process.env.PORT || 5000));

app.use(express.static(__dirname + '/public'));

//  Welcome message - firstbranch

var WelcomeMessage = "Welcome to the demo app, Say Sales to talk to our Sales representative. Say Support to talk to our Support representative"

// This is the message that Plivo reads when the caller does nothing at all

var NoInput = "Sorry, I didn't catch that. Please hangup and try again later."

// This is the message that Plivo reads when the caller inputs a wrong digit.

var WrongInput = "Sorry, it's a wrong input."

app.all('/response/ivr/', function (request, response) {

 if (request.method == "GET") {

  var r = new plivo.Response();

  const get_input = r.addGetInput(

   {

    'action': 'https://'+request.hostname+'/multilevelivr/firstbranch/',

    'method': 'POST',

    'interimSpeechResultsCallback': 'https://'+request.hostname+'/multilevelivr/firstbranch/',

    'interimSpeechResultsCallbackMethod': 'POST',

    'inputType': 'speech',

    'redirect': 'true',

   });

  get_input.addSpeak(WelcomeMessage);

  r.addSpeak(NoInput);

  console.log(r.toXML());

  response.set({ 'Content-Type': 'text/xml' });

  response.end(r.toXML());

 }

});

app.all('/multilevelivr/firstbranch/', function (request, response) {

 var from_number = request.query.From;

 var speech = request.query.Speech;

 console.log("Speech Input is:", speech)

 var r = new plivo.Response();

 var params = {

  'action': 'https://'+request.hostname+'/multilevelivr/action/',

  'method': 'POST',

  'redirect': 'false',

  'callerId': from_number

 };

 var dial = r.addDial(params);

 if (speech == "sales") {

  dial.addNumber("14156667777");

  console.log(r.toXML());

 }

 else if (speech == "support") {

  dial.addNumber("14156667778");

  console.log(r.toXML());

 }

 else {

  r.addSpeak(WrongInput);

 }

 response.set({ 'Content-Type': 'text/xml' });

 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 this code in any file (name the file something like detect_speech.js). To run this file on the server, go to the folder where this file resides and use the following command:

$ node detect_speech.js

And you should see your basic server app in action on http://localhost:3000/response/ivr/

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 (5000 in this case, as our local Express.js 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://02a9fe62aabd.ngrok.io/detect_speech) in a browser or HTTPie to check the XML response from the ngrok URL.

Connect the Express.js 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 activate the voice-controlled virtual assistant.

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-Virtual-Assistant” — and configured the ngrok URL https://02a9fe62aabd.ngrok.io/detect_speech 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 VirtualAssistant Express.js application automatically routes the call to the Sales and Support departments based on the speech inputs received on the call.

And that’s how simple it is to set up a voice-controlled virtual assistant on a Plivo number and handle it using XML documents using Plivo’s Node.js SDK and an Express.js 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.

Our customers use our cloud communications platform to send out billions of SMS messages every year. In keeping them happy and productive, we’ve learned a few things about best practices for sending SMS notifications. Whether you’re one of our customers or you haven’t tried Plivo yet (what are you waiting for?) here are some tips that can help your business use messaging more effectively.

Do you need convincing that SMS is the best communications channel for sending notifications to customers? According to Techjury, SMS messages have a 98% open rate, and 60% of people read text messages within 5 minutes after receiving them. And since almost 4 billion people worldwide own smartphones, you can send SMS messages to just about anyone — and do it cost-effectively. Alternatives like email, postal mail, and voice calling cost more and lack the reach, ease of use, and immediacy of SMS.

Maybe you already use SMS for some use cases — reminders or delivery alerts, maybe. You can leverage your investment in SMS messaging by doing more with it: offering event notifications or collecting customer feedback, for instance.

We’ve written a guide that talks about more possible use cases, and offers best practices for using SMS. You should download it to get all the details, but to stimulate your imagination, here’s a preview of what you’ll find.

Get permission

First, before you start sending messages willy-nilly, make sure you have permission to contact recipients. Thanks to privacy regulations such as the GDPR and CCPA, businesses need consumers to opt into being contacted. Organizations that fail to get permission may be subject to heavy fines.

Timing

Think about the optimal time to send your messages. Aim for times when your customers are likely to read them and take advantage of what you have to say. For example, if you’re a restaurant offering a lunchtime discount, think about scheduling your texts for the midmorning, so that your offers will be on your customers’ minds when they’re making lunch plans.

Personalization

Personalizing your messages lets you build deeper relationships with customers and treat them as unique individuals. Use your subscribers’ names, and keep the customer benefit at the front and center of the message.

Measure your results

Don’t just send out messages and hope for the best. You should have a plan to track and measure your efforts in place before you send your first message. Consider not only open and response rates, but also things like list growth rate, acquisition cost per recipient, and return on investment.

Infrastructure

Use a single platform to manage all your communication channels. A single platform takes less training, speeds up your time to market, and takes fewer resources and less time to maintain.

Prioritize deliverability

To be effective, SMS messaging should be timely — received as quickly as they’re sent —  and reliable — there’s no point in sending out messages that people can’t receive. But if your SMS messages can’t make it through, have a backup plan. Voice messaging offers an alternative to SMS for when your message absolutely, positively has to be there right away.

Get the guide

We go into more depth on these and other points in our best practices guide. Download it for free, or sign up for a free Plivo trial account and see how we let businesses take advantage of SMS messaging.