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.

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 Ruby 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-ruby-demo.git

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

$ cd 2fa-ruby-demo

• Install the dependencies using the Gemfile file.

$ bundle install

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

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 ruby.

code = rand(999_999)

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 initiate_phlo(dst_number, mode)
    code = rand(999_999)
    begin
      phlo = @phloclient.phlo.get(@phlo_id)
      # parameters set in PHLO - params
      params = {
        from: @app_number,
        to: dst_number,
        otp: code,
        mode: mode
      }
      phlo.run(params)
      code
    rescue PlivoRESTError => e
      puts 'Exception: ' + e.message
    end
  end

Verify the OTP

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

get '/verify/:number' do
  number = params['number']
  ##
  # verify(number) accepts a number and initiates verification for it.
	#
  code = if config['phlo_id'].nil?
           twofactor.send_verification_code_sms(number, 
           'Your verification code is __code__. Code will expire in 1 minute.')
         else
           twofactor.initiate_phlo(number, 'sms')
         end
  r.setex('number:%s:code' % number,
 60, code) # Verification code is valid for 1 min
  content_type :json
  { status: 'success', message: 'verification initiated' }.to_json
end

Test

To run the application, start Redis using the redis-server command. Build and Run the app using the command $ ruby app.rb. You can use the URL http://localhost:3000/ 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.

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.

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 Dotnet 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-dotnet-demo.git

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

$ cd 2fa-dotnet-demo

• Install the dependencies using the package.json file.

$ dotnet restore

• Edit the config.js 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 dotnet.

Random r = new Random();
var code = r.Next(999999);

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.”

 public int SendVerificationCodePhlo(String DstNumber, String mode)
		{
			Random r = new Random();
			var code = r.Next(999999);
            var phloClient = new PhloApi(AuthId, AuthToken);
            var phloID = PhloId;
            var phlo = phloClient.Phlo.Get(phloID); 
            var data = new Dictionary<string, object>
            {
                { "from", AppNumber },
                { "to", DstNumber },
		{ "mode", mode },
		{ "otp", code },

            };  
			phlo.Run(data);
            return code;
		}

Verify the OTP

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

public string Index(string number, string code)
    {
        ConnectionMultiplexer redis = 
  ConnectionMultiplexer.Connect(_configuration.GetValue<string>("RedisHost"));
        IDatabase conn = redis.GetDatabase();

    string key = $"number:{number}:code";
    var compare_code = (string)conn.StringGet(key);

        
    if (compare_code == code)
    {
            conn.KeyDelete(key);
            Verification verification = new Verification();
            verification.status = "success";
            verification.message = "Number verified";
            string output = JsonConvert.SerializeObject(verification);
            return output;
            }
            else if(compare_code != code)
            {
            Verification verification = new Verification();
            verification.status = "failure";
            verification.message = "Number verified";
            string output = JsonConvert.SerializeObject(verification);
            return output;
            }
        
            else
            {
            Verification verification = new Verification();
            verification.status = "failure";
            verification.message = "number not found!";
            string output = JsonConvert.SerializeObject(verification);
            return output;
            }
    }

Test

To run the application, start Redis using the redis-server command. Build and Run the app from Visual Studio. You can use the URL http://localhost:5001/ 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.

SMS — short message services — is one of the best tools for building relationships with your customers. 81% of Americans use SMS every day, and more than three-quarters of Americans wish they could text with a business. SMS is one of the most popular and frictionless communication channels in the world.

How popular is SMS? According to Statista, more than 2 billion text messages were sent in America in 2019. According to Gartner, “various sources report SMS open and response rates as high as 98% and 45%, respectively.”

What Is SMS?

SMS, or text messaging, lets people send messages of up to 160 alphanumeric characters between cell phones and other computer devices. Most carriers support longer messages through “concatenated SMS,” which automatically segments messages longer than 160 characters into multiple text messages and combines them at the receiving end.

SMS is almost 30 years old. The first text message, sent in 1992, simply read, “Merry Christmas.” The service was first offered to consumers in 1993, and growth was slow, in part because, initially, consumers couldn’t exchange messages with people who had service on other carriers. Also, early “dumb” mobile phones had only numerical keypads, so sending alpha characters required multiple keypresses, using a system called T9 — short for “text on 9 keys.” After Nokia offered the first smartphone with a QWERTY keyboard in 1996, texting began to get easier.

SMS popularity increased in 2007 when the iPhone was released. CBS News reported that in the first quarter of 2006, Americans sent and received 65 texts per month. By the second quarter of 2008, Americans were sending and receiving a whopping 357 text messages a month — a 450% increase. “Nicholas Covey, director of insights for Nielsen Mobile, attributed the spike in messaging to the spread of QWERTY-style keypads, whose users send 54% more text messages than those with ordinary keypads,” the New York Times reported. By the fourth quarter of 2007, American cell phone subscribers sent more text messages than they made phone calls.

Since then, SMS usage has grown further. As of 2020, according to 99firms, 5 billion people in the world could send and receive SMS messages, and over 90% of text messages are read within three minutes.

Types of SMS: P2P and A2P

There are two primary types of SMS content: person-to-person (P2P) and application-to-person (A2P).

P2P SMS is what most people imagine when they think of text messaging. P2P SMS is generally conversational, and it takes place between real people, generally in real time.

A2P SMS comes in three varieties, as we explain in our SMS best practices guide:

1. Informational messaging happens when a consumer gives their phone number to a business and asks to be contacted in the future.
2. Promotional messaging occurs when a message is sent that contains a sales or marketing promotion.
3. Transactional messages are non-marketing messages that provide important information to customers, such as a welcome message, an order confirmation, or a shipping update.

If a business wants to send SMS messages to customers, they have to take into account certain legal and regulatory considerations. For example, senders of A2P SMS messages must obtain consent from recipients, and they must send messages from an approved SMS number type.

Different countries have different requirements and regulations regarding A2P SMS, so businesses should check local rules.

Common ways businesses can leverage SMS

SMS is the most popular messaging platform, but not all businesses take advantage of it. In 2019, 54% of consumers said they wanted text messages from businesses, but a shockingly small 11% of businesses sent them, Small Business Trends reports.

That’s a shame, because it’s not difficult to automate communicating with customers through SMS. Automation allows you to send text messages to users to welcome them after they sign up for your service. You can remind them of sales and special offers, send order and delivery confirmations, and build community and closer relationships with your audience.

One Plivo customer, Jungleworks, “relies on SMS for coordinating order information, scheduling, reminders, and arrival ETAs. Using Plivo’s SMS API, Jungleworks keeps customers up-to-date with real-time text messages throughout the entire customer journey.”

Meanwhile, Houst uses Plivo to communicate via SMS directly with their customers. Houst’s use of SMS has grown exponentially but stayed reliable. Plivo allows them to “send messages from the same phone number for each property, which keeps a great consistency and user experience.”

Build better relationships with SMS messaging

Now you know what SMS is — a simple, modern communication method that your audience uses and likes. Take advantage of the popularity of SMS to talk directly with your customers in the way they prefer. Sign up for a free trial of Plivo.

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.

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 Node.js 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-node-demo.git

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

$ cd 2fa-node-demo

• Install the dependencies using the package.json file.

$ npm install

• Edit the config.js 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 Node.js.

const code = Math.floor(100000 + Math.random() * 900000);

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.”

 sendVerificationCode_phlo(DstNumber, mode) {
        var payload = {
            from: this.app_number,
            to: DstNumber,
            otp: code,
            mode: mode
        }
        phloClient = this.phlo_client
        phloClient.phlo(this.phloId).run(payload).then(function() {
            return code;
        }).catch(function(err) {
            console.error('Phlo run failed', err);
        });
    }

Verify the OTP

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

Test

To run the application, start Redis using the redis-server command. Start a Node.js server by using the $ node app.js command. The Node.js server will run the app in localhost on 8000 port. You can use the URL http://localhost:3000/ 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.

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.

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 PHP 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-php-demo.git

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

$ cd 2fa-php-demo

• Install the dependencies using the composer.json file.

$ composer install

• Edit the config.ini 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 PHP.

$code = random_int(100000, 999999);

‍

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.”

function send_verification_code_phlo($dst_number,$mode)
{
   $code = random_int(100000, 999999);
   $client = new PhloRestClient($this->config['auth_id'], $this->config['auth_token']);
    try {
        $phlo = $client->phlo->get($this->config['phlo_id']);
        $phlo->run(["from" => $this->config['app_number'], "to" => $dst_number,
         "mode"=>$mode, "otp"=>$code]); 
        // These are the fields entered in the PHLO console
        return $code;
    }
    catch (PlivoRestException $ex) {
        print_r($ex);
    }
}

Verify the OTP

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

<?php
/**
 * Initiate Validation process
 * @param $param[2] route param(Phone number) from index.php
 * @param $param[3] route param(OTP entered by user) from index.php
 */
$number = $param[2];
$code   = $param[3];

$original_code = $client->get('number:' . $number . ':code');

if ($original_code == $code) {
    $client->del('number:' . $number . ':code');
    echo '{"status": "success", "message": "codes match! number verified"}';
} elseif ($original_code != $code) {
    echo '{"status": "failure", "message": "codes do not match! number not verified"}';
} else {
    echo '{"status": "failure", "message": "number not found!"}';
}
?>

Test

To run the application, start Redis using the redis-server command. Start PHP server by using the $ php -S localhost:8000 command. PHP server will run the app in localhost on 8000 port. You can use the URL http://localhost:8000/ 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 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.