> ## 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

<Tabs>
  <Tab title="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.

    <Tabs>
      <Tab title="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](/sdk/server/set-up-node-dev-environment-api-xml-voice/).

        ## 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("<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](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>
          <strong>Note:</strong> 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.
        </Note>

        ## 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=<destination_number>
        http://localhost:5000/verify_otp/?destination_number=<destination_number>&otp=<otp>
        ```
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="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.

    <Tabs>
      <Tab title="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](/sdk/server/set-up-ruby-dev-environment-api-xml-voice/).

        ## 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("<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
        ```

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

        <div class="notice-box">
          <strong>Note:</strong>
          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.
        </div>

        ### 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=<destination_number>
        http://localhost:3000/plivo/verify_otp?destination_number=<destination_number>&otp=<otp>
        ```
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="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.

    <Tabs>
      <Tab title="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](/sdk/server/set-up-python-dev-environment-api-xml-voice/).

        ## 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/<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)
        ```

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

        <div class="notice-box">
          <strong>Note:</strong>
          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.
        </div>

        ## 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>
    </Tabs>
  </Tab>

  <Tab title="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.

    <Tabs>
      <Tab title="Using XML">
        asd
      </Tab>
    </Tabs>
  </Tab>

  <Tab title=".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.

    <Tabs>
      <Tab title="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](/sdk/server/set-up-dotnet-dev-environment-api-xml-voice/).

        ## 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("<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;
              }
            }
          }
        }
        ```

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

        <div class="notice-box">
          <strong>Note:</strong>
          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 `<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.
        </div>

        ## 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=<destination_number>
        https://localhost:5001/verify_otp/?destination_number=<destination_number>&otp=<otp>
        ```
      </Tab>
    </Tabs>
  </Tab>
</Tabs>