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.
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.
How It Works
Five steps, one WhatsApp call — about 10 seconds from start to “verified”.
- 1 Your app
You start a verification
Number to verify +92 300 1234567 - 2 Their phone
They tap Call on WhatsApp
Call on WhatsApp The call goes to your WhatsApp number, from the number being verified. - 3 We answer
WhatsApp tells us who is calling
Incoming WhatsApp call +92 300 1234567 Same number as the request - 4 Short message
We play a message and hang up
“Your phone number has been verified. Thank you.” - 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.
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 Demoindex.html, wa-call-verify.php, README.txt
Authentication
Send your API key in the Authorization header of every request.
Authorization: YOUR-API-KEYAuthorization: Bearer YOUR-API-KEY works too. The key is never accepted in the URL or the body.
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.
| Endpoint | Method | What it does |
|---|---|---|
| start.php | POST | Start a verification for one number |
| status.php?id= | GET | Read the current state of a verification |
| cancel.php | POST | Cancel 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.
Start a Verification
Creates a verification for one number. The user then has 5 minutes to call.
Body (JSON)
| Field | Required | Description |
|---|---|---|
| number* | Yes | The number to verify, in international format: country code + number, e.g. 923001234567. (+923001234567 and the local 03001234567 are also accepted.) |
| whatsapp_id | No | Which of your WhatsApp numbers the user should call (its ID). Default: your first active number. |
| audio_url | No | Your own message to play, as a link. See Your Own Message. Default: our standard message. |
| expires_in | No | Seconds the user has to call: 60 to 300. Default: 300 (5 minutes). |
| notification_callback | No | Your 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" }
}"reused": true. This also applies while a call is in progress. Keep the same Idempotency-Key when retrying.Check Status
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.
Cancel
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.
- A website with
https://and PHP 7.4+ - Your API key
- A WhatsApp number on your account with calling on
- A phone with WhatsApp
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.
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.
$WCV_CONFIG = [ 'api_key' => 'PASTE_YOUR_API_KEY_HERE', 1 Your API key (Dashboard → Profile → API Key) 'verify_mode' => 'both', 2 'auto', 'manual' or 'both' (the user chooses) 'webhook_url' => 'https://your-domain.com/verify/wa-call-verify.php?action=webhook&t=LONG-RANDOM-SECRET', 'webhook_allowed_ips' => ['188.245.210.139'], 3 Optional (instant): this file's address + a secret, and the API's server IP only 'time_limit_minutes' => 5, 4 Time to call: 1 to 5 minutes (default 5) 'check_every_seconds' => 5, 5 How often the page checks: 2 to 30 seconds (default 5) ... 'api_base' => 'https://wa.sendpk.com/apps/whatsapp_call_verification/', ];
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/.
Upload both files into one folder
For example a folder called verify on your website:
public_html/ └── verify/ ├── index.html └── wa-call-verify.php 1 Both files in the same folder
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": []
}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.
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.
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).
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.
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.
+92 300 1234567
Why nobody can fake “verified”
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.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"
}| Rule | Value |
|---|---|
| Link | https:// only, a public address, max 500 characters |
| Format | MP3, WAV or OGG |
| Size | Up to 1 MB |
| Length | At 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 setting | Caller with a waiting request | Anyone else |
|---|---|---|
| All calls default | Answered and verified | Hears a short “not verified” message, then the call ends. Nothing is charged. |
| Verification calls only | Answered and verified | Goes 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
| event | When |
|---|---|
| verification.verified | We picked up the call. The number is verified. |
| verification.call_failed | A 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.failed | Closed: 3 calls did not connect, or time ran out while calling. |
| verification.expired | The request timed out while waiting for a call. |
| verification.cancelled | You cancelled the request. |
| billing.charged | Queued 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
| Rule | Value |
|---|---|
| Link | https:// only, max 500 characters |
| Port | 443 or 8443 |
| Address | A public internet address (no localhost, no private network) |
| Our domains | A 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.
| Repeats | The same webhook can arrive more than once. Use event_id to skip repeats — it stays the same for the same event. |
| Always current | Every webhook carries the current state of the request. If two things happen in the same second, you may get only the newest one. |
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.idis a request you started. - Changed your API key? Every subsequent delivery attempt, including retries, uses the current key.
Statuses
| status | Meaning |
|---|---|
| pending | Waiting for a call or its result. |
| verified | Done. The right number called and we picked up the call. verified_at is set. |
| failed | 3 calls did not connect, or time ran out while calling. |
| expired | The request timed out while waiting for a call. |
| cancelled | You 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.code | Meaning |
|---|---|
| CALL_NOT_CONNECTED | The call did not connect (hung up early, weak network). |
| CALL_NOT_CONFIRMED | WhatsApp never confirmed the call. |
| MEDIA_UNAVAILABLE | The call could not be answered at that moment. |
| REQUEST_EXPIRED | The call came after the 5 minutes. |
| TOO_MANY_CALLS | 3 calls were already tried for this request. |
| NO_ACCESS_TOKEN / ACCOUNT_CHANGED | Your WhatsApp number is not connected correctly. Please contact support. |
Error Codes
When success is false, read error.code.
| HTTP | error.code | When |
|---|---|---|
| 401 | AUTH_MISSING · AUTH_INVALID | No API key, or a wrong one. |
| 403 | ACCOUNT_DISABLED | Your account or its administrator is blocked. |
| 403 | HTTPS_REQUIRED | Plain http:// was used. |
| 400 | INVALID_JSON · INVALID_IDEMPOTENCY_KEY | The body or a header could not be read. |
| 415 | INVALID_CONTENT_TYPE | Content-Type is not application/json. |
| 422 | MISSING_NUMBER · INVALID_NUMBER | The number is missing or not valid (or it is your own WhatsApp number). |
| 422 | INVALID_WHATSAPP_ID · NO_WHATSAPP_NUMBER | No such active WhatsApp number on your account. |
| 422 | INVALID_AUDIO_URL · AUDIO_DOWNLOAD_FAILED · AUDIO_TOO_LARGE · AUDIO_FORMAT_NOT_SUPPORTED | A problem with audio_url. |
| 422 | INVALID_EXPIRES_IN | expires_in is not a whole number from 60 to 300. |
| 422 | INVALID_CALLBACK_URL | notification_callback is not a public https link on port 443 or 8443. |
| 422 | MISSING_ID · INVALID_ID | The request id is missing or wrong. |
| 402 | INSUFFICIENT_BALANCE | Your balance is lower than the price of one verification. |
| 429 | RATE_LIMIT_EXCEEDED · OPEN_LIMIT_REACHED · NUMBER_DAILY_LIMIT_REACHED | A limit was reached. Wait and try again (see the Retry-After header). |
| 404 | REQUEST_NOT_FOUND | No such request on your account. |
| 409 | IDEMPOTENCY_CONFLICT · REQUEST_IN_PROGRESS · REQUEST_ALREADY_TERMINATED | The request is in a state that does not allow this. |
| 503 | SERVICE_UNAVAILABLE · SERVICE_BUSY | The service is temporarily unavailable or busy. Wait before retrying, follow Retry-After when present, and keep the same Idempotency-Key for Start. |
Limits
| Limit | Value |
|---|---|
| Time to call | 5 minutes per request (1–5 minutes with expires_in) |
| Calls per request | 3 |
| New requests | 60 per minute per account, across all numbers |
| Open at the same time | 200 per account, including calls in progress |
| Same number | 10 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.amountis the agreed price.price.chargedbecomestruewhen it is paid in full.price.charged_amountshows the amount actually taken.- Starting a request does not reserve balance. If other activity uses it first, the charge may be partial. Use
verifiedfor the verification result and thepricefields for billing. A free verification has an amount of 0 and needs no debit.
Postman Collection
Try every request without writing code.
- In Postman, click Import and choose the downloaded file.
- Open the collection, go to Variables, and fill in
api_keyandnumber. - Set
base_urltohttps://wa.sendpk.com/apps/whatsapp_call_verification. - Run 1. Start verification — the
idis saved for you. Call the number, then run 2. Check status.
Support
Need help? We're here.