Verified Caller ID New

Plivo’s Verified Caller ID feature allows customers to use their own numbers as outbound caller IDs after verification.

Simply register the number you wish to use for outbound calls with Verified Caller ID. Plivo will send a one-time password (OTP) to the designated number through your preferred channel—SMS or voice. Once successfully authenticated, your number will be added to the verified caller ID list and can be used as the caller ID for making outbound calls.

There are two ways to verify your number: through the Plivo console or using Plivo’s REST APIs or SDKs.

Why should you verify a caller ID?

The rise of call spoofing poses a significant challenge for businesses globally. This fraudulent practice uses technology to mimic calls from local numbers, reputable companies, government agencies, or genuine contacts.

Plivo’s Verified Caller ID, designed to combat call spoofing, strengthens outbound call credibility by ensuring number verification before their utilization as the outbound caller ID.

Verify your caller ID using Plivo’s APIs

Initiate the verification process using Plivo’s Verified Caller APIs/SDK according to the guides linked below. Plivo will initiate the OTP through the channel you select.

Code

1
2
3
4
5
6
7
8
9
10
import plivo

client = plivo.RestClient('<Auth>', '<Token>')

response = client.verify_callerids.initiate_verify(phone_number='<phone_number>',
                                                   alias='<alias>',
                                                     channel='call/sms',
                                                     subaccount='<subaccount>')

print(response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
require 'rubygems'
require 'plivo'

include Plivo
include Plivo::Exceptions


api = RestClient.new("<auth>", "<token>")
begin
    response = api.verify_caller_id.initiate(
        phone_number="91XXXXXXXXXX", channel="sms", alias_ = "test",subaccount="<subAccountAuth>" 
    )
    
    puts response
rescue PlivoRESTError => e
  puts 'Exception: ' + e.message
  
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var plivo = require('plivo');

(function main() {
    'use strict';
    
    var client = new plivo.Client("<auth_id>","<auth_token>");
    client.verify.initiate('<phoneNumber>',{
    channel : '<call/sms>',
    alias : '<TestAlias>',
    subAccount  : '<SubAccount>'
    }).then(function(response) {
    console.log(response);
    }, function (err) {
        console.error(err);
    });
})();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
/**
 * Example for initiat verify api request
 */
require 'vendor/autoload.php';
use Plivo\RestClient;
use Plivo\Exceptions\PlivoRestException;
$client = new RestClient("<auth>","<token>");

try {
    
    $response = $client->verifyCallerId->initiate("+91XXXXXXXXX", [
        "alias" => "test",
        "subaccount" => "<Subaccount>",
        "channel" => "Call"   
    ]);

        print_r($response);
    }
    catch (PlivoRestException $ex) {
    print_r($ex);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.plivo.examples;

import com.plivo.api.Plivo;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.verify.InitiateVerifyResponse;
import com.plivo.api.models.verify.Verify;

import java.io.IOException;

public class verificationCallerID {

  public static void main(String[] args) {
    Plivo.init("<auth>", "<token>");
     try {
      InitiateVerifyResponse response = Verify.initiateVerify().phoneNumber("91XXXXXXXXXX").alias("test").channel("call").create();
      System.out.println(response);
    } catch (PlivoRestException | IOException e) {
      e.printStackTrace();
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main
import (
	"fmt"
	"github.com/plivo/plivo-go/v7"
)

func main() {
	client, err := plivo.NewClient("<Auth>", "<Token>", &plivo.ClientOptions{})
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	response, err := client.VerifyCallerId.InitiateVerify(plivo.InitiateVerify{PhoneNumber: "<phoneNumber>", Alias: "<TestAlias>", Channel : "<call/sms>", SubAccount: "<SubAccount>"})

	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	fmt.Printf("Response: %#v\n", response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using System;
using System.Collections.Generic;
using Plivo;
using Plivo.Exception;

namespace PlivoExamples
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            var api = new PlivoApi("<auth-id>","<auth-token>");
            try
            {
                var response = api.VerifyCallerId.Initiate("<phone_number>", "<call/sms>", "<alias-test>","<subaccount>");
                Console.WriteLine(response);
            }
            catch (PlivoRestException e)
            {
                Console.WriteLine("Exception: " + e.Message);
                Console.WriteLine("Exception: " + e);
            }
        }
    }
}

1
2
3
4
curl -i --user AUTH_ID:AUTH_TOKEN \
    -H "Content-Type: application/json" \
    -d '{"phone_number": "+12025551XXX","alias":"US Mainland"}' \
    https://api.plivo.com/v1/Account/{auth_id}/VerifiedCallerId/

Verify your one-time passcode (OTP) via API

As part of the caller ID verification process, you will need to confirm your phone number by receiving an OTP. Follow the guides linked below to verify your OTP using APIs and SDK. Once the OTP is confirmed, you can use the verified number as a caller ID.

Code

1
2
3
4
5
6
7
import plivo

client = plivo.RestClient('<Auth>', '<Token>')

response = client.verify_callerids.verify_caller_id(verification_uuid="68dea750-5a76-485d-8ac3-5cf5996ba2fb",otp="123456")

print(response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
require 'rubygems'
require 'plivo'

include Plivo
include Plivo::Exceptions


api = RestClient.new("<auth>", "<token>")
begin
  response = api.verify_caller_id.verify("<verification_uuid>", "<otp>")
    puts response
rescue PlivoRESTError => e
  puts 'Exception: ' + e.message
  
end

1
2
3
4
5
6
7
8
9
10
11
12
var plivo = require('plivo');

(function main() {
    'use strict';
    
    var client = new plivo.Client("<auth_id>","<auth_token>");
	client.verify.verify("<verification_uuid>","<otp>").then(function(response) {
                console.log(response);
            }, function (err) {
                console.error(err);
            });
})();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
/**
 * Example for verify API request
 */
require 'vendor/autoload.php';
use Plivo\RestClient;
use Plivo\Exceptions\PlivoRestException;
$client = new RestClient("<auth>","<token>");

    try {

    $response = $client->verifyCallerId->verify("<verification_uuid>","<otp>");
    
        print_r($response);
    }
    catch (PlivoRestException $ex) {
    print_r($ex);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.plivo.examples;

import com.plivo.api.Plivo;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.verify.InitiateVerifyResponse;
import com.plivo.api.models.verify.Verify;

import java.io.IOException;

public class verificationCallerID {

try{ 
    VerifyCallerIdResponse response = Verify.verifyCallerId("2dfd42e2-431d-4bf6-bc70-d3971ffae240").otp("277407").create();
    System.out.println(response);
    
    }catch(PlivoRestException | IOException  e){
        e.printStackTrace();
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main
import (
	"fmt"
	"github.com/plivo/plivo-go/v7"
)

func main() {
	client, err := plivo.NewClient("<Auth>", "<Token>", &plivo.ClientOptions{})
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	response, err := client.VerifyCallerId.VerifyCallerID("<verification_uuid>","123456")

	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	fmt.Printf("Response: %#v\n", response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using System;
using System.Collections.Generic;
using Plivo;
using Plivo.Exception;

namespace PlivoExamples
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            var api = new PlivoApi("<auth-id>","<auth-token>");
            try
            {
                var response = api.VerifyCallerId.Verify("<otp>", "<verification_uuid>");
                Console.WriteLine(response);
            }
            catch (PlivoRestException e)
            {
                Console.WriteLine("Exception: " + e.Message);
                Console.WriteLine("Exception: " + e);
            }
        }
    }
}

1
2
3
4
curl -i --user AUTH_ID:AUTH_TOKEN \
    -H "Content-Type: application/json" \
    -d '{"otp": "7871"}' \
    https://api.plivo.com/v1/Account/{auth_id}/VerifiedCallerId/Verification/f87836bd-f3c0-41bb-9498-125e6faaa4d4/

Verify your caller ID using the Plivo console

You can verify your caller ID on the Plivo console by taking the following steps.

Log in to the Plivo console.
Go to Voice → Verified Caller ID.
Choose "Verify Your First Number."

Enter the alias name, the number requiring verification, and the verification method. If you're a reseller verifying for your client, select the sub-account.

After selecting "Request Verification Code," you'll receive the code via SMS or voice, depending on the method you selected.

Upon successful verification, your number will be added to the Verified Caller ID list. You can then use the verified number as a caller ID to place outbound calls.

Rate this page

🥳 Thank you! It means a lot to us!