Skip to content
ConsultEvo

How to Use Webhooks by Zapier: Setup, Checks, and Safe Automation

Webhooks by Zapier can receive an event from another system or send an HTTP request from a Zap. The useful question is not simply whether a webhook exists, but whether the source can send the request, the destination supports the required operation, and the workflow has a safe rule for incomplete or repeated events.

For example, a field-service application could send an inspection event to a Catch Hook. The Zap could validate the event ID and asset ID, create an event record in an operations system, and route unknown assets to review. That is an implementation pattern, not a claim that every field-service application supports the same webhook configuration.

A webhook is an HTTP request that carries information between systems. Use a Catch Hook when another service pushes an event into Zapier. Use an outbound Webhooks by Zapier action when a Zap must send a request to an endpoint. Zapier currently documents Webhooks by Zapier for Professional, Team, and Enterprise plans.

What Webhooks by Zapier does and when to use it

Webhooks are useful when an event or API operation is not covered by the native Zapier app trigger or action you need. They do not make an unsupported source or destination operation available by themselves. Confirm that the source can send the required request and that the destination accepts the method, fields, authentication, and write operation.

Need Starting point Validation focus Fallback
Another service pushes an event to Zapier Catch Hook or Catch Raw Hook Supported method, non-empty payload, required identifiers Route invalid or unknown events to review
A Zap sends an HTTP request Webhooks by Zapier action Destination schema, authentication, response meaning Use a native action or API by Zapier when more suitable
A URL is checked for new data Assess Retrieve Poll Retrieval method and definition of new data Do not describe polling as instant event delivery
A native Zapier action already fits Native app action Required create, update, or search behavior Prefer the native action over a custom request

Zapier lists Catch Hook for incoming requests and Catch Raw Hook for access to the unparsed request body and headers. The integrations page lists the request types associated with these triggers. See current Webhooks by Zapier triggers and actions and Zapier’s guide to receiving webhook requests.

Define the source event, the destination record, and the exception owner before choosing the automation direction.

Build an incoming webhook trigger

Use Catch Hook when a source app or service can send an event to Zapier. Use Catch Raw Hook when you need to inspect the unparsed body and headers, such as when diagnosing an unusual request format. Normal incoming webhook data must be non-empty and use a supported format such as JSON, XML, or form-encoded data.

  1. In the Zap editor, add Webhooks by Zapier as the trigger and select Catch Hook or Catch Raw Hook.
  2. Copy the generated URL and configure it as the destination for webhook requests in the source system. Confirm that the source sends the method and payload you expect.
  3. Send a non-empty test event from the source. Inspect the captured fields in Zapier. If fields are missing or nested unexpectedly, test the source’s actual payload and consult Zapier’s webhook troubleshooting guide.
  4. Map the inspected fields to the next Zap action only after checking required identifiers and allowed event types.
  5. Assign an owner for invalid payloads, unknown records, duplicate events, and failed destination writes before enabling consequential actions.

Nested JSON may be flattened into fields for mapping. If the source sends arrays or an unusual structure, test that specific payload rather than assuming every item will map as expected. Catch Raw Hook can help inspect the original body and headers during troubleshooting.

01Source owner configures deliverySet the generated URL in the source system and confirm its event, method, and payload. Output: a real request sent to the test hook.
02Integration owner inspects captureCheck that the non-empty request was received and that the expected fields are available. Output: a confirmed field map or a troubleshooting task.
03Business owner defines the recordSpecify whether one request creates, updates, or upserts one event-level record, and identify the destination’s required business key.
04Operations owner approves the gateTest missing IDs, unknown records, and duplicate events. Route exceptions to a named owner before the Zap writes production records.

Design the event contract before mapping fields

Decide what one request represents. In the example below, one request means one completed inspection event, not one asset, a daily summary, or proof of completion beyond what the source event reports. Keep event facts separate from asset identity, contact records, and later aggregate reporting.

The following is hypothetical implementation guidance, not a Zapier-published schema. The values are illustrative:

{
  "source_system": "field-service-app",
  "source_event_id": "evt_84721",
  "source_event_type": "inspection.completed",
  "asset_id": "pump-A12",
  "site_id": "north",
  "technician_id": "tech-204",
  "occurred_at": "2026-11-18T14:20:00Z"
}

Before writing, require the source system, stable event ID, allowed event type, asset or other destination-required identifier, and a parseable occurrence time. Define accepted status values and the destination identifier to save after a successful write. A proposed output record could preserve the source event ID and type, asset and site identifiers, actor, occurrence time, processing status, and destination record ID.

Use deterministic checks for exact event types, required fields, known asset IDs, allowed statuses, and duplicate detection. AI is optional and only useful for genuinely unstructured data, such as classifying a technician’s free-text note into an allowed category. If used, require a structured result, validate it against allowed values, and route low-confidence or invalid results for review. AI should not decide authorization, identity matches, or whether an event ID has already been processed.

Prevent duplicate records and route exceptions

Repeated user actions or sender retries can deliver the same event more than once. Without an idempotency rule, a CRM, spreadsheet, or operations system may receive multiple records for one event. When the source supplies a stable ID, a practical event key is source_system + source_event_id + source_event_type. Do not use only an asset ID or timestamp because an asset can have several legitimate events, including at the same time.

For a CRM write, validate the event ID and business identifier, enforce uniqueness, write once, and save the destination record ID. If concurrent deliveries are possible, a read-then-create lookup can race. Prefer a destination-native idempotency feature or an intermediary database with a database-enforced unique constraint and transactional upsert. This proposed implementation control protects against concurrent attempts to create the same event; it is not a built-in Zapier schema.

Preserve useful provenance in the record or an audit store: source event ID, source system, received and occurred times, a payload hash or raw-payload reference, processing status, destination record ID, and a Zap run reference when available. For CRM data design or record matching, see CRM systems consulting.

  • Missing event ID or unknown asset: send the event to an operations review queue instead of creating an unlinked record.
  • Duplicate event: mark it as already processed and stop the second write.
  • Ambiguous CRM match: hold the update for human review rather than choosing the first result.
  • Invalid payload or failed write: retain the error and payload reference, then assign investigation to the integration owner.

Use a URL, QR code, or NFC tag as a trigger carefully

A QR code, bookmark, NFC target, or internal link may start a Zap when it makes an applicable request to an active Catch Hook URL and supplies usable data. For example, a QR code could carry an opaque asset token and site ID for an asset lookup. Test the actual request format and map the captured fields in the Zap before relying on it.

Keep the event stages distinct: a scan can record inspection.started; a separately submitted form can record inspection.completed after required inspection fields pass validation. Notify a supervisor only after the completion event passes that gate. If the asset token is unknown, the technician ID is missing, or the completion form is incomplete, route the event to operations review.

Decision point

A scan records that a request was made; it does not establish that a person completed the task. Record a start event at the scan, then require a validated completion submission before logging completion or notifying a supervisor.

Send data from a Zap to an API

For an outbound request, add a Webhooks by Zapier action, choose GET, POST, PUT, or Custom Request, then configure the destination endpoint, payload, headers, and supported authentication. Test against the destination’s expected schema and inspect the response, including application-level error details. A successful HTTP status alone does not prove that the intended business operation succeeded.

Use Custom Request when the API needs a method such as PATCH or DELETE, nested JSON arrays, empty values, or highly customized headers. It is less forgiving, so validate the JSON and exact request format. Zapier documents no authentication and Basic Authentication for Webhooks by Zapier actions. Do not put a secret in an ordinary visible step field when it needs connection-based credential storage.

For OAuth2 or API-key credentials stored in a Zapier app connection, consider API by Zapier. Zapier documents it as a premium beta feature requiring a paid account. Use least-privilege scopes and restrict allowed domains where appropriate. A native app action is preferable when it already performs the operation. See Zapier’s guides to sending webhook requests from a Zap and setting up API by Zapier.

Before sending, confirm the destination’s required method, URL, content type, authentication, fields, and expected success response. Save a returned destination ID and processing status. If the destination throttles requests, follow its current retry guidance and avoid replaying writes without an idempotency rule.

Secure and operate the workflow

Treat a Catch Hook URL as a secret. Anyone who obtains it may be able to send requests that trigger the Zap. Do not publish a production URL in a QR example, public repository, or shared document. Keep personal information, customer data, and access tokens out of query strings because they may appear in browser history, logs, screenshots, or analytics systems. Use opaque identifiers when a URL must carry context.

Limits depend on webhook direction and step type. Check Zapier’s current rate-limit guidance and the documentation for the exact trigger or action rather than relying on one universal payload-size figure. Zapier documents throttling responses such as HTTP 429 and notes that high webhook activity can involve delayed processing. Design retries alongside duplicate protection and verify the destination’s own retry behavior.

Assign an owner to review failed Zap runs and destination responses. Track valid-event rate, duplicate suppression count, exception queue volume, destination write failures, and time to resolve exceptions. These measures help distinguish source delivery problems from mapping, identity, and destination issues.

Production launch gate
  • A real, non-empty test request matches the agreed field contract.
  • The Catch Hook URL and any credentials are handled as secrets.
  • Duplicate events cannot create duplicate consequential records.
  • A named owner reviews unknown identities, invalid payloads, and failed writes.
  • The destination response and resulting record ID are captured where available.
  • The team checked current limit guidance for the exact Zapier step and request direction.

If you need help defining event contracts, authentication, exception ownership, or CRM write behavior, explore Zapier automation consulting.

Frequently asked questions

Does Webhooks by Zapier work on the Free plan?

Zapier currently documents Webhooks by Zapier for Professional, Team, and Enterprise plans, not Free.

What is the difference between Catch Hook, Catch Raw Hook, and Retrieve Poll?

Catch Hook receives request data for a Zap. Catch Raw Hook exposes the unparsed request body and headers when inspecting the original request is useful. Retrieve Poll is worth assessing when a URL is checked for new data rather than receiving an instant pushed event.

Can a QR scan prove an inspection was completed?

No. A scan can record that a request or start event occurred. Require a separate submission with the necessary inspection fields before recording completion.

How do I avoid duplicate CRM records?

Use a stable source event or business ID and an idempotent destination write. For concurrent deliveries, use a destination-native mechanism or a database-enforced unique constraint with a transactional upsert. A lookup followed by create is not sufficient by itself.

Is there one maximum webhook payload size?

No single figure applies to every trigger and action. Check current Zapier documentation for the specific step and request direction.