Webhook vs Polling: When to Use Each

Webhooks push data to you when something happens. Polling asks for data on a schedule. Both approaches have trade-offs, but for most real-time use cases, webhooks are dramatically more efficient.

What is Polling?

Polling means your application repeatedly sends HTTP requests to an API at regular intervals to check for new data. A typical implementation looks like this:

// Poll every 30 seconds
setInterval(async () => {
  const response = await fetch('/api/orders?since=' + lastCheck);
  const newOrders = await response.json();
  if (newOrders.length > 0) {
    processOrders(newOrders);
  }
  lastCheck = Date.now();
}, 30000);

The problem? Most of those requests return nothing. A Zapier study found that 98.5% of polling requests are wasted — they return empty responses because nothing has changed.

What is a Webhook?

A webhook is an HTTP callback. Instead of asking for data, you give a service a URL and it sends you an HTTP POST request whenever something happens:

// Your server receives events as they happen
app.post('/webhooks/stripe', (req, res) => {
  const event = req.body;
  if (event.type === 'payment_intent.succeeded') {
    notifyTeam(event.data.object);
  }
  res.status(200).send('ok');
});

No wasted requests. No delays. Data arrives within milliseconds of the event occurring.

When to Use Webhooks

• Real-time notifications — payment confirmations, deployment alerts, error tracking
• Event-driven workflows — triggering actions when something happens in another system
• High-frequency data — where polling would generate too many empty requests
• Multi-service orchestration — connecting Stripe, GitHub, Sentry, and other services

When Polling Still Makes Sense

• The API does not support webhooks — some legacy APIs only offer polling
• You need bulk data sync — periodic full syncs of large datasets
• Unreliable network — if your server might be down, polling with retry is simpler
• Rate-limited APIs — when you need to control exactly how often you hit an endpoint

Performance Comparison

For a service generating 100 events per day:

• Polling every 30s: 2,880 API requests/day, 100 contain data (3.5% efficiency)
• Webhooks: 100 HTTP callbacks/day (100% efficiency)

That is a 28x reduction in network traffic. At scale, this difference translates directly to lower infrastructure costs and faster response times.

The Practical Challenge with Webhooks

Webhooks are more efficient, but they introduce operational complexity:

• You need a publicly reachable endpoint to receive them
• You must verify webhook signatures to prevent spoofing
• You need to handle retries and idempotency
• Debugging is harder — you cannot just re-run a request

This is exactly why we built dread. It gives you a webhook endpoint instantly, delivers events as desktop notifications and a live terminal feed, and lets you inspect and replay payloads without writing any server code.

curl -sSL dread.sh/install | sh