How to Bulk-Verify WhatsApp Numbers (Up to 10 per Request)

Validating phone numbers one API call at a time is fine for a single sign-up, but it is the wrong tool when you need to clean a list of thousands of leads. Bulk validation lets you check many numbers per request, cutting both the wall-clock time and the number of HTTP calls you make.

This guide covers the batch-check-10 operation, which verifies up to 10 WhatsApp numbers in a single request, and shows a Python script that processes a whole file safely: deduplicated, retried, and resumable.

Why bulk validation matters

• Speed. Ten numbers per call means roughly ten times fewer round trips for the same list.
• Simpler rate management. Fewer requests to schedule, pace and retry.
• Cleaner pipelines. One call returns a result for each number in the batch, ready to stream into a database or a CSV.

Step 1: Get an API key

Sign up and copy an active key from your Dashboard. Free credits are included, so you can test on a small file first.

Step 2: Make a batch request

Pass a comma-separated list of full international numbers in the accounts parameter:

curl "https://api.opendata-api.com/api/project/whatsapp/batch-check-10?key=YOUR_API_KEY&accounts=15551234567,15557654321,442071234567"

The reply reports, for each number in the batch, whether it is on WhatsApp and whether it is a business account. The business information is a free by-product, handy for segmenting a list into consumers and businesses in the same pass.

Step 3: Scale to a full list with Python

Split the list into groups of 10, call the operation once per group and write everything to disk as you go. The script below deduplicates first, retries a failed group with backoff, and writes one JSON line per batch so an interrupted run can resume without redoing finished work.

import json
import os
import time
import requests

API_KEY = "YOUR_API_KEY"
URL = "https://api.opendata-api.com/api/project/whatsapp/batch-check-10"
OUT = "whatsapp_results.jsonl"


def chunks(items, size=10):
    for i in range(0, len(items), size):
        yield items[i:i + size]


def load_done():
    done = set()
    if os.path.exists(OUT):
        with open(OUT) as fh:
            for line in fh:
                done.update(json.loads(line)["requested"])
    return done


def check_batch(batch, attempts=4):
    for attempt in range(attempts):
        try:
            resp = requests.get(
                URL,
                params={"key": API_KEY, "accounts": ",".join(batch)},
                timeout=60,
            )
            resp.raise_for_status()
            body = resp.json()
            # A reply can be wrapped more than once as {"code": ..., "data": {...}}
            while isinstance(body, dict) and "code" in body and isinstance(body.get("data"), (dict, list)):
                body = body["data"]
            return body
        except (requests.RequestException, ValueError):
            time.sleep(2 ** attempt)   # 1s, 2s, 4s, 8s
    return None


def run(numbers):
    unique = sorted({n.strip() for n in numbers if n.strip()})
    done = load_done()
    todo = [n for n in unique if n not in done]
    failed = []
    with open(OUT, "a") as out:
        for batch in chunks(todo):
            result = check_batch(batch)
            if result is None:
                failed.extend(batch)
                continue
            out.write(json.dumps({"requested": batch, "result": result}) + "\n")
            out.flush()
    return failed


numbers = [line.strip() for line in open("numbers.txt")]
print("still to retry:", run(numbers))

A few details are worth copying into your own version:

• The requested list is stored next to the raw result. You can always reconcile what you asked with what came back, and the script does not depend on how the per-number results are laid out inside the reply.
• flush() after every batch. If the process dies, at most one batch is repeated.
• Failures are returned, not swallowed. Re-run the script and only the numbers without a stored result are sent again.

Tips to save credits and time

• Deduplicate first. Remove duplicate numbers so you never check the same one twice.
• Normalize before batching. Keep digits and the country code, and drop values that are clearly not phone numbers.
• Store results. Keep each result with a timestamp and re-verify on a schedule, such as monthly, rather than before every campaign.
• Handle failures gracefully. Retry failed groups with backoff, and log numbers that keep failing so you can re-run just those.
• Pace yourself. Start with sequential requests, measure, and only add parallel workers if your volume needs it.
• Enrich only what remains. After cleaning, run profile lookups for the numbers that passed. See the WhatsApp number lookup guide.

Single vs. batch

If you are validating a number in a live sign-up form, use the single-number check-exist-by-phone or the quick check-active. Both avoid waiting for ten numbers to accumulate. For offline list cleaning, use batch-check-10 for throughput. The walkthrough for a single number, including the three-state isExist result, is in how to check if a number is on WhatsApp.

Bulk checks across channels

A number that is not on WhatsApp may still be reachable elsewhere. The cleaned list is a good starting point for the lead verification workflow, which sends the leftovers through Telegram, Viber and Signal checks. If your audience also uses Snapchat, see how Snapchat number lookup handles batches.

FAQ

How many numbers can I check in one request? Up to 10 with batch-check-10. Pass them as a comma-separated list in the accounts parameter. For longer lists, split them into groups of 10 and loop.

What does each result contain? For each number, the reply reports whether it is on WhatsApp and whether it is a business account.

What should I do when a batch request fails? Retry it with exponential backoff, and if it keeps failing, log its numbers so you can re-run only those. The script above returns the failed numbers and skips finished batches on the next run.

Should I use bulk or single checks for a sign-up form? Use a single check. check-exist-by-phone or check-active answer for one number immediately, while batches are meant for offline cleaning of larger lists.

How often should I re-verify a list? Pick a schedule that matches how quickly your list changes, for example monthly for active lists, and re-check sooner for numbers you are about to use for something important.

Try it

Test a batch interactively on the WhatsApp Number Validation page or read the batch-check-10 reference. See pricing to estimate the credit cost for your list size.