Webhook vs Polling

Build the mental model

Polling and webhooks solve the same problem — finding out something changed — with opposite mechanics. Polling repeatedly asks if anything happened; a webhook sends you a request the instant it does.

Polling is simple and needs no public endpoint, but wastes requests and adds delay. A webhook is near-instant and wastes nothing, but requires a public URL and inherits signature verification and idempotent handling as real requirements.

Polling fits low-frequency checks or environments where you can't host a public endpoint. Webhooks fit anywhere near-real-time matters and you can host a receiving endpoint.

POLLING VS WEBHOOK
------------------
-----
Polling (your app asks repeatedly):
  Your App -> "anything new?" -> Server   (t=0s)
  Your App -> "anything new?" -> Server   (t=10s)
  Your App -> "anything new?" -> Server   (t=20s)
  Your App -> "anything new?" -> Server   (t=30s)

Webhook (service pushes once, when it happens):
  External Service -> "something happened!" -> Your App (t=7s)

Connect it to a real scenario

The code below simulates both approaches against the same timeline of two events at seconds 7 and 23, over a 30-second window. simulateWebhook notices instantly with no interval to wait out.

Run both functions and compare totalRequests and delay. Polling makes a fixed number of requests with delay depending on timing luck. The webhook makes exactly one request per event with zero delay every time.

Scale the polling interval down to notice sooner, and you immediately pay for it in far more requests — a tradeoff webhooks sidestep entirely.

• Polling pulls for updates on a fixed interval; a webhook pushes updates to you the instant they happen.
• Polling wastes requests and adds delay; webhooks are efficient and near-instant but require a public endpoint and proper security.
• Choose polling for low-frequency needs or when you can't host a public endpoint; choose webhooks when near-real-time updates matter.

Try the working example

function simulatePolling(events, intervalSeconds, totalSeconds) {
  let requests = 0;
  const noticedAt = [];
  for (let t = 0; t <= totalSeconds; t += intervalSeconds) {
    requests++;
    events.forEach((e) => {
      if (e.at <= t && e.noticedAtPoll === undefined) {
        e.noticedAtPoll = t;
        noticedAt.push({ event: e.name, occurredAt: e.at, noticedAt: t, delaySeconds: t - e.at });
      }
    });
  }
  return { approach: "polling", totalRequests: requests, noticedAt };
}

function simulateWebhook(events) {
  const noticedAt = events.map((e) => ({ event: e.name, occurredAt: e.at, noticedAt: e.at, delaySeconds: 0 }));
  return { approach: "webhook", totalRequests: events.length, noticedAt };
}

const timeline = [
  { name: "payment.completed", at: 7 },
  { name: "user.created", at: 23 }
];

const pollingResult = simulatePolling(timeline.map((e) => ({ ...e })), 10, 30);
const webhookResult = simulateWebhook(timeline);

console.log(pollingResult);
console.log(webhookResult);

{
  approach: 'polling',
  totalRequests: 4,
  noticedAt: [
    { event: 'payment.completed', occurredAt: 7, noticedAt: 10, delaySeconds: 3 },
    { event: 'user.created', occurredAt: 23, noticedAt: 30, delaySeconds: 7 }
  ]
}
{
  approach: 'webhook',
  totalRequests: 2,
  noticedAt: [
    { event: 'payment.completed', occurredAt: 7, noticedAt: 7, delaySeconds: 0 },
    { event: 'user.created', occurredAt: 23, noticedAt: 23, delaySeconds: 0 }
  ]
}

Polling (computer science) — Wikipedia — API Integration & Webhooks