The True Cost of a Duplicate Webhook

A duplicate webhook feels free. It’s just one extra request, already handled, nothing broke. But the cost of a duplicate webhook is never one number — it’s billed in three places at once, and it scales with a volume you don’t control. This post puts a defensible figure on a single duplicate, then on a month of them, across the three platforms most AI agents run on — and shows the two ways to stop paying.

What a duplicate webhook actually costs

A duplicate doesn’t cost you a request; it costs you a full run of whatever the webhook triggers. That splits into three bills that fire together:

• Platform charge — an execution (n8n), an operation (Make), or a task (Zapier).
• LLM tokens — the model reprocesses the same input it already saw.
• Downstream effects — a second CRM write, a second notification, a double reply to the user.

The first two are pure waste. The third is worse than waste, because it creates work to undo.

Why duplicates happen in the first place

Duplicate webhooks are the normal behavior of reliable systems, not a rare glitch. Senders retry when they don’t get a fast 200: Twilio and Meta re-deliver WhatsApp and SMS webhooks on timeout, Slack retries Events API callbacks up to three times (see stopping duplicate Slack events), and payment and CRM webhooks re-send until acknowledged. Any agent that calls an LLM before responding is slow enough to trigger these retries routinely. The duplicate rate isn’t noise; it’s a steady percentage of your traffic.

The cost on each platform

Each platform meters differently, so the same duplicate has a different price tag depending on where it lands. The figures below are public list prices translated to a per-event cost — a projection to compare platforms, not a measured study.

Platform	Billing unit	Approx. cost per duplicate run
n8n (Cloud)	Per workflow execution	~$0.002
Make	Per operation (each module step)	~$0.01–0.03 (multi-step scenario)
Zapier	Per task (each action step)	~$0.02–0.05 (multi-step Zap)

The spread matters: on n8n a duplicate burns one execution, but on Make and Zapier a single duplicate webhook fans out into one charge per step. A five-step Zapier workflow bills five tasks for one duplicate. Add the LLM token cost on top, and the per-duplicate figure roughly doubles on a chatty agent.

A month of duplicates

One duplicate is rounding error. The real cost is the monthly total, because duplicates arrive as a stable fraction of inbound volume. Take an agent receiving 50,000 webhooks/month with an 18% duplicate rate — conservative for channels with retrying senders. That’s 9,000 duplicate runs every month.

Platform	Cost/duplicate (blended with tokens)	Monthly waste	Annualized
n8n	~$0.006	~$54	~$648
Make (5-step)	~$0.05	~$450	~$5,400
Zapier (5-step)	~$0.10	~$900	~$10,800

The manual fix (Option 1)

You stop paying by rejecting the duplicate before it hits the billable trigger. Three defenses you build and maintain yourself:

Fix 1: acknowledge fast

Return 200 immediately so senders stop retrying — this removes the root cause of most duplicates before any dedup logic runs.

On a gateway, the instant ack is the default.

Fix 2: deduplicate on a stable ID

Hash the payload or key on the sender’s event ID within a short window, and drop repeats. See how deduplication works in n8n for the mechanics.

On a gateway, the id store and window are built in.

Fix 3: filter in front, not inside

This is the one that saves the platform charge. Dedup inside the workflow saves tokens but the execution/operation/task is already counted; only a pre-trigger drop avoids the platform bill entirely — the same distinction that drives the ROI of message filtering.

On a gateway, “in front” is the whole point — the duplicate never reaches the trigger.

The catch: you have to keep it running

Acking fast, hosting the hash store, tuning the window, and wiring a pre-trigger filter is real work — and on Make and Zapier you’d need that filter outside the platform to save the per-step charge, which the platforms themselves don’t give you. Build it once per channel, patch it as senders change, repeat forever.

Place a gateway layer (Option 2) — faster

A pre-trigger layer — a managed gateway or a DIY Cloudflare Worker — absorbs the duplicate so no execution, operation, or task is ever counted, across every platform at once.

• Zero platform charges on duplicates. The copy never reaches the billable trigger.
• One layer, every platform. n8n, Make and Zapier behind the same filter.
• Nothing to maintain. No ack path or hash store to host per workflow.

Option 1 (inside) vs Option 2 (in front)

Where you filter decides which of the three bills you actually kill:

	Filter inside the workflow	Filter in front (gateway)
LLM token cost	✓Saved	✓Saved
Platform charge (exec/op/task)	✕Still counted	✓Never counted
Per-step cost (Make/Zapier)	✕Billed per step	✓Dropped before step 1
Setup & upkeep	~Per workflow, forever	✓Once, all platforms
Control of internals	✓Full	~Abstracted away

A single duplicate is cheap; a month of them is a line item worth removing. It’s one more application of message quality for AI agents.

If dropping them before the trigger sounds like you, here’s the short version of how to set it up: absorb duplicates before they’re billed →.

Either way — go make the duplicate stop costing you three times.

Thanks for reading. 👋

Orlando. -