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 Go using the Gin application 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 rails 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.

• Golang, Gin, and Plivo go packages.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

How it works

Create a Gin web application to create a voice-controlled virtual assistant

Once you’ve installed Golang, Gin, and Plivo go packages, create a simple Gin web 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 Go 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:

        
package main

    import (
        "github.com/gin-gonic/gin"
        "github.com/plivo/plivo-go/v7/xml"
    )
    
    func >main() {
        >r := >gin.>Default()
        //  Welcome message - firstbranch
        >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
        >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.
        >WrongInput := "Sorry, it's a wrong input."
        >r.>GET("/virtual_assistant/", func(>c *>gin.>Context) {
            >c.>Header("Content-Type", "application/xml")
            >response := >xml.>ResponseElement{
                >Contents: []interface{}{
                    new(>xml.>GetInputElement).
                        >SetAction("https://" + >c.>Request.>Host + "/virtual_assistant/firstbranch/").
                        >SetMethod("POST").
                        >SetInputType("speech").
                        >SetInterimSpeechResultsCallback("https://" + >c.>Request.>Host + "/virtual_assistant/firstbranch/").
                        >SetInterimSpeechResultsCallbackMethod("POST").
                        >SetRedirect(true).
                        >SetContents([]interface{}{
                            new(>xml.>SpeakElement).
                                >AddSpeak(>WelcomeMessage, "WOMAN", "en-US", 1),
                        }),
                    new(>xml.>SpeakElement).
                        >AddSpeak(>NoInput, "WOMAN", "en-US", 1),
                },
            }
            >c.>String(200, >response.>String())
        })
        >r.>GET("/virtual_assistant/firstbranch/", func(>c *>gin.>Context) {
            >c.>Header("Content-Type", "application/xml")
            >speech := >c.>Query("Speech")
            >fromnumber := >c.>Query("From")
            // result := "Digit Input is:" + digit + " "
            if >speech == "sales" {
                >c.>XML(200, >xml.>ResponseElement{
                    >Contents: []interface{}{
                        new(>xml.>DialElement).
                            >SetCallerID(>fromnumber).
                            >SetContents([]interface{}{
                                new(>xml.>NumberElement).
                                    >SetContents("+14156667777"),
                            }),
                    },
                })
            } else if >speech == "support" {
                >c.>XML(200, >xml.>ResponseElement{
                    >Contents: []interface{}{
                        new(>xml.>DialElement).
                            >SetCallerID(>fromnumber).
                            >SetContents([]interface{}{
                                new(>xml.>NumberElement).
                                    >SetContents("+14156667778"),
                            }),
                    },
                })
            } else {
                >response := >xml.>ResponseElement{
                    >Contents: []interface{}{
                        new(>xml.>SpeakElement).
                            >AddSpeak(>WrongInput, "WOMAN", "en-US", 1),
                    },
                }
                >c.>String(200, >response.>String())
            }
        })
        >r.>Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
    }
    
  

Test the code locally

Save this code in any file (name the file something like virtual_assistant.go). To run this file on the server, go to the folder where this file resides and use the following command:

$ go run virtual_assistant.go

And you should see your basic server app in action on http://localhost:8080/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 incoming calls (8080 in this case, as our local Gin web application is running there):

$ ./ngrok http 8080

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

Test the link by opening the ngrok URL (https://59d9-49-206-115-115.ngrok.io/virtual_assistant/) in a browser or use HTTPie to check the XML response from the ngrok URL.

Connect the Gin web application to a Plivo number

The final step is to configure the 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://59d9-49-206-115-115.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 rails 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 Plivo’s Ruby SDK and a rails 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.

One of the key advantages of cloud computing is the ability to pay for only the resources you use. It’s true of the hardware resources you save if you spin up cloud instances, and it’s true of SaaS software like Plivo.

Using the cloud for computing and storage resources is a huge win over buying hardware. Hardware is expensive. It’s not easy to scale up as your needs change. It requires administrators to install and maintain it. And often it sits underutilized, meaning you’re not getting the full value out of your precious capital expenditures.

The same advantages apply to cloud software. You don’t have to pay an annual license fee (though you may have to pay an annual or monthly subscription fee). You don’t have to install anything, so you need fewer sysadmin resources. Your software doesn’t get out of date — you’re always working with the most recent version. There’s no contract to sign. The SaaS provider handles everything from security to availability — all you have to do is hand over your credit card.

With Plivo, the benefit is even bigger, because Plivo is pure pay-as-you-go — simple usage-based pricing. Check out our pricing page. Every phone call you make or receive, every text message you send or receive costs the same amount, and we tell you what you’ll pay in black and white right on our website, so you can see what Plivo costs compared to what our competitors charge — if they’re as transparent about their pricing as we are. There are no hidden fees or surcharges — what you see is what you pay.

Or rather, we should say, what you see is the most you’ll pay. If you commit to using Plivo for a certain level of voice and messaging traffic every month, we’ll give you a volume discount. You should talk to our sales team about how much of a discount you can enjoy for your individual use case.

To get you started, we have another great pricing scheme — free. Sign up for Plivo and we’ll give you free credits so you can see how easy it is to send messages and make voice calls with our APIs and our cloud communications platform. We have great getting started documentation and free 24/7 support. The sooner you try us out, the sooner you can start saving.

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 Go 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 Go Gin 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.

• Golang, Gin, and Plivo go packages.
• ngrok — a utility that exposes your local development server to the internet over secure tunnels.

How it works

Create a Gin web application to forward incoming calls

Once you’ve installed Golang, Gin, and Plivo go packages, create a simple Gin web 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 Go 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 main

    import (
        "github.com/gin-gonic/gin"
        "github.com/plivo/plivo-go/v7/xml"
    )
    
func main() {
    r := gin.Default()
    r.GET("/receive_call", func(c *gin.Context) {
    c.Header("Content-Type", "application/xml")
    response := xml.ResponseElement{
        Contents: []interface{}{
            new(xml.SpeakElement).
               AddSpeak("Hello, you just received your first call", "MAN", "en-US", 1),
                },
            }
            c.String(200, response.String())
        })
        r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
    }
    

Test the code locally

Save this code in any file (name the file something like forward_call.go). To run this file on the server, go to the folder where this file resides and use the following command:

$ go run receive_call.go

And you should see your basic server app 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 Gin web application is running there):

$ ./ngrok http 8080

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

Test the link by opening the ngrok URL (https://e67a-49-206-115-115.ngrok.io/forward_call) in a browser or use HTTPie to check the XML response from the ngrok URL.

Connect the Gin web application to a Plivo number

The final step is to configure the 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://e67a-49-206-115-115.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 Gin web 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 Go SDK and a Gin web 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 Ruby using Ruby on Rails 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 rails 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.

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

How it works

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

First, you need to install Rails if you haven’t installed it already. Use the command gem install rails, or use bundler or RVM to install it. Add a new Rails project with boilerplate code with the command rails new myrailsapp. This will create a myrailsapp directory with the necessary folders and files for development. Then add the Plivo Ruby gem (gem ‘plivo’, ‘~> 4.16.0’) as a dependency in the gemfile and use the command bundle install to install it.

Once you’ve installed Rails and the Plivo Ruby SDK, change to the newly created myrailsapp project directory and run rails generate controller Plivo voice to create a Rails 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 Ruby 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 in the PlivoController class in app/controllers/plivo_controller.rb file:

# Welcome message - firstbranch
$WelcomeMessage = "Welcome to the demo app, Press 1 for your account balance.
Press 2 for your account status. Press 3 to talk to our representative"
# This is the message that Plivo reads when the caller does nothing at all
$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.
$WrongInput = "Sorry, it's a wrong input."
class PlivoController < ApplicationController
  def virtual_assistant
    response = Plivo::XML::Response.new
    get_input = response.addGetInput(
		action:'https://'+request.host+'/plivo/va_firstbranch/', 
		digitEndTimeout: '5',
		inputType:'dtmf',
		method:'POST',
		redirect:'true',
    )
    get_input.addSpeak($WelcomeMessage, voice: 'Polly.Salli', language: 'en-US')
    response.addSpeak($NoInput)
    xml = Plivo::XML::PlivoXML.new(response)
    puts xml.to_xml()
    puts xml.to_xml
    render xml: xml.to_xml
 end
 def va_firstbranch
    speech = params[:Speech]
    from_number = params[:From]
    puts "Speech Input is:", speech
    response = Plivo::XML::Response.new
    if (speech == "sales")
      params = {
        'action' => 'https://'+request.host+'/plivo/multilevelivr/action/',
        'method' => "POST",
        'redirect' => "false",
        'callerId' =>from_number
      }
      dial = response.addDial(params)
      dial.addNumber("<number_1>")
    elsif (speech == "support")
      params = {
        'action' => 'https://'+request.host+'/plivo/multilevelivr/action/',
        'method' => "POST",
        'redirect' => "false",
        'callerId' =>from_number
      }
      dial = response.addDial(params)
      dial.addNumber("<number_2>")
    else
      response.addSpeak($WrongInput)
    end
    xml = Plivo::XML::PlivoXML.new(response)
    puts xml.to_xml
    render xml: xml.to_xml
  end
end

Test the code locally

Add a route for the inbound function in the PlivoController class. Open the config/routes.rb file and add this line after the inbound route: get ‘plivo/virtual_assistant’. To run the code on the rails server, use the command rails server. You should see your basic server application in action on http://127.0.0.1:3000/plivo/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 ngrok, but before you start the ngrok service, whitelist ngrok by adding it to the config.hosts list in the config/environments/development.rb file with this command. You’ll face a Blocked host error if you fail to add it.

# whitelist ngrok domain
config.hosts << /[a-z0-9]+\.ngrok\.io/

Now run ngrok on the command line, specifying the port that hosts the application on which you want to receive messages (3000 in this case, as our local Rails application runs there):

$ ./ngrok http 3000

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://e3b9-49-206-112-65.ngrok.io/plivo/virtual_assistant/) in a browser or HTTPie to check the XML response from the ngrok URL.

Connect the Rails 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://e3b9-49-206-112-65.ngrok.io/plivo/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 rails 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 Plivo’s Ruby SDK and a rails 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.

Go back to school with SMS from Plivo

Hey, Mr. Retailer, is back-to-school time an important shopping period for your business? We hope the season is going well for you this year — and we know a way to make it better in the future.

Plivo commissioned The Harris Poll to conduct a survey in August among more than 2,000 US adults aged 18 and older. We found that nearly 9 in 10 Americans (87%) are open to receiving communications from retailers they shop or want to shop with, and the percentage was even higher — 94% — among US adults who planned to do back-to-school shopping.

How do you reach all of those consumers, who have money that they’re already planning to spend — somewhere — on clothing, school supplies, dorm furnishings, and personal electronics? The best way to communicate with current and potential customers is through SMS text messaging. Consider these statistics from TechJury:

• 75% of people are open to receiving offers via SMS.
• 66% of Americans check their phones 160 times a day on average.
• SMS has a 98% open rate.
• More than 60% of people read their SMS messages within five minutes.

All of those statistics show that text messaging is a tool you can’t afford to ignore.

We dived a little deeper into the results of our Harris Poll survey and found that about 3 in 4 (74%) US adults surveyed would opt in to receive text messages from retailers, primarily for shipping and delivery notices and updates (45%) and coupons (43%). The results varied a bit with the age of the consumer; younger adults were more likely to opt in to any messaging, and adults ages 35-44 were most likely to opt in for sales promotions.

CPaaS and APIs FTW

While businesses may see the value of adding text messaging to their applications, they may be baffled about where to start. The answer is a cloud-based communications platform, also known as communication platform as a service (CPaaS), that provides a set of APIs that your developers can use to add the ability to send and receive messages to your existing applications.

Of course CPaaS platforms vary, so to take advantage of the power of SMS, you should look for a communications platform with a reliable network of high-quality carriers, a presence in every market you serve (with local phone numbers), and a simple, well-documented API that makes it easy for developers to add SMS messaging to your applications. Plivo not only provides all that, we walk our customers through the complex world of regulatory compliance for things like sending rate limits, data privacy, and sender ID regulations. Put all of that together and you can see why Plivo is the top cloud communications platform in customer satisfaction on G2.

That all sounds good, but we know you won’t be convinced until you see for yourself. That’s why we’ve written use case guides for common tasks like sending SMS messages that show you and your developers exactly how to implement more than a dozen common business tasks, with coding examples in seven common development languages. You can test any and all of them for free by creating a free Plivo account.

If you’re not already using SMS to communicate with your market, your customers aren’t the only ones who need to go back to school. We’ve got some interesting study aids for you. You can read about the power of using SMS for marketing. We’ve also written awhite paper on how to optimize your SMS communications, and an SMS best practices guide for more insights and tips. If you have questions on other topics, we encourage you to talk to one of our experts. They can help you pass SMS 101 with flying colors.

*This survey was conducted online within the United States by The Harris Poll on behalf of Plivo from August 10-12, 2021 among 2,082 U.S. adults ages 18 and older, of whom, 688 plan to shop for back to school this year. For complete survey methodology, please contact press@plivo.com.

With back-to-school season upon us, it’s time for a little pop quiz (remember those?). Do you know how back-to-school shoppers prefer to communicate with your brand?

If you’re not sure, you’re in the right place.

In early August, Plivo commissioned The Harris Poll to conduct a survey among more than 2,000 US adults aged 18 and older.* We found that nearly 9 in 10 Americans (87%) are open to receiving communications from retailers they shop or want to shop with, and the percentage was even higher — 94% — among US adults who planned to do back-to-school shopping.

Of those adults, 70% preferred email notifications, 53% preferred SMS/text messaging, and 32% preferred direct mail. Only 27% were open to in-app messaging and 26% were open to receiving phone calls.

When we looked into those who were specifically shopping for back to school, we discovered four more key insights:

Men and women are both doing back-to-school shopping

While men are less likely than women to do back-to-school shopping, a significant number of them still do. According to our survey, 36% of men and 34% of women are doing back-to-school shopping.

Older shoppers prefer email and direct mail communications

Reaching out to older shoppers? Be sure to reach out via their preferred channels. Back-to-school consumers over the age of 65 noted that their preferred form of communication is email (70%) and direct mail (65%), while SMS (19%) and phone call (7%) were their least preferred. By contrast, younger consumers between the ages of 18 and 34 most prefer email (65%) and SMS (56%), and least prefer direct mail (24%).

91% of back-to-school shoppers would opt in to SMS/text message notifications from retailers

In great news for brands, we found back-to-school consumers are very open to opting in to SMS notifications. They’re willing to sign up for:

• Shipping/delivery notices and updates (58%)
• Coupons (57%)
• Sale promotions (51%)
• Notification that product is back in stock (42%)
• Curbside pickup (37%)
• New product notifications (34%)

Clearly these consumers are most interested in deals and updates on existing orders. Back-to-school shoppers likely have specific supply lists or items in mind this time of year, so they’re looking for communications that help them find what they need, at a good price, delivered when they want it.

As income and education increases, so does the likelihood of opting in to SMS notifications

For the most part, the likelihood of opting in to retailers’ text notifications increases with income and education level. 88% of US adults with an income of under $50,000 said they would opt in, while 95% of those with an income over $100,000 would opt in. Meanwhile, 85% of those with a high school education or less would opt in, while of those with a college degree or more, 94% would opt in.

If you’re not already communicating with your back-to-school customers in their preferred channels, go back to school with us! Check out our guide to SMS notification use cases and best practices.

*This survey was conducted online within the United States by The Harris Poll on behalf of Plivo from August 10-12, 2021, among 2,082 U.S. adults ages 18 and older, of whom 688 plan to shop for back to school this year. For complete survey methodology, please contact press@plivo.com.

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

How it works

Create a Rails application to forward incoming calls

First, you need to install Rails if you haven’t installed it already. Use the command gem install rails, or use bundler or RVM to install it. Add a new Rails project with boilerplate code with the command rails new myrailsapp. This will create a myrailsapp directory with the necessary folders and files for development. Then add the Plivo Ruby gem (gem ‘plivo’, ‘~> 4.16.0’) as a dependency in the gemfile and use the command bundle install to install it.

Once you’ve installed Rails and the Plivo Ruby SDK, change to the newly created myrailsapp project directory and run rails generate controller Plivo voice to create a Rails 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 Ruby 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 in the PlivoController class in app/controllers/plivo_controller.rb file:

class PlivoController < ApplicationController
  def forward
   response = Plivo::XML::Response.new
   dial = response.addDial()
   dest_number = "14153234567"
   dial.addNumber(dest_number)

   xml = Plivo::XML::PlivoXML.new(response)
   puts xml.to_xml
   render xml: xml.to_xml
 end 
end

Test the code locally

Add a route for the inbound function in the PlivoController class. Open the config/routes.rb file and add this line after the inbound route: get 'plivo/forward'. To run the code on the rails server, use the command rails server. You should see your basic server application in action on http://127.0.0.1:3000/plivo/forward/.

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 ngrok, but before you start the ngrok service, whitelist ngrok by adding it to the config.hosts list in the config/environments/development.rb file with this command. You’ll face a Blocked host error if you fail to add it.

# whitelist ngrok domain
config.hosts << /[a-z0-9]+\.ngrok\.io/

Now run ngrok on the command line, specifying the port that hosts the application on which you want to receive messages (3000 in this case, as our local Rails application runs there):

$ ./ngrok http 3000

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://2e16-49-206-115-248.ngrok.io/plivo/forward/) in a browser or HTTPie to check the XML response from the ngrok URL.

Connect the Rails 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://2e16-49-206-115-248.ngrok.io/plivo/forward/ 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 Rails 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 Ruby SDK and a Rails 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.

Two-factor authentication (2FA) can play a key role in securing your applications against password data breaches. Authentication with a one-time password (OTP) delivered to your users over SMS is an effective approach to implementing two-factor authentication. Plivo’s premium direct routes guarantee the highest possible delivery rates and the shortest possible delivery times for your 2FA SMS messages. In this blog post, we walk you through a sample implementation of 2FA using the Plivo SMS platform and PHLO, our visual workflow builder.

{{cta-style-1}}

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 to send messages to the US and Canada. To search for and rent an available number, go to Phone Numbers > Buy Numbers on the Plivo console.

Create a PHLO to send OTP via SMS

PHLO lets you construct your entire use case and build and deploy workflows visually. With PHLO, you pay only for calls you make and receive, and building with PHLO is free.

To get started, visit PHLO in the Plivo console and click on Create New PHLO. A pop-up window gives you a list of prebuilt templates to start with. Choose Two-Factor Authentication and click Create Application to create a PHLO with the prebuilt components to build a workflow that can manage sending the OTP via SMS, with failover to use a phone call to deliver the OTP as a text-to-speech (TTS) message.

Use the PHLO in a Flask application

We have a demo application available for this in our GitHub repository that you can clone to see how the implementation works.

• Clone the repository from GitHub.

$ git clone https://github.com/plivo/2fa-python-demo.git

• Change your working directory to 2fa-python-demo.

$ cd 2fa-python-demo

• Install the dependencies using the requirements.txt file.

$ pip install -r requirements.txt

• Edit the settings.py file. Replace the PLIVO_AUTH_ID, PLIVO_AUTH_TOKEN, PLIVO_NUMBER, and PHLO_ID placeholders with your own values.

Note: Enter your phone number in E.164 format.

Generate the OTP

Generate an exclusive six-digit authentication code. To create the OTP, use the time-based OTP generation algorithm. Here’s how it’s done in Python.

def generate_code(self):
    code = random.choice(range(100000, 999999))  # generating 6 digit random code
    return code

Send OTP via SMS or a phone call

A single function helps us to trigger the PHLO to send SMS messages and make calls; the rest of the work is done by PHLO. Use the mode argument to tell PHLO whether to trigger a call or an SMS message by passing the value “sms” or “call.”

def send_verification_code_phlo(self,dst_number,code,mode):
    payload = {
        "from": self.app_number,
        "to": dst_number,
        "otp": code,
        "mode": mode,
    }
    try:
        phlo = self.client_phlo.phlo.get(self.phlo_id)
        response = phlo.run(**payload)
        return response
    except exceptions as e:
        print(e)
        return ("Error encountered", 400)

Verify the OTP

After the user enters the OTP they received on their handset, this Python code verifies it.

@app.route("/verify/<number>")
    def verify(number):
        """
        verify(number) accepts a number and initiates verification for it.
        """
        try:
            code = current_app.p2fa.generate_code()
            if app.config["PHLO_ID"] == "":
                {
                    current_app.p2fa.send_verification_code_sms(
                        number,
                        f'Your verification code is "{code}".
                        Code will expire in 1 minute. ',
                    )  # String should be less than 160 chars
                }
            else:
                {current_app.p2fa.send_verification_code_phlo(number, code, "sms")}
            current_app.redis.setex(
                "number:%s:code" % number, 60, code
            )  # Verification code is valid for 1 min
            return jsonify({"status": "success", "message": "verification initiated"})
        except:
            return ("Error encountered", 400)
    

Test

To run the application, start Redis using the redis-server command. Start Flask, the Python web framework module, by typing flask run. Flask will display the URL and port number on which it’s running. Click on that link to run the sample application in your browser.

On the browser page, choose your country and enter your mobile number, then click on Send Verification Code. Check your mobile phone — you should get an SMS message with an OTP code. Enter the code in the browser form and click Verify, and the application will confirm that you’re verified.

What if you don’t get the SMS message you were expecting, or you wait too long to enter the value you received? The application gives you a link so you can use a phone call as a fallback OTP channel. Click on “Didn’t receive sms? Call me.” You should then receive a call, and when you answer it, you’ll hear a text-to-speech message that gives you an OTP code, which you can use in the form for verification.

Simple and reliable

Edit the sample application to see how simple it was to code. Our simple APIs work in tandem with our comprehensive global network. Plivo’s premium direct routes guarantee the highest possible delivery rates and the shortest possible delivery times for your 2FA SMS and voice messages. See for yourself — sign up for a free trial account.

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

• 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}}

How it works

Create a spring boot application to create a voice-controlled virtual assistant

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

        
package com.example.VirtualAssistant ;

    import com.plivo.api.exceptions.PlivoValidationException ;
    import com.plivo.api.exceptions.PlivoXmlException ;
    import com.plivo.api.xml.* ;
    import com.plivo.api.xml.Number ;
    import org.springframework.boot.SpringApplication ;
    import org.springframework.boot.autoconfigure.SpringBootApplication ;
    import org.springframework.web.bind.annotation.* ;
    
    import javax.servlet.http.HttpServletRequest ;
    
    @SpringBootApplication
    @RestController
    public class VirtualAssistantApplication {
        public static void main (final String [] args ) {
            SpringApplication .run (VirtualAssistantApplication .class , args );
        }
    
        // Welcome message - firstbranch
        String 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
        String 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.
        String wrongInput = "Sorry, it's a wrong input." ;
    
        @GetMapping (value = "/virtual_assistant/" , produces = {
            "application/xml"
        })
    
        public Response getInput (HttpServletRequest request ) throws PlivoXmlException , PlivoValidationException {
            String hostName = request .getRequestURL ().toString ();
            final Response response = new Response ().children (
                    new GetInput ().action (hostName + "firstbranch/" ).method ("POST" )
                    .interimSpeechResultsCallback (hostName + "firstbranch/" )
                    .interimSpeechResultsCallbackMethod ("POST" ).inputType ("speech" ).redirect (true )
                    .children (new Speak (welcomeMessage )))
                .children (new Speak (noInput ));
            System .out .println (response .toXmlString ());
            return response ;
        }
    
        @RequestMapping (value = "/virtual_assistant/firstbranch/" , produces = {
            "application/xml"
        }, method = RequestMethod .POST )
        public Response firstbranch (HttpServletRequest request , @RequestParam ("Speech" ) final String speech ,
            @RequestParam ("From" ) final String fromNumber ) throws PlivoXmlException , PlivoValidationException {
            System .out .println ("Speech Input is:" + speech );
            String hostName = request .getRequestURL ().toString ();
            final Response response = new Response ();
            if (speech .equals ("sales" )) {
                response .children (
                    new Dial ().callerId (fromNumber ).action (hostName + "action/" )
                    .method ("POST" ).redirect (false ).children (new Number ("<number_1>" )));
            } else if (speech .equals ("support" )) {
                response .children (
                    new Dial ().callerId (fromNumber ).action (hostName + "action/" )
                    .method ("POST" ).redirect (false ).children (new Number ("<number_2>" )));
            } else {
                response .children (new Speak (wrongInput ));
            }
            System .out .println (response .toXmlString ());
            return response ;
        }
    }
    
        

Test the code locally

Save the file and run the application. You should see your basic server application in action on http://localhost:8080/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 (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://46a4-49-206-115-248.ngrok.io/virtual_assistant/) in a browser or 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 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://46a4-49-206-115-248.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 spring boot 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 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.