How to Chain Zaps Together with Webhooks and Webhook Relay

A practical field guide from Automation Ace.

How to Chain Zaps Together with Webhooks and Webhook Relay

A single Zap has a linear structure: one trigger, then steps in sequence. When your workflow is too complex for one Zap — or when you want to reuse the same downstream logic across multiple triggers — chaining Zaps with webhooks is the solution. One Zap finishes its work and fires a Webhooks POST to another Zap's Catch Hook trigger, handing off the data. The receiving Zap takes it from there. The advanced version of this — webhook relay — receives one incoming webhook and immediately forwards it to multiple downstream Zap hooks, fanning out to parallel workflows.

Basic Zap Chaining: Trigger One Zap from Another

The simplest chain: Zap A does its work, then triggers Zap B by POSTing to its Catch Hook URL.

Step 1: Set Up Zap B with a Catch Hook Trigger

1. Create Zap B and set the trigger to Webhooks by Zapier → Catch Hook
2. Copy the Catch Hook URL
3. Complete and publish Zap B

Step 2: Add a Webhooks POST Action at the End of Zap A

1. In Zap A, add a Webhooks by Zapier → POST action as the last step
2. Set the URL to Zap B's Catch Hook URL
3. Set Payload Type to Json
4. In the Data section, add the fields Zap B needs — map them from Zap A's trigger and earlier step outputs

Every time Zap A runs successfully, it fires Zap B with whatever data you mapped. The two Zaps are decoupled — they run independently, with their own task histories, and can be modified separately.

Why Chain Zaps Instead of Using One Long Zap

• Step limits: Free and lower-tier Zapier plans limit steps per Zap. Chaining lets you extend beyond that limit
• Reusability: Multiple Zaps with different triggers can all call the same downstream Zap — e.g., a "Create CRM Contact" Zap triggered by form submits, Typeform responses, and Shopify orders all pointing to one Contact Creator Zap
• Modularity: Separate concerns — one Zap fetches and cleans data, another creates records, another sends notifications. Edit each independently without risking the others
• Parallel execution: Fire multiple downstream Zaps simultaneously (covered in the relay pattern below)

Passing Data Between Chained Zaps

Data passes through the webhook payload body. Include all fields the downstream Zap needs — don't rely on the downstream Zap to look up data it could receive directly:

// Code step in Zap A: build the handoff payload
const payload = {
  contact_id:   inputData.contact_id,
  email:        inputData.email,
  first_name:   inputData.first_name,
  last_name:    inputData.last_name,
  source_zap:   'Lead Intake',
  processed_at: new Date().toISOString()
};

output = { payload: JSON.stringify(payload) };

Then in the Webhooks POST action, set Payload Type to Json and Data to {{payload}} (the raw JSON string). Or map fields individually in the Data key-value rows without a Code step.

Advanced: Webhook Relay (One Incoming → Multiple Downstream Zaps)

A webhook relay Zap receives a single incoming webhook and immediately forwards it to multiple downstream Zap hooks — enabling fan-out to parallel workflows from a single trigger event.

Relay Zap Structure

1. Trigger: Webhooks by Zapier → Catch Hook (receives the original event)
2. Action 1: Webhooks by Zapier → POST → Zap B's Catch Hook URL (forward to workflow B)
3. Action 2: Webhooks by Zapier → POST → Zap C's Catch Hook URL (forward to workflow C)
4. Action 3: Webhooks by Zapier → POST → Zap D's Catch Hook URL (forward to workflow D)

Each POST action passes the same trigger data (or a transformed subset) to a different downstream Zap. All three downstream Zaps run effectively in parallel — Zapier processes them concurrently because they're separate Zap runs.

Building the Relay Payload

The relay Zap can forward the raw payload unchanged, or use a Code step to reshape or filter the data before forwarding to each downstream Zap:

// Relay Zap: reshape incoming data for different consumers
const raw = {
  order_id:    inputData.order_id,
  customer:    inputData.customer_email,
  total:       inputData.order_total,
  items:       inputData.line_items,
  shipping:    inputData.shipping_address
};

// CRM Zap only needs customer data
const crmPayload = JSON.stringify({
  order_id:  raw.order_id,
  customer:  raw.customer,
  total:     raw.total
});

// Fulfillment Zap needs items and shipping
const fulfillmentPayload = JSON.stringify({
  order_id:  raw.order_id,
  items:     raw.items,
  shipping:  raw.shipping
});

output = { crm_payload: crmPayload, fulfillment_payload: fulfillmentPayload };

Then use {{crm_payload}} as the Data in the POST to the CRM Zap and {{fulfillment_payload}} in the POST to the Fulfillment Zap.

Webhook Chaining vs. Sub-Zaps

Zapier also supports Sub-Zaps (Zapier's native Zap-calling feature) for triggering one Zap from another. The difference:

• Webhook chaining: asynchronous — Zap A doesn't wait for Zap B to finish; fire-and-forget. Use when downstream results aren't needed by Zap A.
• Sub-Zaps: synchronous — Zap A waits for the Sub-Zap to complete and can use its output. Use when Zap A needs the result (e.g., a created record ID) from the downstream Zap.

Deduplication in Chained Zaps

When the relay Zap forwards identical payloads to the same downstream Catch Hook repeatedly, Zapier's deduplication may skip some. Include a timestamp or nonce in the forwarded payload to prevent this. See webhook trigger deduplication for the pattern.

Webhook chaining is the loosest coupling available in Zapier — two workflows connected only by a URL and a JSON payload, with no shared state. That makes each Zap independently editable, testable, and debuggable. The relay pattern extends this to fan-out: one inbound event splits into multiple parallel downstream workflows, each receiving only the data it needs.

For the sequential queue pattern (a special case of self-chaining), see sequential queue with Webhooks and Zapier Tables. For passing data in the webhook payload, see passing data through Webhooks in Zapier. For a self-triggering loop with Google Sheets, see looping Zaps with Google Sheets and webhooks. For help designing a multi-Zap pipeline, talk to Automation Ace.