Webhooks Vs Polling

title: "Webhooks vs Polling" description: "Compare webhooks and polling approaches for data synchronization, understand trade-offs in latency, efficiency, and complexity." weight: 12 date: 2026-06-28 lastmod: 2026-06-28 tags: ["apis", "webhooks"]

Webhooks and polling are two approaches for receiving updates from external systems. Understanding their trade-offs helps you choose the right strategy for each integration.

## What You'll Learn

- How polling works and its limitations
- How webhooks improve on polling
- Latency and resource comparison
- Hybrid approaches
- When to use each method

## Why It Matters

Choosing between webhooks and polling affects your system's latency, resource usage, and complexity. The wrong choice leads to unnecessary load or delayed updates.

## Real-World Use

A logistics company originally polled a shipping API every 5 minutes for status updates, causing 288 unnecessary requests per day per shipment. Switching to webhooks reduced API calls by 99% and provided real-time tracking updates.

## Flow Chart

```mermaid
flowchart LR
    A[Polling] --> B[Client asks every N seconds]
    B --> C[Server responds always]
    C --> D[Many wasted requests]
    
    E[Webhooks] --> F[Server notifies on event]
    F --> G[Client receives only when data changes]
    G --> H[Fewer requests, real-time]

Code Examples

Example 1: Polling Implementation

// Client-side polling
async function pollForUpdates() {
  const pollInterval = 5000; // 5 seconds
  let lastCheck = null;

  setInterval(async () => {
    try {
      const url = lastCheck
        ? `/api/updates?since=${lastCheck}`
        : '/api/updates';

      const response = await fetch(url);
      const updates = await response.json();

      if (updates.length > 0) {
        console.log(`Received ${updates.length} updates`);
        updates.forEach(processUpdate);
        lastCheck = updates[updates.length - 1].timestamp;
      }
    } catch (error) {
      console.error('Polling failed:', error.message);
    }
  }, pollInterval);
}

// Server-side polling endpoint
app.get('/api/updates', (req, res) => {
  const since = req.query.since 
    ? new Date(req.query.since) 
    : new Date(0);

  const updates = getUpdatesSince(since);
  res.json(updates);
});

Expected output: Client polls every 5 seconds, most responses contain no new data (wasted requests).

Example 2: Webhook Implementation

// Provider sends webhook on events
app.post('/api/orders', (req, res) => {
  const order = createOrder(req.body);
  
  // Send webhook to registered consumers
  webhookService.send('order.created', {
    id: order.id,
    status: order.status,
    customer: order.customerId,
    total: order.total,
  });

  res.status(201).json(order);
});

// Consumer receives webhook
app.post('/webhooks/order-created', (req, res) => {
  const webhook = req.body;
  
  // Process the order update immediately
  processOrderUpdate(webhook.data);
  
  res.status(200).end(); // Acknowledge immediately
});

Expected output: Consumer receives order updates within seconds of creation, with no polling overhead.

Example 3: Hybrid Approach with Fallback

class HybridUpdateService {
  constructor() {
    this.lastUpdate = null;
    this.pollInterval = 30000; // 30 second fallback
    this.connected = false;
    this.initWebhook();
    this.initPollFallback();
  }

  initWebhook() {
    // Primary: webhook endpoint
    app.post('/webhooks/updates', (req, res) => {
      const updates = req.body;
      this.lastUpdate = Date.now();
      this.processUpdates(updates);
      res.status(200).end();
    });
  }

  initPollFallback() {
    // Fallback: poll when webhook is not working
    setInterval(() => {
      if (this.lastUpdate && Date.now() - this.lastUpdate > 60000) {
        // No webhook received in 60 seconds, poll as fallback
        this.pollForUpdates();
      }
    }, this.pollInterval);
  }

  async pollForUpdates() {
    // Polling logic
  }

  processUpdates(updates) {
    // Process received updates
    this.emit('update', updates);
  }
}

Expected output: System primarily uses webhooks for real-time updates, but automatically falls back to polling if webhooks stop working.

Common Mistakes

Practice Questions

1. What are the main disadvantages of polling?
2. How do webhooks reduce server load compared to polling?
3. What is a reasonable polling interval for non-critical updates?
4. When would you use a hybrid webhook/polling approach?
5. How do you handle webhook delivery failures?

Challenge

Design a system that uses webhooks as the primary update mechanism with polling as fallback. Implement the fallback to activate after detecting webhook delivery failures and deactivate once webhooks resume working.

FAQ

Mini Project

Build a comparison dashboard that shows the difference between webhooks and polling for the same data source. Track metrics: number of requests, bytes transferred, latency to receive updates, and success rate.

What's Next

Learn about the complete webhook flow