Validate a WhatsApp number via API: how to know if a number has WhatsApp

Format: does the number have a country code, a valid area code and the right digit count? It is a text rule that runs in your browser or server without asking anyone. The free WhatsApp number validator and the bulk formatter do this, including the ninth digit of Brazilian mobiles.

Existence: is that number, even if well formed, registered on WhatsApp right now? Only a query to WhatsApp answers it. That is why the format tool warns that it does not confirm the account exists, and the check comes through the API.

In the ZapZap API, the endpoint is POST /api/v1/{instanceId}/chat/check, with the numbers field as a list. The answer carries, for each queried number, the query field (what you sent), isInWhatsapp (true or false) and jid (the conversation identifier). The full description is in the endpoint reference.

Send the number in the same format as sending: country code and digits only. Check the answer format with two numbers of your own before wiring this into your flow.

# Does this number have WhatsApp?
curl -X POST "https://api.zapzapapi.com/api/v1/$ZAPZAP_INSTANCE/chat/check" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $ZAPZAP_API_KEY" -H "x-api-secret: $ZAPZAP_API_SECRET" \
  -d '{"numbers":["5511999999999","5521888888888"]}'
# Each item of the answer carries: query, isInWhatsapp (true/false) and jid

The example normalizes the format (digits only, country code 55 when missing, dropping what cannot be a Brazilian number), removes duplicates, queries in small batches with a pause and returns only those with WhatsApp. The result feeds the next send and reduces errors.

The normalization rule is simple on purpose. For edge cases, such as the ninth digit on older numbers, use the site formatter as a reference.

// Validate a small batch before sending, keep only numbers that exist
const API = "https://api.zapzapapi.com/api/v1/" + process.env.ZAPZAP_INSTANCE;
const headers = {
  "Content-Type": "application/json",
  "x-api-key": process.env.ZAPZAP_API_KEY,
  "x-api-secret": process.env.ZAPZAP_API_SECRET,
};

export function normalizeBr(raw) {
  // 1) digits only, 2) add country code 55 when missing, 3) reject what cannot be a Brazilian number
  let d = String(raw).replace(/\D/g, "");
  if (d.length === 10 || d.length === 11) d = "55" + d;
  return /^55\d{10,11}$/.test(d) ? d : null;
}

export async function filterWhatsApp(rawNumbers) {
  const numbers = [...new Set(rawNumbers.map(normalizeBr).filter(Boolean))];
  const ok = [];
  for (let i = 0; i < numbers.length; i += 20) {           // small batches
    const batch = numbers.slice(i, i + 20);
    const r = await fetch(API + "/chat/check", { method: "POST", headers, body: JSON.stringify({ numbers: batch }) });
    if (!r.ok) throw new Error("check failed: HTTP " + r.status);
    const items = await r.json();
    for (const it of items) if (it.isInWhatsapp) ok.push({ number: it.query, jid: it.jid });
    await new Promise((res) => setTimeout(res, 3000 + Math.random() * 4000)); // pause between batches
  }
  return ok;
}

Querying thousands of numbers at once, in a burst, is an unusual behavior pattern. We have no published limit for this endpoint, so the prudent advice is the same as for sending: small batches, a pause between them and nothing in parallel. If your list is large, validate the format first (free, local) and only query existence for those that passed.

Store the result with the query date. A number that had WhatsApp today may not tomorrow, and a number without WhatsApp may be created later. And remember that having WhatsApp does not mean consenting to receive your message: see LGPD on WhatsApp.

The most useful point is sign-up: validate when the lead types the phone and warn right away if the number has no WhatsApp, instead of finding out at send time. The second is cleaning an old list before reactivating it. In both, combine it with warm-up and gradual volume.

If you use n8n, the endpoint fits in an HTTP Request node before the send node. The guide to WhatsApp in n8n shows the flow design.