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 Dotnet 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 .NET MVC 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.
• 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 forward incoming calls

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

using System;
    using System.Collections.Generic;
    using Plivo.XML;
    using Microsoft.AspNetCore.Mvc;
    
    namespace VoiceApp.Controllers {
      public class ForwardCalls: Controller {
        public IActionResult Index() {
          Plivo.XML.Response resp = new Plivo.XML.Response();
          Plivo.XML.Dial dial = new Plivo.XML.Dial
          (new Dictionary < string, string > () {});
    
          // call will be forwarded to the below number
          dial.AddNumber("+14156667777",
            new Dictionary < string, string > () {});
          resp.Add(dial);
    
          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 app in action on http://localhost:5000/ForwardCalls/

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://42f68190ab0d.ngrok.io/ForwardCalls/) 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 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-call-forward” — and configure the ngrok URL https://42f68190ab0d.ngrok.io/ForwardCalls/ as the Answer URL. Select the HTTP verb as POST, then click Create Application.

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

Test the application

Make a phone call to the Plivo number you selected. You should see that the ASP.NET MVC application automatically 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 Dotnet SDK and ASP.NET MVC 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.

For every case that a customer needs to contact you for assistance, there’s probably another that they can handle on their own if you give them the tools. Press 1 if you know where we’re going with this.

Interactive voice response (IVR) systems let incoming callers access information via prerecorded messages or dynamically generated audio without having to speak to an agent. Callers can respond to spoken menus via Touch-Tone keypresses or speech recognition to maneuver through a spoken menu and reach the information they want. IVR is useful in many scenarios: finding an agent, making payments and purchases, offering travel information and weather conditions. Customers can conveniently open service tickets, book appointments, and track order shipments.

Individual departments can also improve customer experience by using IVR. If you receive large volumes of IT requests, for example, you can offer guided instructions for resetting passwords or rebooting customer applications.

Whenever a caller has an inquiry that can’t be resolved with one of these automated options, you can redirect them to a live agent. Many organizations use IVR to route calls to agents during business hours and provide automated voice messages after business hours.

Here are some detailed use cases for both inbound and outbound communication via IVR:

• Call center setup
  You can implement a multilevel IVR system in call centers that routes incoming calls based on user input.
• Televoting and surveys
  You can use IVR with outbound calls to collect information from customers, such as satisfaction or Net Promoter Scores.
• Appointment reminders
  You can set up automated appointment notifications to remind customers about their scheduled appointments in advance and facilitate rescheduling as needed.
• Lead assignment and lead routing
  For inbound sales calls, you can set up IVR with a set of qualifying questions to understand customers’ interest and redirect calls to representatives based on lead scores.
• Service dispatch
  Dispatch scheduling systems send services to people’s homes. They can use IVR to confirm people’s availability at the destination.

In short, IVR systems can reduce your costs and improve your customers’ experience. Plivo makes it easy to incorporate IVR into your own applications. We’ve written a guide to help you get started. Check it out, and sign up for free to try it yourself.

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.