Chain Webhooks Between Workflows for Microservice Architectures

To build microservice-style automation in n8n, split logic across multiple workflows that call each other through internal webhooks. One workflow receives the external event, then triggers specialized sub-workflows via HTTP Request nodes pointing at other n8n webhooks. Each service gets independent deployment, testing, and error handling, so you can change one without touching the others.

What is webhook chaining between workflows?

For complex systems, split logic across multiple workflows that communicate via internal webhook calls. One workflow receives the external event, then triggers specialized sub-workflows via HTTP Request nodes pointing to other n8n webhooks. This gives you independent deployment, testing, and error handling per service.

Real-world example: An order processing system with separate workflows for payment, inventory, and notification logic.

How do you chain webhooks between workflows?

Main workflow (Order Receiver):

// Code node: "Route Order Event"
const event = $input.first().json.body;
const baseUrl = 'https://your-n8n.example.com/webhook';

// Determine which downstream workflows to trigger
const targets = [];

if (event.type === 'order.created') {
  targets.push({ url: `${baseUrl}/internal/payment/charge`, data: event });
  targets.push({ url: `${baseUrl}/internal/inventory/reserve`, data: event });
  targets.push({ url: `${baseUrl}/internal/notifications/order-confirm`, data: event });
}

if (event.type === 'order.cancelled') {
  targets.push({ url: `${baseUrl}/internal/payment/refund`, data: event });
  targets.push({ url: `${baseUrl}/internal/inventory/release`, data: event });
}

return targets.map(t => ({ json: t }));

Then use an HTTP Request node in batch mode to call each target:

{
  "method": "POST",
  "url": "={{ $json.url }}",
  "sendBody": true,
  "bodyParameters": {
    "parameters": []
  },
  "jsonBody": "={{ JSON.stringify($json.data) }}",
  "options": {
    "timeout": 5000
  }
}

Each sub-workflow has its own Webhook node:

# Payment workflow

Path: internal/payment/charge
Auth: Header Auth (internal shared secret)

# Inventory workflow

Path: internal/inventory/reserve
Auth: Header Auth (internal shared secret)

# Notification workflow

Path: internal/notifications/order-confirm
Auth: Header Auth (internal shared secret)

When should you use Execute Workflow instead?

Tip: Use the Execute Workflow node for tighter coupling. If the sub-workflows are on the same n8n instance and you need synchronous results, the Execute Workflow node is simpler and avoids HTTP overhead. Use webhook chaining when workflows run on separate instances or when you need fire-and-forget behavior.

This pattern lets you update notification logic without touching payment logic, and each workflow has its own error handling and retry configuration.

Related: Set a Unique Encryption Key and Back It Up · Use the HTTP Request Node as a Universal Connector