> ## Documentation Index > Fetch the complete documentation index at: https://plivo.com/docs/llms.txt > Use this file to discover all available pages before exploring further. # Voice OTP > Verify phone numbers with voice one-time passwords using text-to-speech > [tab] Node > > ## 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. > > > [tab] 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](https://cx.plivo.com/signup) 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. > > > > ```js theme={null} > > 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("", ""); > > var response = client.calls.create( > > "", // from > > number, // to > > "https://.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](https://cx.plivo.com/home). Replace the phone number placeholder with an actual phone number in [E.164 format](https://en.wikipedia.org/wiki/E.164) (for example, +12025551234). > > > > > [!NOTE] > > > > > > **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. > > > > ```shell theme={null} > > $ node voiceotp.js > > $ 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= > > ``` > [tab] Ruby > > ## 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. > > > [tab] 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](https://cx.plivo.com/signup) 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 Ruby development environment. > > > > ## Create a Rails controller > > > > Change to the project directory and run this command to create a Rails controller for the voice OTP application. > > > > ```shell theme={null} > > $ 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. > > > > ```shell theme={null} > > $ rm app/views/plivo/voice.html.erb > > ``` > > > > ## Create a voice OTP application > > > > Edit app/controllers/plivo\_controller.rb file and add this code. > > > > ```ruby theme={null} > > 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("","") > > begin > > response = api.calls.create( > > '', > > [dst_number], > > "https://.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 > > ``` > > > > Replace the auth placeholders with your authentication credentials from the [Plivo console](https://cx.plivo.com/home). Replace the phone number placeholder with an actual phone number in [E.164 format](https://en.wikipedia.org/wiki/E.164) (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 `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: > > > > ```shell theme={null} > > get 'plivo/voice' > > ``` > > > > to > > > > ```shell theme={null} > > get 'plivo/verify_otp' > > get 'plivo/dispatch_otp' > > ``` > > > > ## Test > > > > Start Rails and Redis. > > > > ```shell theme={null} > > $ rails server > > $ redis-server > > ``` > > > > You should see your basic server application in action as below: > > > > ``` > > http://localhost:3000/plivo/dispatch_otp?destination_number= > > http://localhost:3000/plivo/verify_otp?destination_number=&otp= > > ``` > [tab] Python > > ## 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. > > > [tab] 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](https://cx.plivo.com/signup) 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 Python development environment. > > > > ## Create a voice OTP application > > > > Create a file called `voiceotp.py` and paste into it this code. > > > > ```py theme={null} > > 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/") > > def dispatch_otp(destination_number): > > try: > > # generate OTP. > > code = generate_code() > > > > # Make a call > > client = plivo.RestClient("", "") > > response = client.calls.create( > > from_="", > > to_=destination_number, > > answer_url=f"https://.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//") > > 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) > > ``` > > > > Replace the auth placeholders with your authentication credentials from the [Plivo console](https://cx.plivo.com/home). Replace the phone number placeholder with an actual phone number in [E.164 format](https://en.wikipedia.org/wiki/E.164) (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 `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. > > > > ```shell theme={null} > > $ 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 > > ``` > [tab] PHP > > ## 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. > [tab] .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. > > > [tab] 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](https://cx.plivo.com/signup) 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 .NET development environment. > > > > ## Create a voice OTP application > > > > In Visual Studio, create a controller named `otp.cs` and paste into it this code. > > > > ```cs theme={null} > > 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("", ""); > > var response = api.Call.Create( > > to: new List < String > { > > destination_number > > }, > > from: "", > > answerMethod: "POST", > > answerUrl: "https://.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; > > } > > } > > } > > } > > ``` > > > > Replace the auth placeholders with your authentication credentials from the [Plivo console](https://cx.plivo.com/home). Replace the phone number placeholder with an actual phone number in [E.164 format](https://en.wikipedia.org/wiki/E.164) (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 while initializing the client. You can store environment variables using `Environment.SetEnvironmentVariable Method` and fetch them using `Environment.GetEnvironmentVariable Method` when initializing the client. > > > > ## Test > > > > Save the file and run it, and start Redis. > > > > ```shell theme={null} > > $ redis-server > > ``` > > > > You should see your basic server application in action as below: > > > > ``` > > https://localhost:5001/dispatch_otp/?destination_number= > > https://localhost:5001/verify_otp/?destination_number=&otp= > > ```