Official WhatsApp Business API Partner
wa.sendpk.com logo
WhatsApp Call Verification API

Verified with a single call

Your user calls your WhatsApp number. We pick up, confirm the number, play a short message and hang up. No code to type, no SMS to wait for.

Live Environment No OTP to type Number confirmed by WhatsApp Pay only when verified PHP · Node.js · Python
Base URL https://wa.sendpk.com/apps/whatsapp_call_verification/

Overview

WhatsApp Call Verification proves that a person really owns a phone number. Instead of sending a code, you ask the person to make a short WhatsApp call to your business number. WhatsApp tells us who is calling, so the number is confirmed the moment the call connects.

Perfect for: sign-up and login, checkout and cash-on-delivery confirmation, password reset, and any place where you need to know the number is real.
Note: to use this service, WhatsApp calling must be switched on for your WhatsApp number. Meta allows this only when your Meta Business Manager is verified. Once it is verified, contact us and we will enable calling on your account.

How It Works

Five steps, one WhatsApp call — about 10 seconds from start to “verified”.

No code to type. No SMS to wait for. The user just makes one WhatsApp call to your number. WhatsApp tells us who is calling — that is the proof.

  1. 1 Your app

    You start a verification

    Number to verify +92 300 1234567
  2. 2 Their phone

    They tap Call on WhatsApp

    Call on WhatsApp The call goes to your WhatsApp number, from the number being verified.
  3. 3 We answer

    WhatsApp tells us who is calling

    Incoming WhatsApp call +92 300 1234567 Same number as the request
  4. 4 Short message

    We play a message and hang up

    “Your phone number has been verified. Thank you.”
  5. 5 You get the result

    The number is verified

    Checking… Number verified

Nothing is sent to the phone, so there is nothing to intercept and nothing to type wrong. You pay only when a number is verified.

The user calls your own WhatsApp number — the one connected to your account. WhatsApp calling must be switched on for that number.
STEP-BY-STEP TUTORIAL

See it working in minutes — with a free demo

A ready-made web page you upload to your website, plus a simple guide from zero to “Number verified”. Works on Android and iPhone. Your API key stays on your server, never in the page.

Two ways to verify

  • Automatic — the user taps Call on WhatsApp and makes the call. The page says “Number verified” by itself, with a signed webhook or by checking every few seconds (2–30, default 5).
  • With a Verify button — the user makes the call, comes back and taps Verify. No webhook needed.

Live demo

Try it right now with your own phone: type your WhatsApp number, tap Call on WhatsApp, make the call — and watch the page say “Number verified”.

Open Live Demo
Download Website Demo (ZIP) 3 files: index.html, wa-call-verify.php, README.txt

Authentication

Send your API key in the Authorization header of every request.

Authorization: YOUR-API-KEY

Authorization: Bearer YOUR-API-KEY works too. The key is never accepted in the URL or the body.

1. Create an accountRegister, then log in to the customer portal.
2. Get your API keyCopy it from the profile page in your dashboard. It is the same key as the WhatsApp API.
Call this API from your server, never from a browser or mobile app. Anyone who sees your API key can use your balance.

Base URL

All endpoints live under the Base URL shown at the top of this page (your own account domain). Every example already uses it.

EndpointMethodWhat it does
start.phpPOSTStart a verification for one number
status.php?id=GETRead the current state of a verification
cancel.phpPOSTCancel a verification that is still waiting

Requests use HTTPS only and send JSON. Every reply is JSON with the same shape:

// success
{ "success": true,  "data": { ... },  "meta": { "request_id": "..." } }

// error
{ "success": false, "error": { "code": "...", "message": "...", "details": { } }, "meta": { "request_id": "..." } }

Keep meta.request_id when something goes wrong — support can find your exact request with it.

POST

Start a Verification

POST https://wa.sendpk.com/apps/whatsapp_call_verification/start.php

Creates a verification for one number. The user then has 5 minutes to call.

Body (JSON)

FieldRequiredDescription
number*YesThe number to verify, in international format: country code + number, e.g. 923001234567. (+923001234567 and the local 03001234567 are also accepted.)
whatsapp_idNoWhich of your WhatsApp numbers the user should call (its ID). Default: your first active number.
audio_urlNoYour own message to play, as a link. See Your Own Message. Default: our standard message.
expires_inNoSeconds the user has to call: 60 to 300. Default: 300 (5 minutes).
notification_callbackNoYour webhook URL, to get updates without polling. See Webhooks.

Optional header: Idempotency-Key — see Safe Retries.

Example Request

curl -X POST 'https://wa.sendpk.com/apps/whatsapp_call_verification/start.php' \
  -H 'Authorization: YOUR-API-KEY' \
  -H 'Content-Type: application/json' \
  -d '{"number": "923001234567"}'
<?php
$ch = curl_init('https://wa.sendpk.com/apps/whatsapp_call_verification/start.php');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: YOUR-API-KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode(['number' => '923001234567']),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

if ($result['success']) {
    $id     = $result['data']['id'];       // save this
    $callTo = $result['data']['call_to'];  // show this to the user
} else {
    echo $result['error']['message'];
}
// Node.js 18+ (built-in fetch)
const res = await fetch('https://wa.sendpk.com/apps/whatsapp_call_verification/start.php', {
  method: 'POST',
  headers: {
    'Authorization': 'YOUR-API-KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ number: '923001234567' }),
});
const result = await res.json();

if (result.success) {
  const { id, call_to } = result.data;   // save id, show call_to
  console.log(id, call_to);
} else {
  console.log(result.error.message);
}
import requests

r = requests.post(
    "https://wa.sendpk.com/apps/whatsapp_call_verification/start.php",
    headers={"Authorization": "YOUR-API-KEY"},
    json={"number": "923001234567"},
    timeout=15,
)
result = r.json()

if result["success"]:
    request_id = result["data"]["id"]       # save this
    call_to = result["data"]["call_to"]     # show this to the user
else:
    print(result["error"]["message"])

Example Response

{
  "success": true,
  "data": {
    "id": "01a12ed2-1dff-7f6d-aa29-1240cf92c058",
    "status": "pending",
    "verified": false,
    "number": "+923001234567",
    "call_to": "+923356742000",
    "call_link": "https://wa.me/call/923356742000",
    "created_at": "2026-10-12T11:34:44+05:00",
    "expires_at": "2026-10-12T11:39:44+05:00",
    "expires_in": 300,
    "verified_at": null,
    "audio": "default",
    "price": { "amount": 1, "currency": "PKR", "charged": false, "charged_amount": 0 },
    "call": { "attempts": 0, "rejected": 0, "connected_seconds": null, "last_call_at": null },
    "error": null,
    "webhook": null
  },
  "meta": { "request_id": "01a12ed2-1e02-7c11-9b2a-3c4d5e6f7a8b" }
}
If the same number already has an open request on the same WhatsApp number, you get that request back with "reused": true. This also applies while a call is in progress. Keep the same Idempotency-Key when retrying.
GET

Check Status

GET https://wa.sendpk.com/apps/whatsapp_call_verification/status.php?id=REQUEST_ID

Returns the current state. Ask every 2–3 seconds while status is pending. It becomes verified the moment we pick up the call. Prefer not to keep asking? Use a webhook.

Example Request

curl 'https://wa.sendpk.com/apps/whatsapp_call_verification/status.php?id=01a12ed2-1dff-7f6d-aa29-1240cf92c058' \
  -H 'Authorization: YOUR-API-KEY'
<?php
$id = '01a12ed2-1dff-7f6d-aa29-1240cf92c058';

$ch = curl_init('https://wa.sendpk.com/apps/whatsapp_call_verification/status.php?id=' . urlencode($id));
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => ['Authorization: YOUR-API-KEY'],
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

if ($result['success'] && $result['data']['verified']) {
    // The number is verified - log the user in.
}
const id = '01a12ed2-1dff-7f6d-aa29-1240cf92c058';

const res = await fetch(`https://wa.sendpk.com/apps/whatsapp_call_verification/status.php?id=${encodeURIComponent(id)}`, {
  headers: { 'Authorization': 'YOUR-API-KEY' },
});
const result = await res.json();

if (result.success && result.data.verified) {
  // The number is verified - log the user in.
}
import requests

r = requests.get(
    "https://wa.sendpk.com/apps/whatsapp_call_verification/status.php",
    headers={"Authorization": "YOUR-API-KEY"},
    params={"id": "01a12ed2-1dff-7f6d-aa29-1240cf92c058"},
    timeout=15,
)
result = r.json()

if result["success"] and result["data"]["verified"]:
    pass  # The number is verified - log the user in.

Example Response — verified

{
  "success": true,
  "data": {
    "id": "01a12ed2-1dff-7f6d-aa29-1240cf92c058",
    "status": "verified",
    "verified": true,
    "number": "+923001234567",
    "call_to": "+923356742000",
    "call_link": "https://wa.me/call/923356742000",
    "created_at": "2026-10-12T11:34:44+05:00",
    "expires_at": "2026-10-12T11:39:44+05:00",
    "expires_in": 0,
    "verified_at": "2026-10-12T11:35:45+05:00",
    "audio": "default",
    "price": { "amount": 1, "currency": "PKR", "charged": true, "charged_amount": 1 },
    "call": { "attempts": 1, "rejected": 0, "connected_seconds": 6, "last_call_at": "2026-10-12T11:35:35+05:00" },
    "error": null,
    "webhook": {
      "url": "https://example.com/webhooks/whatsapp-call",
      "status": "sent",
      "last_event": "billing.charged",
      "delivered": 2,
      "last_http_code": 200,
      "last_try_at": "2026-10-12T11:35:47+05:00"
    }
  },
  "meta": { "request_id": "01a12ed3-0a11-7d22-8e33-4f5a6b7c8d9e" }
}

webhook is null when you did not send notification_callback. Otherwise its status is none (no event queued yet), pending (sending or waiting to retry), sent or failed.

If expires_in reaches 0, check status before starting again. A call already in progress can still finish. A request still waiting for a call becomes expired.

POST

Cancel

POST https://wa.sendpk.com/apps/whatsapp_call_verification/cancel.php

Stops a verification that is still waiting for a call and has not expired — for example when the user closes your page. Nothing is charged.

If a call is already in progress, cancellation returns REQUEST_IN_PROGRESS, even while Status shows pending. Check Status again. Cancelling the same cancelled request is safe; an expired or otherwise closed request returns REQUEST_ALREADY_TERMINATED.

curl -X POST 'https://wa.sendpk.com/apps/whatsapp_call_verification/cancel.php' \
  -H 'Authorization: YOUR-API-KEY' \
  -H 'Content-Type: application/json' \
  -d '{"id": "01a12ed2-1dff-7f6d-aa29-1240cf92c058"}'
<?php
$ch = curl_init('https://wa.sendpk.com/apps/whatsapp_call_verification/cancel.php');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => ['Authorization: YOUR-API-KEY', 'Content-Type: application/json'],
    CURLOPT_POSTFIELDS     => json_encode(['id' => '01a12ed2-1dff-7f6d-aa29-1240cf92c058']),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);
await fetch('https://wa.sendpk.com/apps/whatsapp_call_verification/cancel.php', {
  method: 'POST',
  headers: { 'Authorization': 'YOUR-API-KEY', 'Content-Type': 'application/json' },
  body: JSON.stringify({ id: '01a12ed2-1dff-7f6d-aa29-1240cf92c058' }),
});
import requests

requests.post(
    "https://wa.sendpk.com/apps/whatsapp_call_verification/cancel.php",
    headers={"Authorization": "YOUR-API-KEY"},
    json={"id": "01a12ed2-1dff-7f6d-aa29-1240cf92c058"},
    timeout=15,
)

Website Demo Tutorial

Download, paste your API key, upload — and verify your own number in a few minutes. No coding needed.

Try the live demoSee it working first: type your WhatsApp number and make one call.
Download Website Demo (ZIP)index.html · wa-call-verify.php · README.txt (the same guide as text)
  • A website with https:// and PHP 7.4+
  • Your API key
  • A WhatsApp number on your account with calling on
  • A phone with WhatsApp
PART A On your website — do this once
1

Download and unzip

Click Download Website Demo (ZIP) and unzip it. Inside: index.html (what your user sees), wa-call-verify.php (your key and settings) and README.txt.

2

Open wa-call-verify.php and fill in the settings

Any text editor works. All settings are at the top. The orange boxes show what to change.

Leave webhook_url empty and Automatic mode still works — the PHP file then asks the API at every check. api_base must be https://wa.sendpk.com/apps/whatsapp_call_verification/.

3

Upload both files into one folder

For example a folder called verify on your website:

4

Check the setup

Open https://your-domain.com/verify/wa-call-verify.php?action=ping. You want "ready": true. If not, the problems list says exactly what to fix — it even tests your webhook address. Testing? Set 'debug' => true to see the API's exact reply on errors (your key is never shown). Set it back to false before going live.

{
  "ok": true,
  "ready": true,
  "modes": ["auto", "manual"],
  "minutes": 5,
  "problems": [],
  "notes": []
}
PART B What your user does
5

Type the number and choose how to verify

Open https://your-domain.com/verify/index.html on your phone. 1 Type the number in international format, e.g. 923001234567. 2 Choose Automatic or With a Verify button (shown when verify_mode is both). Tap Start verification.

6

Tap “Call on WhatsApp” — the circle shows the time left

The circle fills up as the time passes (5 minutes by default). 1 Tap Call on WhatsApp: WhatsApp opens with a call to your business number. Call from the number you typed. We pick up, play a short message and hang up. On a computer, call the number shown using WhatsApp on your phone.

7

Automatic: the page verifies by itself

The page shows Waiting for your call…. The moment we pick up, the API sends a signed webhook to your webhook_url. Your PHP file checks the signature, then asks the API itself, and the page shows Number verified — normally 1–2 seconds after the pickup. If a webhook is ever lost, the PHP file still asks the API every 15 seconds. No webhook_url? It asks the API at every check instead, so the page still verifies by itself. How often the page checks is your choice: check_every_seconds (2–30, default 5).

8

Verify button: tap “I have called — Verify”

After the call, the user comes back to the page and taps I have called — Verify. Your PHP file asks the API. Not called yet? The page says so and the user can call and tap again. No webhook is needed.

9

Done! Save the number on your side

The page shows Number verified. At the same moment on_number_verified() in wa-call-verify.php runs — once, with the number the API confirmed. Put your own code there, for example to save the number to the user's account.

Why nobody can fake “verified”

Key stays on your serverThe page talks only to your PHP file. The API key is never sent to the browser or the phone.
Sealed ticketThe page gets an encrypted ticket (AES-256-GCM). Change one letter and it stops working. It only works in the browser that started it.
Signed webhooksA webhook needs a valid X-SENDPK-Signature made with your API key, your secret t=, the API's server IP and a fresh time. A fake, changed or replayed one is refused.
Always double-checkedEven a real webhook only wakes the PHP file up: it asks the API itself and checks it is the same request and the same number.
The right caller onlyWhatsApp tells us who is calling. A call from any other number does not count.
Limits built inPer-number and per-visitor limits, and pages on other websites cannot use your PHP file.
Mobile app? Your Android or iPhone app can use the same PHP file: send the same start, check and cancel requests as index.html. See README.txt.

Your Own Message

Want your own voice and words? Send audio_url with start.php.

{
  "number": "923001234567",
  "audio_url": "https://example.com/audio/welcome.mp3"
}
RuleValue
Linkhttps:// only, a public address, max 500 characters
FormatMP3, WAV or OGG
SizeUp to 1 MB
LengthAt most 30 seconds are played. Short is better: 3–6 seconds.

We download the file once when you call start.php and reuse it for an hour, so a bad link fails right away (AUDIO_DOWNLOAD_FAILED, AUDIO_TOO_LARGE or AUDIO_FORMAT_NOT_SUPPORTED) and nothing is charged.

Calls Without a Request

What happens when someone calls your WhatsApp number but you did not start a verification for them?

Account settingCaller with a waiting requestAnyone else
All calls defaultAnswered and verifiedHears a short “not verified” message, then the call ends. Nothing is charged.
Verification calls onlyAnswered and verifiedGoes to your normal call handling
  • One request verifies once. To verify the same number again later (for example after logout), start a new request.
  • With All calls, a call just after the person's request expired is declined. With Verification calls only, it follows your normal call handling.
  • Your WhatsApp number also takes ordinary customer calls? Ask us to switch your account to Verification calls only.

Safe Retries

Network timeout? Within 24 hours, send the same request again with the same Idempotency-Key to get the same verification back.

curl -X POST 'https://wa.sendpk.com/apps/whatsapp_call_verification/start.php' \
  -H 'Authorization: YOUR-API-KEY' \
  -H 'Content-Type: application/json' \
  -H 'Idempotency-Key: login-7f3a9c' \
  -d '{"number": "923001234567"}'

The key can be 1–100 visible ASCII characters, without spaces, and is remembered for 24 hours. The same key with a different body returns IDEMPOTENCY_CONFLICT.

An open request can hold one key. If it has no key yet, a retry can attach one. Trying to attach a different key to an already keyed request returns IDEMPOTENCY_CONFLICT. Keep the key for retries of that request; use a new key for a new verification.

For SERVICE_BUSY, SERVICE_UNAVAILABLE or a network timeout, keep the same body and key. Wait before retrying, and follow Retry-After when present.

Webhooks

Send notification_callback with start.php to receive updates, normally within 1–2 seconds of a change.

{
  "number": "923001234567",
  "notification_callback": "https://example.com/webhooks/whatsapp-call"
}

Events

eventWhen
verification.verifiedWe picked up the call. The number is verified.
verification.call_failedA call did not count (for example it did not connect). The request is still open — the user can call again. data.error says why.
verification.failedClosed: 3 calls did not connect, or time ran out while calling.
verification.expiredThe request timed out while waiting for a call.
verification.cancelledYou cancelled the request.
billing.chargedQueued after the verification.verified delivery attempts, once billing finishes. Check data.price.charged and data.price.charged_amount for a full or partial charge.

Your webhook URL must be

RuleValue
Linkhttps:// only, max 500 characters
Port443 or 8443
AddressA public internet address (no localhost, no private network)
Our domainsA webhook may not point back at this website.

What we send

POST /webhooks/whatsapp-call HTTP/1.1
Host: example.com
Content-Type: application/json
User-Agent: SENDPK-Webhook/1.0
X-SENDPK-Event: verification.verified
X-SENDPK-Event-Id: 3f2b1c0d-9e8f-5a7b-8c6d-5e4f3a2b1c0d
X-SENDPK-Signature: sha256=<hex HMAC-SHA256 of the raw body>

{
  "event": "verification.verified",
  "event_id": "3f2b1c0d-9e8f-5a7b-8c6d-5e4f3a2b1c0d",
  "created_at": "2026-10-12T11:35:46+05:00",
  "data": {
    "id": "01a12ed2-1dff-7f6d-aa29-1240cf92c058",
    "status": "verified",
    "verified": true,
    "number": "+923001234567",
    ...the other fields of Check Status
  }
}

data has the same fields as Check Status, except for the webhook block.

Repeating Start for an open request with a new notification_callback replaces its callback URL. A completed request's callback URL cannot be changed. When using an Idempotency-Key, changing the body returns IDEMPOTENCY_CONFLICT.

Your answer

  • Reply with any 2xx status within 5 seconds. Do the slow work after you reply.
  • For timeouts, network errors, 408, 429 and 5xx, we make at most 3 attempts: the first delivery, a retry 1 minute after failure, then another 5 minutes after that failure. Other 4xx answers and redirects are not retried.
RepeatsThe same webhook can arrive more than once. Use event_id to skip repeats — it stays the same for the same event.
Always currentEvery webhook carries the current state of the request. If two things happen in the same second, you may get only the newest one.
A webhook is a quick heads-up. If one is ever missed, Check Status always has the answer.

Webhook Security

The signature proves the webhook came from us and was not changed on the way.

We sign the raw body with HMAC-SHA256, using your API key as the secret, and send it in the X-SENDPK-Signature header. Your server does the same calculation and compares. Read the raw body before parsing the JSON.

<?php
// https://example.com/webhooks/whatsapp-call
$raw      = file_get_contents('php://input');
$expected = 'sha256=' . hash_hmac('sha256', $raw, 'YOUR-API-KEY');
$given    = $_SERVER['HTTP_X_SENDPK_SIGNATURE'] ?? '';

if (!hash_equals($expected, $given)) {
    http_response_code(401);
    exit;
}

$event = json_decode($raw, true);

// Skip repeats: remember $event['event_id'] for a day.
if ($event['event'] === 'verification.verified') {
    $requestId = $event['data']['id'];       // your saved request id
    $number    = $event['data']['number'];   // this number is verified
}
http_response_code(200);
// Express - keep the raw body for the signature check
const crypto = require('crypto');
const express = require('express');
const app = express();

app.post('/webhooks/whatsapp-call', express.raw({ type: 'application/json' }), (req, res) => {
  const expected = 'sha256=' + crypto.createHmac('sha256', 'YOUR-API-KEY').update(req.body).digest('hex');
  const given = req.get('X-SENDPK-Signature') || '';

  if (given.length !== expected.length ||
      !crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(given))) {
    return res.sendStatus(401);
  }

  const event = JSON.parse(req.body.toString('utf8'));
  res.sendStatus(200);                 // answer first

  if (event.event === 'verification.verified') {
    console.log('verified', event.data.id, event.data.number);
  }
});
# Flask
import hashlib, hmac, json
from flask import Flask, request

app = Flask(__name__)

@app.post("/webhooks/whatsapp-call")
def whatsapp_call_webhook():
    raw = request.get_data()
    expected = "sha256=" + hmac.new(b"YOUR-API-KEY", raw, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(expected, request.headers.get("X-SENDPK-Signature", "")):
        return "", 401

    event = json.loads(raw)
    if event["event"] == "verification.verified":
        print("verified", event["data"]["id"], event["data"]["number"])
    return "", 200
  • Check that data.id is a request you started.
  • Changed your API key? Every subsequent delivery attempt, including retries, uses the current key.

Statuses

statusMeaning
pendingWaiting for a call or its result.
verifiedDone. The right number called and we picked up the call. verified_at is set.
failed3 calls did not connect, or time ran out while calling.
expiredThe request timed out while waiting for a call.
cancelledYou cancelled it.

Every request also shows in your dashboard: Call Verification. It updates live and shows the calls, the charge and the webhook of each request, with charts and CSV, Excel or PDF downloads.

Call Problems

While a request is still open, error can explain why the last call did not count. The user can simply call again.

error.codeMeaning
CALL_NOT_CONNECTEDThe call did not connect (hung up early, weak network).
CALL_NOT_CONFIRMEDWhatsApp never confirmed the call.
MEDIA_UNAVAILABLEThe call could not be answered at that moment.
REQUEST_EXPIREDThe call came after the 5 minutes.
TOO_MANY_CALLS3 calls were already tried for this request.
NO_ACCESS_TOKEN / ACCOUNT_CHANGEDYour WhatsApp number is not connected correctly. Please contact support.

Error Codes

When success is false, read error.code.

HTTPerror.codeWhen
401AUTH_MISSING · AUTH_INVALIDNo API key, or a wrong one.
403ACCOUNT_DISABLEDYour account or its administrator is blocked.
403HTTPS_REQUIREDPlain http:// was used.
400INVALID_JSON · INVALID_IDEMPOTENCY_KEYThe body or a header could not be read.
415INVALID_CONTENT_TYPEContent-Type is not application/json.
422MISSING_NUMBER · INVALID_NUMBERThe number is missing or not valid (or it is your own WhatsApp number).
422INVALID_WHATSAPP_ID · NO_WHATSAPP_NUMBERNo such active WhatsApp number on your account.
422INVALID_AUDIO_URL · AUDIO_DOWNLOAD_FAILED · AUDIO_TOO_LARGE · AUDIO_FORMAT_NOT_SUPPORTEDA problem with audio_url.
422INVALID_EXPIRES_INexpires_in is not a whole number from 60 to 300.
422INVALID_CALLBACK_URLnotification_callback is not a public https link on port 443 or 8443.
422MISSING_ID · INVALID_IDThe request id is missing or wrong.
402INSUFFICIENT_BALANCEYour balance is lower than the price of one verification.
429RATE_LIMIT_EXCEEDED · OPEN_LIMIT_REACHED · NUMBER_DAILY_LIMIT_REACHEDA limit was reached. Wait and try again (see the Retry-After header).
404REQUEST_NOT_FOUNDNo such request on your account.
409IDEMPOTENCY_CONFLICT · REQUEST_IN_PROGRESS · REQUEST_ALREADY_TERMINATEDThe request is in a state that does not allow this.
503SERVICE_UNAVAILABLE · SERVICE_BUSYThe service is temporarily unavailable or busy. Wait before retrying, follow Retry-After when present, and keep the same Idempotency-Key for Start.

Limits

LimitValue
Time to call5 minutes per request (1–5 minutes with expires_in)
Calls per request3
New requests60 per minute per account, across all numbers
Open at the same time200 per account, including calls in progress
Same number10 requests per day

Billing

You pay only for successful verifications. Expired, failed and cancelled requests are free, and so is a “not verified” call.

  • When you start a request, your balance only has to cover one verification — nothing is taken yet.
  • Verification succeeds when the call is picked up. Billing follows and may finish later; a verified number stays verified while its charge is processing.
  • price.amount is the agreed price. price.charged becomes true when it is paid in full. price.charged_amount shows the amount actually taken.
  • Starting a request does not reserve balance. If other activity uses it first, the charge may be partial. Use verified for the verification result and the price fields for billing. A free verification has an amount of 0 and needs no debit.

Postman Collection

Try every request without writing code.

Download Postman CollectionWhatsApp-Call-Verification.postman_collection.json
  1. In Postman, click Import and choose the downloaded file.
  2. Open the collection, go to Variables, and fill in api_key and number.
  3. Set base_url to https://wa.sendpk.com/apps/whatsapp_call_verification.
  4. Run 1. Start verification — the id is saved for you. Call the number, then run 2. Check status.

Support

Need help? We're here.

Chat with us on WhatsAppSales & support: 923001654321
WhatsApp Business APISend template and free-form messages