We’ve all spent much more time on a customer service call than we expected. We may have interacted with voice menus, listened to long menus, and still had to repeat the same information again and again. And we’ve left with the feeling of, “Why can’t this experience be better?” Studies show these subpar experiences decrease customer retention.

In a July 2021 report, The future of customer conversation, Accenture wrote: “We’re moving to a world where customers expect to engage with brands at any time, across multiple devices, channels, and touchpoints. Customers also expect interactions to be in tune with their personal preferences and schedules.”

In today’s mobile-first consumer world, customers want fast, flexible, and frictionless assistance. That’s why we built Contacto.

Contacto is an omnichannel contact center platform that combines traditional and emerging customer service channels with an easy-to-use interface, out of the box customizability for a focus on today’s mobile-first consumer.

Contacto is built on Plivo’s Premium Communications Platform that has been proven for scale over the last 10 years with billions of requests each month. It natively supports voice and emerging channels like in-app chat, WhatsApp, social media, and has pre-built integrations with existing applications like Salesforce, Zendesk, Shopify, Kustomer, and more.

Why Contacto, and why now?

Plivo has long been focused on the back end of communications and on building its voice and messaging API business.

But based on feedback from customers, we recognized an opportunity to package that back end into a vertical application for an underserved niche. Most businesses don’t have the time or resources to build out a fully customized contact center for their customer service needs. They’re already too occupied with running their own business.

That’s especially true for nimble businesses in the B2C retail and ecommerce space, where efficient, effective customer service is a growing competitive advantage. And customer expectations are very high.

We want to make it possible for every company, no matter their size, to provide customers with world-class customer service interactions.

Communication channels

Contacto comes with native, full-featured voice capabilities so there’s no need to engage costly third-party vendors for enterprise-grade on-call features, excellent call quality, and high reliability.

Web and in-app chat embedded directly into a brand’s application or website let customers interact with retailers while they shop and beyond.

Customers can choose messaging via SMS, MMS, or WhatsApp — the leading consumer chat app. Brands can also utilize notifications to deliver proactive support updates.

We plan to add native integrations with social platforms like Facebook, Twitter, and Instagram later this year.

Feature highlights

All agent activity in Contacto revolves around a unified agent desktop, where all communications channels are presented in a single simple interface.

That enables agents to:

• Respond to all incoming conversations from one screen, no matter their channel
• View the customer’s associated conversation timeline and interaction history
• Create and manage information in third-party systems without leaving Contacto

With all that information in one place, agents have the context they need to solve issues faster and create a more tailored experience for the customer.

Contacto is designed to work seamlessly with a business’ existing systems, with out-of-the-box integrations with Salesforce, Salesforce Service Cloud, Zendesk, Shopify, and more.

Plivo’s next phase of growth

With Contacto, Plivo is entering into its next evolution in the marketplace — offering not only best-in-class API products for technical teams, but also cloud-based communications solutions that offer superior out-of-the-box functionality for B2C customer service teams.

As Plivo embarks on its next 10 years of growth, we look forward to continued innovation and evolution, while maintaining our focus on providing customers with the solutions they want and need to succeed.

Sound interesting? Take a tour!

Interested in giving Contacto a try? We’d be happy to give you a quick tour. We look forward to helping you maximize agent productivity and meet customers on their terms with our unified cloud contact center for B2C teams.

Voice OTP is used to authenticate a phone number by delivering a one-time password (OTP) via a phone call. This verification is done by making a call to the mobile number and playing a sequence of digits. To verify the mobile number, the user needs to confirm the played sequence of digits.

OTPs are commonly used to verify new user registrations, online transactions, and login sessions in an app or website. In this blog post, we walk you through a sample implementation of sending a voice OTP using the Plivo Voice platform and PHLO, our visual workflow builder. Plivo’s direct carrier connectivity and intelligent routing engine guarantee the best call connectivity and quality.

Prerequisites

Before you get started, you’ll need:

• A Plivo account — sign up for one for free if you don’t have one already.
• A voice-enabled Plivo phone number if you want to receive incoming calls. To search for and buy a number, go to Phone Numbers > Buy Numbers on the Plivo console.

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

Create a PHLO to send OTP via phone call

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 to build a new PHLO. In the Choose your use case window, click Build my own. The PHLO canvas will appear with the Start node. Click on the Start Node, under API request, fill in the Keys as from, to, and otp, then click Validate. From the list of components on the left side, drag and drop the Initial Call component onto the canvas and connect the Start node with the Initiate Call node, using the API Request trigger state.

Configure the Initiate Call node with the using the From field, and in the To field. Once you’ve configured a node, click Validate to save the configurations.

Similarly, create a node for the Play Audio component and connect it to the Initiate Call node using the Answered trigger state. Configure the Play Audio node to play a specific message to the user — for example, in this case, “Your verification code is <OTP>”. Under Speak Text, click on Amazon Polly and paste the following:

<Speak voice="Polly.Amy">
    <prosody rate="medium">
        Your verification code is
    <break/>
    <break/>
    <say-as interpret-as="spell-out">{{Start.http.params.otp}}</say-as>
    </prosody>
</Speak>

Click Validate to save.

Connect the Initiate Call node with the Play Audio node using the Answered trigger state.

After you complete configuration, provide a friendly name for your PHLO and click Save.

Use the PHLO in a Flask application

Now you can use the PHLO in a Python Flask application.

• Create a project directory and change into it.
  

  $ mkdir mypythonapp
  $ cd mypythonapp

• Install the Plivo SDK using pip.
  

  $ pip install plivo

• Install other modules.
  

  $ brew install redis
  $ pip install redis
  $ pip install flask

We recommend that you use virtualenv to manage and segregate your Python environments, instead of using sudo with your commands and overwriting dependencies.

Run the PHLO to send OTP via phone call

Now you can trigger the PHLO and test it out. Copy the PHLO ID from the end of the URL of the workflow you just created. You’re also going to need your Auth ID and Auth Token. Create a Python source code file — let’s call it trigger_phlo.py — and paste this code into it:

import plivo
import random
import redis

from flask import Flask, jsonify

app = Flask(__name__)

r = redis.StrictRedis()

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


# Make call to the destination number with OTP.
@app.route("/dispatch_otp/<destination_number>")
def dispatch_otp(destination_number):
    try:
        # generate OTP.
        code = generate_code()

        # Make a call
        auth_id = <auth_id>
        auth_token = <auth_token>
        phlo_id = 'Your PHLO ID' # https://console.plivo.com/phlo/list/
        payload = {"from" : "+15671234567","to" : destination_number, "otp":code}
        phlo_client = plivo.phlo.RestClient(auth_id=auth_id, auth_token=auth_token)
        phlo = phlo_client.phlo.get(phlo_id)
        response = phlo.run(**payload)
        print str(response)
        print(r.setex("number:%s:code" % destination_number, 60, code))
        return (
            jsonify({"status": "success", "message": "verification initiated"}),
            200,
        )
    except:
        return ("Error encountered", 400)

# verify the OTP enetered by the user.
@app.route("/verify_otp/<destination_number>/<code>")
def check_code(destination_number, code):
    """
    check_code(number, code) accepts a number and the code entered by the user and
    tells if the code entered for that number is correct or not.
    """
    # fetch the OTP set for the destination number
    original_code = r.get("number:%s:code" % destination_number)

    if int(original_code) == int(code):  # verification successful, delete the code
        r.delete("number:%s:code" % destination_number)
        return (
            jsonify({"status": "success", "message": "codes match! number verified"}),
            200,
        )
    elif original_code != code:
        return (
            jsonify(
                {
                    "status": "rejected",
                    "message": "codes do not match! number not verified",
                }
            ),
            404,
        )
    else:
        return (jsonify({"status": "failed", "message": "number not found!"}), 500)


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

Substitute actual values for <auth_id>, <auth_token>, and <PHLO_ID>. Save the file and run it.

$ python trigger_phlo.py

Boom — you’ve made an outbound call with the OTP as a text-to-speech message.

Simple and reliable

And that’s all there is to send OTP via a phone call using Plivo’s Python SDK. Our simple APIs work in tandem with our comprehensive global network. You can also use Plivo’s premium direct routes that 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 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.