The short version
  • Zapier is the right default for low-stakes plumbing a marketer should own: a submission to a spreadsheet, a new contact to a chat channel. It is a weaker default for the one pipe that carries every lead.
  • No-code automation rarely fails loudly. The failures we've debugged were a queue that quietly stopped draining, a field that arrived twice, and an integration nobody on the client's team could open.
  • The upstream half is the blind spot. Zap history only shows runs that reached Zapier. If the form never sends, there is nothing to look at.
  • Testing a live Zap is a live action. Zapier's own docs say an action test can create real records. Intercept on the sending side instead.
  • A small custom endpoint is cheaper to trust, because every submission becomes a numbered row you can count and replay. It can still fail. You just see it.
  • Our default: the lead itself rides a pipe you own and can audit. Zapier handles everything downstream of that.

Every contact form has a pipe behind it. The form fires, something carries the submission to a CRM or an inbox, and somebody calls the lead back. Nobody looks at that pipe until a lead goes missing, and then the only question that matters is how much of it you can see. That question settles most of the Zapier vs webhooks argument.

We're a Vancouver studio and we maintain both kinds. Some of our clients route form entries through Zapier into their back office and CRM. Our own site sends every lead to a small endpoint we wrote. Both have broken on us. They broke differently, and the difference is the whole comparison.

60 days
of run history Zapier guarantees
39 of 54
scheduled jobs stalled by one redirect
15 min
the schedule we set for a backup job
1–3.4 hr
how often it actually ran

Zapier vs webhooks: what you are actually choosing

A webhook is nothing exotic. It's an HTTP request one system sends to another when something happens. Zapier can be the receiving end: its Catch Hook trigger gives you a unique URL that your app can POST to, and from there you map fields into any of its connected apps. So the choice isn't between webhooks and no webhooks. It's about who hosts the receiving end, who writes the mapping, and who can see what happened.

In practice we meet three shapes:

  • A form plugin's Zapier add-on. Gravity Forms ships one. Each form gets a feed, and the plugin posts entries to a Zap.
  • A landing-page builder's built-in integration. The builder pushes leads into a Zap from inside its own account, which is often not your account.
  • A custom endpoint. A small function you deploy (we use a Cloudflare Worker) accepts the POST, writes a row to a database, and forwards or exports it.

The pricing models differ in kind. Zapier bills by task: a task is a successful action, triggers never count, failed actions don't count, and a replayed run uses tasks again. Cloudflare Workers, as of November 2026, has a free plan with a daily request allowance and a paid plan billed on requests and CPU time; its database, D1, bills on rows read, rows written and storage. At contact-form volume, neither bill is the deciding factor. Attention is.

Zapier, honestly

Right when: the pipe is low-stakes, the destination has a supported app, and a non-developer should be able to change it on a Tuesday. A new enquiry posted into a team channel. A webinar sign-up added to a list. Zapier is very good at this, and building it yourself would be a waste of everyone's time.

Wrong when: it's the only record of a lead, and nobody watches it. Zapier is a middle link. It can tell you a lot about the runs it received and almost nothing about the ones it never got.

What people underestimate: the ends of the pipe. Zapier itself was never the broken part in anything we've debugged. The sender stalled, or the mapping was ambiguous, or the Zap lived in an account nobody could open. Also underestimated: history is finite. Zapier guarantees a maximum of 60 days of Zap run data, so a question about last quarter's leads may have no answer there.

What people overestimate: how much a failed run costs you. Errored runs can be replayed, and paid plans can autoreplay errored runs. A loud failure inside Zapier is the recoverable kind. The quiet ones outside it are the problem.

A custom endpoint, honestly

Right when: the pipe carries every lead, attribution matters, and you want to count submissions independently of any vendor. One function, one table, a sequence number on every row.

Wrong when: nobody on your side can deploy and own code. A custom endpoint without an owner is just a newer place for leads to disappear.

What people underestimate: how small it is. Ours is a Worker with a /collect route that accepts a beacon from the page, a D1 table that gives each lead a monotonic sequence number, and an authenticated /export?since_seq=N route that a nightly job reads from. The job stores the highest number it has seen, so re-running it can't double-count.

What people overestimate: how much it protects you. Ours sat built but inert for three weeks while the last deploy steps waited, and because the collector URL in the page script was still empty, nothing errored; the page simply never sent. Then the nightly job got refused by Cloudflare's own bot protection, because a Python client running in CI looks like a bot; it needed a browser User-Agent. A custom pipe fails too. The difference is that every one of those failures sat in code, config and logs we could read.

Failure one: the queue that stopped draining

An insurance client's IT team told us one morning that nothing had reached their back office since the previous evening. Submissions were arriving on the site. They just weren't leaving it.

The form plugin was Gravity Forms with its Zapier add-on, and that add-on sends feeds in the background. Gravity Forms' own docs describe how: the site sends a request to itself to process the queue, with WP-Cron as the fallback. And WP-Cron doesn't run on its own; WordPress triggers it with a request to itself on page load.

Overnight, a redirect rule appeared at the host's origin. Every dynamic request that carried a query string was redirected to the insecure version of the URL with the query stripped off. WordPress fires cron with a non-blocking request to wp-cron.php?doing_wp_cron=…, which always carries a query string, and a non-blocking request doesn't follow redirects. So cron never ran. By the time we looked, 39 of 54 scheduled events were overdue, the Zapier feed processor among them.

Three details made it quiet:

  • Zapier saw nothing wrong. No requests arrived, so no runs failed. Zap history was simply short.
  • The site's failure alert watched the wrong thing. It hooked a different add-on from the one actually sending, and it only caught failed HTTP calls. A stalled queue makes no HTTP call at all.
  • Every response said server: cloudflare, which pointed everyone at the CDN. Requesting the origin directly, bypassing the CDN, showed the same redirect. That one test moved the ticket to the right desk.

The host removed the rule within about a day. We drained the backlog by re-sending each stuck entry through the add-on's own send function, skipping any entry already marked as delivered, so a second run couldn't double-send.

Then we added a backup: a scheduled GitHub Actions job that triggers WordPress's due cron events server-side every fifteen minutes and turns red if any send fails or cron lag is too high. GitHub doesn't honour a fifteen-minute schedule on that repository. Measured over two weeks, the job actually fired every one to three and a half hours. Later it failed to start at all for about 27 hours, and nobody noticed, because a job that never starts can't run its own failure step. No submissions were affected; the site's own cron was healthy by then. Catching that needs an outside check that expects a ping and complains when it doesn't arrive.

Failure two: one submission, the same field twice

The same client reported that some submissions arrived with the company name duplicated. The obvious suspect was a double-firing Zap. It wasn't. Only one feed was active for that form.

The form stored the customer's company in two fields, both labelled "Company Name": a dropdown for returning users and a text box for new ones. Conditional logic meant only one was filled. A few days earlier we'd added a small hook to keep a staff view's company column complete, which copied the new-company value into the dropdown field. It copied without clearing. From then on, every logged-out submission carried the name twice, and the Zap, mapping both fields, sent both.

Nothing errored. Zapier did exactly what it was told. The recommended fix needs no code: point the Zap at the one field that's always filled, and rename the second field so the mapping screen can tell them apart. That's as far as this one went: diagnosed, with the fix written up, not yet applied.

The lesson is about coupling. A change on the form side can silently change what the Zap sends, and the Zap's field picker shows labels, not field IDs. If two fields share a label, nobody can see which one is mapped.

Failure three: the integration nobody could open

A family-law firm ran paid landing pages on a page builder. The builder posted each lead through its own Zapier integration, with hidden fields for the page URL, five UTM parameters and gclid. Where that Zap sent them, and how it mapped them, we could never verify. Nothing in the access we had could see it.

When we read the firm's CRM workflows (read-only), we found a labelling rule that treated any lead whose source detail mentioned Zapier as a main-website lead, and it ran before the rule that recognised paid landing pages. The name of the pipe could decide which channel got the credit.

The right ask was view access to the Zap, not full CRM access, which would have exposed every family-law client's record. And when we rebuilt the pages, they submitted straight to HubSpot's form submission endpoint, into a form whose name and fields the firm's workflows were built to recognise. That endpoint rejects any field that isn't on the form, with a FIELD_NOT_IN_FORM_DEFINITION error, which is the kind of loud failure you want.

If you can't open the integration that carries your leads, you don't have an integration. You have a rumour.

Testing a live Zap without firing it

Start with the uncomfortable fact: Zapier's docs say testing an action step is live and may make changes in your app. Testing a "create contact" step creates a contact. The editor offers Skip test for steps you don't want to run. So the editor is the wrong place to prove a production pipe.

What works for us:

  1. Intercept on the sending side. On the insurance client's WordPress site, five forms had live Zapier feeds when we mapped it, so a real test submission fires a real Zap. We test either on a form with no feed attached, or with WordPress's pre_http_request filter catching the outbound call in-process, so the request is built and inspected but never leaves.
  2. Give the page a dry-run switch. The family-law landing pages take a ?hsdryrun=1 parameter that keeps a live page from sending. Our test scripts intercept the endpoint locally and assert on the payload.
  3. Prove the conversion without the lead. To check tracking on those pages, a script opens the thank-you state with the same session note a real send leaves behind, then checks that the conversion tags fire. No enquiry is ever created.
  4. Read the destination, never write to it. We inspect the CRM side with a read-only login and the HubSpot command line. When a real end-to-end test lead is genuinely needed, a person sends it deliberately and the firm deletes the test contact afterwards.
  5. Watch for silence, not just errors. Zapier returns a 404 to webhook requests aimed at a Zap that's off, but its docs note a delay of up to several hours during which the URL still answers 200. A sender that checks only the status code can't see that window.

What our own pipe looks like, warts included

Our contact form posts to a hosted form service for the email, and separately sends a beacon to our Worker. The Worker writes the lead, with first-touch UTMs and gclid, into D1. Every night a job pulls new rows since the last sequence number into the database our reporting reads.

We proved it by tracing one test lead from form to Worker (204), to D1, to export (200, gclid intact), to the reporting table, then purged it.

Two warts are worth knowing about, because they apply to any custom pipe:

  • gclid is useless if the script that stores it isn't loaded where people land. For a while our tracking script sat on 14 of 131 pages. A paid click landing on the homepage carried its gclid in the URL, clicked through to the contact page, and arrived at the collector with nothing. We proved it in a real browser against the live site and moved the script into the shared page head.
  • The pipe grows a second job. The same Worker now serves small shared documents for unlisted group pages (a poll, a review round) with a version check on every write. That's useful, and it's also one more thing that depends on a Worker we maintain.

Zapier vs webhooks, side by side

Zapier (form plugin feed) Landing-builder integration Custom endpoint (Worker + D1)
Who changes the mapping A marketer, in a browser Whoever owns the builder account A developer, in code
Where the record lives The form plugin, plus Zap history (60 days guaranteed) The builder, plus a Zap you may not see Your own database table
What you see when the sender stalls Nothing in Zapier Nothing anywhere you can open Fewer rows than form emails, in a table you can query
Retry Replay and autoreplay for errored runs Depends on the builder Re-export from any sequence number
Pricing model Per task Bundled in the builder's plan Per request, CPU time and database rows
Safe testing Intercept upstream; editor tests are live Rarely possible Local mock or dry-run flag
Attribution fields Only what the feed maps Hidden fields, if configured Whatever you choose to store

Read the third row first. In Zapier vs webhooks, it's the row that decides how long a missing lead stays missing.

Our defaults

Since a comparison that won't pick is a cop-out:

  • Low-stakes routing a marketer should own → Zapier. Notifications, list sign-ups, spreadsheets. Don't build what Zapier already does well.
  • The lead itself, on a site you control → keep a record you own: a small endpoint and a table, or at least a form plugin that stores every entry. Then let Zapier carry copies downstream.
  • Gravity Forms on WordPress with Zapier feeds → fine, with two additions: alert on queue depth and cron lag rather than HTTP errors, and run WordPress cron from a real scheduler with an outside check that notices when the scheduler itself stops.
  • Landing-page builders → only if someone on your team can open the Zap. Otherwise submit straight to the CRM's form endpoint and test the whole conversion chain yourself.
  • Paid traffic of any size → make sure gclid and UTMs survive the trip, then reconcile the counts against your ad platform. If the numbers disagree, the pipe is the first suspect.

The real question in Zapier vs webhooks isn't which tool is better. It's which failure you can see. Pick the pipe whose silence you'd notice.

Related comparisons: Contact form backend: where leads land and how you know · Uptime monitoring vs synthetic monitoring: what a 200 hides

If leads are going missing somewhere between your form and your CRM, or you run WordPress forms that feed Zapier and want them watched properly, tell us what's connected to what.

Common questions

Is Zapier reliable enough for website lead forms?

Zapier itself is usually the most reliable link in the chain. The risk sits on either side of it: the form plugin or landing-page builder that has to send the submission, and the field mapping that decides what lands in the CRM. Zap history only shows runs that reached Zapier, so a sender that stops sending leaves nothing to look at. For low-stakes routing, that's an acceptable trade. For the pipe that carries every lead, keep an independent record you can count against, and alert on silence, not just on errors.

What is the difference between Zapier and a webhook?

A webhook is a plain HTTP request one system sends to another when something happens, such as a form being submitted. Zapier is a hosted service that can receive those requests, map the fields and pass them on to hundreds of apps. Zapier vs webhooks is really a question of who hosts the receiving end and who can see inside it. With Zapier, the vendor hosts it and you configure it in a browser. With a custom webhook, you deploy a small endpoint yourself and own its logs and records.

How do I test a Zap without sending real data?

Assume any test is live. Zapier's documentation says testing an action step performs the action in the connected app and can create real records, and the editor offers a Skip test option for steps you don't want to run. To prove the whole chain without creating a fake lead, intercept the request on the sending side instead: on WordPress, filter the outbound HTTP call before it reaches Zapier, or submit only to a form with no feed attached. Then check the receiving app with read-only access.

Why did my Gravity Forms Zapier feed stop sending?

If submissions are being saved but never reach Zapier, look at background processing before anything else. Gravity Forms can send feeds in the background, triggered by a loopback request from the site to itself with WP-Cron as the fallback. If something blocks that loopback, such as a redirect at the host, the queue fills up and nothing fails visibly. Check Site Health for loopback and scheduled-event errors, enable Gravity Forms logging, and look for overdue cron events.

What does it cost to run a webhook on Cloudflare Workers?

As of November 2026, Cloudflare offers a free Workers plan with a daily request allowance and a per-request CPU cap, plus a paid plan billed on requests and CPU time above an included amount. Its D1 database bills on rows read, rows written and storage. A contact-form endpoint at small-business volume sits comfortably inside those allowances. The real cost is the developer time to build, deploy and own it, which is why it only makes sense for the pipe that matters most.

Why does my Zap send the same field twice?

Check whether it's two runs or one run carrying the value twice. In the case we diagnosed, there was only one active feed. The form stored the same answer in two fields with the same label, one for returning users and one for new ones, and a small hook copied the value across without clearing the original. Zapier faithfully sent both. The fix is to map the Zap to a single field and give the two fields different labels, so the mapping screen can tell them apart.

Should a landing-page builder send leads to my CRM through Zapier?

Only if someone on your team can open that Zap. A builder's built-in integration often runs inside an account owned by whoever set it up, which might be an ad vendor. When leads go missing or arrive mislabelled, you need to see the mapping and the run history. If you can't, either ask for view access to the Zap or have the page submit straight to your CRM's form endpoint, which you can test and monitor yourself.