← Back to Blog

Fixing Meta WhatsApp Cloud API Webhook Event Drops, Rate Limits & OTP Delays


BLUF: During high-concurrency retail campaigns, delays in WhatsApp OTP and notification delivery can increase user drop-off. Coupling webhook endpoints directly to synchronous database queries risks request backpressure, causing Meta to retry events and creating queue backlogs. Decoupling ingest with an asynchronous message queue (such as Redis BullMQ) ensures immediate HTTP 200 acknowledgments, protects backend services from spikes, and isolates background event processing.

Production Symptoms Under High-Traffic Conditions

During concentrated traffic bursts across e-commerce platforms, unoptimized webhook handlers exhibit noticeable friction:

  • Notification delays: Outgoing queues back up when webhook delivery confirmations compete with transactional workflows.
  • HTTP 504 timeouts & event re-delivery: Inbound webhooks for status updates (sent, delivered, read) get blocked behind slow SQL queries, prompting Meta to re-send events.
  • Sender reputation risk: Unhandled message duplicates can result in spam complaints and degraded quality ratings.

Root Cause Analysis: Synchronous Webhook Processing

Meta requires incoming webhook endpoints to acknowledge receipt promptly with an HTTP 200. When an application attempts to parse payloads, run database writes, and trigger third-party APIs inside the synchronous request thread, server worker pools exhaust under sustained load. The receiving endpoint stalls and backpressure propagates upstream.

Illustrative TypeScript Implementation (Not Production-Tested)

Engineering Disclaimer: The following code is an illustrative prototype demonstrating event loop decoupling and signature validation. It is not a complete, production-tested service. In production, configure persistent Redis brokers, dead-letter queues (DLQ), and monitor against Meta's official webhook guidelines.

import crypto from 'node:crypto';
import express, { Request, Response } from 'express';
import { Queue } from 'bullmq';

const app = express();
const messageQueue = new Queue('whatsapp-inbound-messages', { connection: { host: '127.0.0.1', port: 6379 } });
const statusQueue = new Queue('whatsapp-status-events', { connection: { host: '127.0.0.1', port: 6379 } });

// 1. Secure HMAC signature validation with length check to prevent timingSafeEqual RangeError
function verifyMetaSignature(req: Request, appSecret: string): boolean {
  const signatureHeader = req.headers['x-hub-signature-256'] as string | undefined;
  if (!signatureHeader || !signatureHeader.startsWith('sha256=')) return false;

  const hmac = crypto.createHmac('sha256', appSecret);
  const expectedSignature = 'sha256=' + hmac.update(req.body).digest('hex');

  const sigBuffer = Buffer.from(signatureHeader, 'utf8');
  const expectedBuffer = Buffer.from(expectedSignature, 'utf8');

  if (sigBuffer.byteLength !== expectedBuffer.byteLength) {
    return false;
  }

  return crypto.timingSafeEqual(sigBuffer, expectedBuffer);
}

// 2. Immediate Webhook Ingest Endpoint (Acknowledge before processing)
app.post('/api/webhooks/whatsapp', express.raw({ type: 'application/json' }), async (req: Request, res: Response) => {
  if (!verifyMetaSignature(req, process.env.META_APP_SECRET || '')) {
    return res.status(403).send('Invalid Signature');
  }

  // Acknowledge HTTP 200 immediately to Meta to avoid retry floods
  res.status(200).send('EVENT_RECEIVED');

  try {
    const payload = JSON.parse(req.body.toString('utf8'));

    // Iterate through all entries and changes without dropping batched events
    for (const entry of payload.entry || []) {
      for (const change of entry.changes || []) {
        const val = change.value;
        if (!val) continue;

        if (Array.isArray(val.messages)) {
          for (const msg of val.messages) {
            await messageQueue.add('inbound_message', {
              metadata: val.metadata,
              contact: val.contacts?.[0],
              message: msg,
            }, { priority: 1, attempts: 3, removeOnComplete: 1000 });
          }
        }

        if (Array.isArray(val.statuses)) {
          for (const status of val.statuses) {
            await statusQueue.add('delivery_status', {
              metadata: val.metadata,
              status,
            }, { priority: 10, removeOnComplete: true });
          }
        }
      }
    }
  } catch (err) {
    console.error('Error queuing webhook payload:', err);
  }
});

Operational Metrics & Example Internal SLOs

The following metrics represent example operational SLOs for your internal Prometheus and Grafana dashboards:

  • whatsapp_webhook_ack_duration_seconds < 0.05 (Example SLO): Webhook acknowledgment target to prevent upstream retry cascades.
  • whatsapp_queue_lag == 0 (Example SLO): Background processing queue lag monitoring.

Commercial Engineering & Platform Infrastructure Advisory

Need hands-on senior engineering to audit, scale, or stabilize your infrastructure?

From bare-metal Kubernetes and immutable Talos Linux to drastically cutting cloud infrastructure bills, resolving PostgreSQL deadlocks, and architecting sovereign AI systems, I work directly with production engineering teams to deliver resilient foundations.

View Consulting Disciplines & Services Pricing & Engagement Models 💬 WhatsApp (+212 697 720 221)
Regional Hubs:Casablanca · Morocco•Riyadh · KSA•Dubai · UAE•Doha · Qatar•Manama · Bahrain•Muscat · Oman•Remote · Worldwide•Self-Hosted n8n•Cloud Cost Reduction