Voice OTP

Node
Ruby
Python
PHP
.NET

Overview

This guide shows how to use a voice one-time password (OTP) to verify a mobile number. We first make a call to the phone number to be verified and use text-to-speech to read a random sequence of digits to the call recipients. The user then confirms the digits by entering them using dialpad keypresses. Voice OTP is commonly used to verify new user registrations for an app or website.You can send a voice OTP either by using our PHLO visual workflow builder or our APIs and XML documents. Follow the instructions in one of the tabs below.

Using XML

Here’s how to use Plivo APIs and XML to implement voice OTPs.

Prerequisites

To get started, you need a Plivo account — sign up with your work email address if you don’t have one already. If this is your first time using Plivo APIs, follow our instructions to set up a Node.js development environment.

Create a voice OTP application

Create a file called voiceotp.js and paste into it this code.

const express = require('express');
const app = express();
const redis = require('redis');
const redisClient = redis.createClient();
var plivo = require('plivo');

// Make call to the destination number with OTP
app.get('/dispatch_otp/:number', function(req, res) {
    const number = (req.params.number);
    const code = Math.floor(100000 + Math.random() * 900000);

    var client = new plivo.Client("<auth_id>", "<auth_token>");
    var response = client.calls.create(
        "<caller_id>", // from
        number, // to
        "https://<yourdomain>.com/answer_url/" + code, // answer url
        {
            answerMethod: "GET",
        },
    )
    console.log(response)
    redisClient.set(`number:${number}:code`, code, 'EX', 60);
    res.send(JSON.stringify({
        'status': 'success',
        'message': 'verification initiated'
    }));
});

// Validate the OTP entered by the user
app.get('/verify_otp/:number/:code', function(req, res) {
    const number = (req.params.number);
    const code = (req.params.code);
    redisClient.get(`number:${number}:code`, function(err, OriginalCode) {
        if (OriginalCode == code) {
            redisClient.del(`number:${number}:code`);
            res.send(JSON.stringify({
                'status': 'success',
                'message': 'Codes match — number verified'
            }));
        } else if (OriginalCode != code) {
            res.send(JSON.stringify({
                'status': 'failure',
                'message': 'Codes do not match — number not verified'
            }));
        } else {
            res.send(JSON.stringify({
                'status': 'failure',
                'message': 'Number not found'
            }));
        }
    });
});

app.listen(5000);

Replace the auth placeholders with your authentication credentials from the Plivo console. Replace the phone number placeholder with an actual phone number in E.164 format (for example, +12025551234).

Note: We recommend that you store your credentials in the auth_id and auth_token environment variables, to avoid the possibility of accidentally committing them to source control. If you do this, you can initialize the client with no arguments and Plivo will automatically fetch the values from the environment variables. You can use process.env to store environment variables and fetch them when initializing the client.

Test

Save the file and run it, and start Redis.

$ node voiceotp.js
$ redis-server

You should see your basic server application in action as below:

http://localhost:5000/dispatch_otp/?destination_number=<destination_number>
http://localhost:5000/verify_otp/?destination_number=<destination_number>&otp=<otp>

Overview

Using XML

Here’s how to use Plivo APIs and XML to implement voice OTPs.

Prerequisites

Create a Rails controller

Change to the project directory and run this command to create a Rails controller for the voice OTP application.

$ rails generate controller Plivo voice

It generates a controller named plivo_controller in the app/controllers/ directory and a respective view in app/views/plivo. We can delete the view as we don‘t need it.

$ rm app/views/plivo/voice.html.erb

Create a voice OTP application

Edit app/controllers/plivo_controller.rb file and add this code.

include Plivo
require 'redis'
require 'json'
include Plivo::Exceptions

class PlivoController < ApplicationController
	def dispatch_otp
		redis = Redis.new(host: "localhost")
		code = rand(999_999)
		dst_number = params[:dst_number]

		api = RestClient.new("<auth_id>","<auth_token>")
		begin
			response = api.calls.create(
				'<caller_id>',
				[dst_number],
				"https://<yourdomain>.com/answer_url/#{code}"
			)
			puts response
		end
		redis.setex(dst_number, 60, code) # Verification code is valid for 1 min
		puts JSON.pretty_generate({ :status=> 'success', :message=> 'verification initiated' })
	rescue PlivoRESTError => e
		puts 'Exception: ' + e.message
	end

	def verify_otp
		redis = Redis.new(host: "localhost")
		code = params[:otp]
		number = params[:number]
		original_code = redis.get(number)
		if original_code == code
			redis.del(number)  # verification successful, delete the code
			puts JSON.pretty_generate( { :status=> 'success', :message=> 'Codes match — number verified'})
		elsif original_code != code
			puts JSON.pretty_generate({ :status => "failure", :message=> 'Codes do not match — number not verified' })
		else
			puts JSON.pretty_generate( { :status=> 'rejected', :message=> 'Number not found' })
		end
	end
end

Note: We recommend that you store your credentials in the auth_id and auth_token environment variables, to avoid the possibility of accidentally committing them to source control. If you do this, you can initialize the client with no arguments and Plivo will automatically fetch the values from the environment variables. You can use ENV to store environment variables and fetch them when initializing the client.

Add a route

Edit the file config/routes.rb and change the line:

get 'plivo/voice'

get 'plivo/verify_otp'
get 'plivo/dispatch_otp'

Test

Start Rails and Redis.

$ rails server
$ redis-server

You should see your basic server application in action as below:

http://localhost:3000/plivo/dispatch_otp?destination_number=<destination_number>
http://localhost:3000/plivo/verify_otp?destination_number=<destination_number>&otp=<otp>

Overview

Using XML

Here’s how to use Plivo APIs and XML to implement voice OTPs.

Prerequisites

Create a voice OTP application

Create a file called voiceotp.py and paste into it this code.

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
        client = plivo.RestClient("<auth_id>", "<auth_token>")
        response = client.calls.create(
            from_="<caller_id>",
            to_=destination_number,
            answer_url=f"https://<yourdomain>.com/answer_url/{code}",
            answer_method="GET",
        )
        print(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 whether the code entered is correct
    """
    # 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)

Note: We recommend that you store your credentials in the auth_id and auth_token environment variables, to avoid the possibility of accidentally committing them to source control. If you do this, you can initialize the client with no arguments and Plivo will automatically fetch the values from the environment variables. You can use os module(os.environ) to store environment variables and fetch them when initializing the client.

Test

Save the file and run it, and start Redis.

$ python voiceotp.py
$ redis-server

You should see your basic server application in action as below:

http://localhost:5000/dispatch_otp/destination_number
http://localhost:5000/verify_otp/destination_number/otp

Overview

Using XML

Here’s how to use Plivo APIs and XML to implement voice OTPs.

Prerequisites

Create a voice OTP application

In Visual Studio, create a controller named otp.cs and paste into it this code.

using System;
using System.Collections.Generic;
using Plivo;
using StackExchange.Redis;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;

namespace otp.Controllers {
  public class otp: Controller {
    public object dispatch_otp(String destination_number) {
      ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost: 6379");
      IDatabase conn = redis.GetDatabase();

      Random r = new Random();
      var code = r.Next(999999);
      var api = new PlivoApi("<auth_id>", "<auth_token>");
      var response = api.Call.Create(
        to: new List < String > {
          destination_number
        },
        from: "<caller_id>",
        answerMethod: "POST",
        answerUrl: "https://<yourdomain>.com/answer_url/" + code);
      var key = string.Format("number:{0}:code", destination_number);
      conn.StringSet(key, code, TimeSpan.FromSeconds(60));

      Verification verification = new Verification();
      verification.status = "success";
      verification.message = "verification initiated";
      string output = JsonConvert.SerializeObject(verification);
      return output;
    }

    public string verify_otp(String destination_number, String otp) {
      ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost: 6379");
      IDatabase conn = redis.GetDatabase();

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

      if (compare_code == otp) {
        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 != otp) {
        Verification verification = new Verification();
        verification.status = "failure";
        verification.message = "Number not 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;
      }

    }

    private class Verification {
      public string status {
        get;
        internal set;
      }
      public string message {
        get;
        internal set;
      }
    }
  }
}

<a href="https://docs.microsoft.com/en-us/dotnet/api/system.environment.setenvironmentvariable?view=netcore-3.1" rel="nofollow">Environment.SetEnvironmentVariable Method</a>

and fetch them using

<a href="https://docs.microsoft.com/en-us/dotnet/api/system.environment.getenvironmentvariable?view=netcore-3.1" rel="nofollow">Environment.GetEnvironmentVariable Method</a>

when initializing the client.

Test

Save the file and run it, and start Redis.

$ redis-server

You should see your basic server application in action as below:

https://localhost:5001/dispatch_otp/?destination_number=<destination_number>
https://localhost:5001/verify_otp/?destination_number=<destination_number>&otp=<otp>

Getting Started

Concepts

API Reference

XML Reference

SDKs

Troubleshooting

Voice Tutorials

Migration Guides

Overview

Prerequisites

Create a voice OTP application

Test

Overview

Prerequisites

Create a Rails controller

Create a voice OTP application

Add a route

Test

Overview

Prerequisites

Create a voice OTP application

Test

Overview

Overview

Prerequisites

Create a voice OTP application

Test

​Overview

​Prerequisites

​Create a voice OTP application

​Test

​Overview

​Prerequisites

​Create a Rails controller

​Create a voice OTP application

​Add a route

​Test

​Overview

​Prerequisites

​Create a voice OTP application

​Test

​Overview

​Overview

​Prerequisites

​Create a voice OTP application

​Test

Overview

Prerequisites

Create a voice OTP application

Test

Overview

Prerequisites

Create a Rails controller

Create a voice OTP application

Add a route

Test

Overview

Prerequisites

Create a voice OTP application

Test

Overview

Overview

Prerequisites

Create a voice OTP application

Test