A webhook is an event-driven HTTP request. When something happens in one system, that system sends information to a URL configured to receive it. For example, when an order is created, a store can send an order-created event to an automation endpoint, which validates the request and routes permitted data to an order-management or CRM workflow.
The key operational distinction is simple: receiving the request is not proof that the later automation or business action succeeded. The receiver still needs to authenticate and validate the event, record what happened, process it safely and track the downstream result.
This guide explains how webhooks differ from polling and APIs, what happens during delivery, how to receive them with Zapier or Make, and how to design validation, duplicate prevention, exception handling and optional AI classification around them.
A webhook confirms that an event was sent to an endpoint. The receiver owns validation, processing and the downstream result.
What is a webhook?
A webhook is a way for one system, the event source, to notify another system when a selected event occurs. The source sends an HTTP request to a configured endpoint, which is a URL that accepts the request. The request includes a method, headers and a payload, meaning the data that describes the event.
The receiver may verify authentication or a signature, parse the payload, validate required fields, return an HTTP response and pass valid data to further processing. In an order workflow, the source might send an event type and order ID. The receiver checks that the event is expected and that the required fields are present, then queues or routes the order for the next step. Whether an order record is successfully created is a separate outcome to record.
Webhook vs. polling vs. API
With polling, a client repeatedly asks a source whether anything has changed. With a webhook, the source sends a request when a configured event occurs. An API is a broader interface that can let software retrieve, create or update records through documented operations.
These categories can overlap. A webhook commonly uses HTTP and may call an API endpoint, while an automation may receive a webhook and then use an API to update a destination system. A webhook is not simply a one-to-one version of an API, and it does not have to connect only two systems.
| Approach | Who initiates? | Useful when | Main decision |
|---|---|---|---|
| Webhook | Source sends on an event | The source documents the event and delivery behavior you need. | Can the receiver validate, acknowledge and recover the delivery? |
| Polling | Client checks repeatedly | No suitable webhook exists, or controlled synchronization is important. | Does the API support reliable incremental retrieval or cursors? |
| API request | Caller requests an operation | You need to retrieve, create or update data through a documented interface. | Which method, authentication and destination operation are supported? |
Webhooks can reduce repeated checks and may deliver changes sooner, but they do not guarantee real-time delivery or better reliability. Polling can be preferable when the source has no suitable webhook, when the receiver needs controlled synchronization, or when the API supports reliable incremental retrieval. Choose based on the source’s documented event, recovery and synchronization options.
For Zapier-specific choices between Webhooks by Zapier and API by Zapier, see Zapier’s guide to making API requests.
What happens during a webhook delivery?
The source detects an event, constructs a request and sends it to the receiver. The receiver checks its authenticity and format, validates the fields it needs and responds according to the sender’s delivery contract. Work that cannot safely finish within the sender’s response window may need to be queued after receipt.
The following JSON is a hypothetical event shape. It is not a Zapier, Make or provider schema:
{
"event_id": "evt_example_001",
"event_type": "order.created",
"created_at": "2026-11-18T10:15:00Z",
"data": {
"order_id": "ord_example_42",
"status": "submitted"
}
}
For this example, the receiver should confirm that the event is authentic, the event type is allowed and the order ID is present before attempting to create or update an order record. The correct response code, authentication method, signature format, content type, retry behavior and timeout depend on the sender.
HTTP status codes do not create one universal webhook contract. 302 means a redirection response and 404 means that a resource was not found. Neither is a universal synonym for successful or failed webhook receipt. Follow the provider’s instructions for accepted responses and retries. The HTTP semantics standard defines these status-code meanings, but it does not define a universal webhook success rule.
As a provider-specific example, GitHub recommends returning a 2XX response within 10 seconds and processing longer work asynchronously when appropriate. That timing guidance applies to GitHub webhook receivers, not to every sender. See GitHub’s webhook best practices.
Receiving webhooks with Zapier or Make
Zapier: Catch Hook or Catch Raw Hook
- Create a Zap and select Webhooks by Zapier as the trigger.
- Choose Catch Hook when parsed request fields are suitable for mapping. Consider Catch Raw Hook when you need the unparsed body and headers.
- Copy the generated URL into the sending system’s webhook settings. Match the method and expected payload format to the sender and the Zapier trigger.
- Send a safe test event, inspect the received sample and map its fields to later Zap steps. Test the destination action too. A received sample only proves that Zapier received sample data.
Zapier currently documents Catch Hook and Catch Raw Hook for GET, PUT and POST requests. Its documentation lists a 2 MB maximum for Catch Raw Hook and a 10 MB maximum for triggers generally. Do not generalize those limits to other products. As of November 18, 2026, Zapier’s help documentation lists Webhooks by Zapier on Professional, Team and Enterprise plans. Check Zapier’s current setup and limits and its pricing page before implementation.
For receiving webhook-style traffic, Zapier documents no authentication or Basic Authentication for the relevant functionality. If the destination requires OAuth 2.0, reusable API keys or bearer tokens, compare Webhooks by Zapier with API by Zapier and use the product that matches the authentication requirement. A unique URL should be treated as sensitive where it provides access, but it is not a universal substitute for provider-supported verification.
For service information, see Zapier automation consulting.
Make: Custom webhook
In Make, add Webhooks > Custom webhook, create its URL and configure the sender to call it. Make documents optional API-key authentication for custom webhooks. Connect the webhook to the scenario and decide deliberately between immediate processing and scheduled processing. Make can queue incoming webhook data for scheduled work.
Confirm that the selected processing mode, queue behavior and recovery options fit the workflow. A request entering a Make queue does not prove that every later scenario module has completed. The exact downstream module and field mapping must be checked in the target application’s current Make documentation.
See Make’s Webhooks app documentation and its webhook processing guide. For service information, see Make automation consulting.
For either platform, test with non-production data and check the exact URL, method, content type, required fields and destination mapping. If the payload contains nested objects or arrays, confirm that the received sample can be mapped as needed before relying on the workflow.
Make webhook processing reliable
A production receiver should separate receipt from the work that changes business records. A practical sequence is to verify the provider’s authentication or signature, parse and validate the payload, record its event or delivery ID and processing state, prevent duplicate side effects, queue the permitted action and track its result.
Use an identifier at the correct grain. A proposed event ledger might store source_system, provider_event_id, event_type, source_object_id, received_at, signature_verified and processing_status. One row should represent one provider event or delivery identity, not a daily aggregate or a summary of several events. This is an illustrative engineering design, not a vendor-defined schema.
A customer ID, order ID or event type alone is usually not enough. One order can generate several legitimate events, and one event can be delivered more than once. Stripe, for example, documents event IDs and event types, but a Stripe event ID identifies an event, not every possible downstream business action.
A lookup followed by a create can still duplicate work when two deliveries arrive together. When duplicate side effects matter, enforce uniqueness atomically with a database constraint on (source_system, provider_event_id) or use a transactional upsert. This is a proposed implementation pattern, not a vendor schema.
When an event has already been recorded, avoid repeating its side effect and acknowledge it according to the provider’s documented rules. For new events, track states such as received, authenticated, parsed, validated, queued, processed and failed. Route unresolved failures to an integration operator, who can investigate and replay the event or assign the issue to the relevant business-process owner.
Protect endpoint secrets and raw payloads, retain only the personal data needed for the workflow and restrict writes to authorized records and fields. If a sender provides a signature, verify it before trusting the payload. GitHub, for example, documents delivery identifiers and signature verification using its own headers and secret. Do not copy GitHub’s exact header or signature process to another provider without checking that provider’s documentation.
For payment-related workflows, verify the exact event and payment state required before marking an order paid or triggering fulfillment. Stripe advises using webhook events for fulfillment rather than relying only on a customer’s browser redirect, including for delayed payment situations. Consult Stripe’s payment guidance for the relevant event and payment behavior.
Three practical implementation patterns
| Trigger | AI job | Validation and action | Fallback |
|---|---|---|---|
| External order-created event to a Zapier Catch Hook | None required for receipt or routing. | Match method, content type and required order fields, then map the verified sample to an order-management or CRM step. | Integration operator investigates missing samples, parsing failures and unsuccessful destination writes. |
| Make Custom webhook receives a contact message | Optional classification after authentication and normalization. | Choose immediate or scheduled processing, validate the source record ID and write only to the permitted destination field. | Queue or scenario owner handles authentication, schema, queue and destination errors. |
| Signed provider event to an application-controlled endpoint | None for signature verification, event uniqueness or permissions. | Verify the signature, atomically insert the delivery identity, queue work and apply the system-of-record update once. | Reject or quarantine invalid requests according to provider rules; send business conflicts to the relevant owner. |
| Validated support message requiring categorization | Classify text into an approved intent enum. | Validate category, confidence, source IDs, freshness and destination identity before a CRM update. | Send low-confidence, ambiguous or high-impact cases to a named reviewer. |
The table separates the trigger from the optional AI task and from the actual validation gate. In many webhook workflows, no AI is needed at all. Deterministic routing is usually the safer choice when the event type, status, identity or permission can be checked exactly.
Where AI fits, and where it does not
Use deterministic rules for facts the system can check exactly: signature validity, allowed event type, required IDs, permissions, freshness, duplicate detection, exact status and numeric thresholds. AI cannot verify a signature, establish payment success or replace authorization checks.
AI can be useful after those gates when a validated payload contains free text that needs a bounded classification, such as assigning a support message to an approved intent category. A proposed flow is: authenticate and validate the event, apply deterministic eligibility rules, classify eligible text, validate the structured result, then update a permitted CRM field or send the case to a human reviewer.
An illustrative classifier response could look like this:
{
"classification": "schedule_change",
"confidence": 0.91,
"source_event_id": "evt_example_004",
"source_record_id": "message_example_31",
"model_version": "recorded-at-runtime",
"prompt_version": "recorded-at-runtime",
"review_required": false
}
The category must come from an approved list, the confidence value must be within the permitted range and the source IDs must match the already validated event. Reject unknown categories, missing IDs, stale events, unresolved identities or unauthorized writes. Send low-confidence results, conflicting record matches and high-impact changes to a named operations or support reviewer.
Store the source event ID and relevant model or prompt version for audit. The classifier contract, confidence threshold and CRM mapping are proposed design choices, not a documented Zapier or Make AI template. For service information, see AI agent design.
A webhook readiness check
Before relying on a webhook workflow, establish what the source sends, what the receiver promises and who owns the exceptions. Confirm the destination system of record and the intended operation: create, update, search or true upsert.
- Confirm the source event, current delivery mechanism, request method, payload format and required fields.
- Document supported authentication or signature checks, and protect endpoint secrets and retained payloads.
- Check provider-specific response, timeout, retry, redelivery, payload-size and rate-limit behavior.
- Choose the provider event or delivery ID used to prevent repeated side effects, and enforce uniqueness atomically when needed.
- Name the system of record, destination operation and permitted fields. Confirm whether the operation is a true upsert.
- Assign an exception owner and define how invalid, delayed, duplicate, failed and low-confidence events are investigated or replayed.
Monitor accepted deliveries, duplicate suppressions, processing failures, exception age and successful destination writes. Set targets based on the workflow’s operational needs rather than assuming a universal benchmark. Proceed only when the event contract, processing path and failure ownership are clear.
