Webhook Executor Node

The Webhook node lets you send HTTP requests to any external endpoint from within your workflows. Use it to connect Syncaut to any service that accepts webhooks — Slack, Discord, Zapier, Make, custom APIs, internal services, or anything else that exposes an HTTP endpoint.

Unlike the integration nodes (Shopify, WooCommerce, etc.), the Webhook node requires no credentials. You provide the URL, method, and payload directly.

When to Use the Webhook Node

• Sending data to a service that does not have a dedicated Syncaut integration

• Triggering a Zapier or Make (Integromat) automation from a Syncaut workflow

• Posting notifications to Slack or Discord incoming webhooks

• Calling an internal API or microservice

• Forwarding processed data to a third-party reporting tool or CRM

• Chaining Syncaut workflows by triggering one workflow from another

Step 1 — Configure the Request

When adding a Webhook node to your workflow, you go through two steps:

Configure

• Step name — a variable name used to reference this node's output in later steps (e.g. notifyWebhook). Must start with a letter or underscore, no spaces.

• Method — choose between POST, PUT, or PATCH

• URL — the full endpoint URL to send the request to (must start with https:// or http://)

Payload

Write the JSON body to send with the request. The payload editor supports Handlebars variables so you can reference outputs from previous workflow steps.

Choosing a Method

• POST — use for creating resources or sending notifications. This is correct for most webhook use cases including Slack, Discord, Zapier, and Make.

• PUT — use for replacing a resource entirely. Use this when the receiving API expects a full object replacement.

• PATCH — use for partial updates. Use this when the receiving API expects only the changed fields.

If you are not sure which method to use, check the documentation of the service you are sending to. Most webhook receivers expect POST.

Writing the Payload

The payload must be valid JSON. A template pre-loads with {} — replace it with the structure the receiving endpoint expects.

Basic example for a Slack incoming webhook:

{
  "text": "New order received: {{orderId}} for {{customerName}}"
}

Example forwarding order data to an external API:

{
  "event": "order.created",
  "order_id": "{{orderId}}",
  "customer_email": "{{customerEmail}}",
  "total": {{orderTotal}},
  "timestamp": "{{timestamp}}"
}

Using Variables in the Payload

Reference outputs from any previous workflow step using Handlebars syntax:

{{stepName.data}}

For example, if a previous step named getOrder fetched a WooCommerce order, reference the order ID as:

{{getOrder.data.id}}

To pass an entire object or array as a JSON string, use the {{json variable}} helper:

{
  "payload": "{{json getOrder.data}}"
}

Use the variable picker (+ variable) above the payload editor to insert common variables quickly.

Common Use Cases

Slack notification

Add an incoming webhook in your Slack workspace under Apps → Incoming Webhooks, then use that URL with a POST request:

{
  "text": "Order {{orderId}} has been fulfilled. Tracking: {{trackingNumber}}"
}

Trigger a Zapier Zap

Create a Zap with a Webhooks by Zapier trigger, copy the webhook URL, and send any JSON payload you want Zapier to receive:

{
  "order_id": "{{orderId}}",
  "customer": "{{customerName}}",
  "status": "shipped"
}

Trigger a Make (Integromat) scenario

Add a Webhooks module as the trigger in Make, copy the webhook URL, and POST your data:

{
  "event": "new_order",
  "data": "{{json getOrder.data}}"
}

Call an internal API

Send processed data to your own backend or microservice:

{
  "source": "syncaut",
  "action": "order_synced",
  "order_id": "{{orderId}}",
  "synced_at": "{{timestamp}}"
}

Referencing This Node's Output

Every Webhook node stores its result under the step name you provide. The output structure is:

{
  "status": 200,
  "statusText": "OK",
  "data": {},
  "url": "https://hooks.example.com/webhook",
  "method": "POST"
}

• {{stepName.status}} — the HTTP status code returned by the endpoint (e.g. 200, 201, 204)

• {{stepName.statusText}} — the status text (e.g. OK)

• {{stepName.data}} — the response body parsed as JSON, or { "text": "..." } if the response is not JSON

• {{stepName.url}} — the URL that was called

• {{stepName.method}} — the HTTP method used

You can use the status code in later steps to branch your workflow logic — for example, only proceed if {{notifyWebhook.status}} equals 200.

Troubleshooting

Webhook Error: Failed to fetch / ECONNREFUSED The URL is unreachable. Check that the endpoint is live and publicly accessible. Internal URLs like http://localhost will not work from Syncaut's servers.

Webhook Error: 4xx response The receiving endpoint rejected the request. Common causes are a malformed payload, missing required fields, or an incorrect URL. Check the endpoint's documentation for the exact payload structure it expects.

Webhook Error: 5xx response The receiving server encountered an error. This is an issue on the destination side. Check the service's status page or logs.

Invalid JSON payload Your payload has a syntax error or a variable resolved to an unexpected value (e.g. an object where a string was expected). Check the payload in the node editor. Use {{json variable}} if you are embedding an object inside a string field.

Response data is { "text": "..." } instead of an object The endpoint returned a non-JSON response (plain text, HTML, or empty body). Syncaut wraps this in a text field automatically. This is expected for some services — for example Slack returns the string ok on success.

Timeout after 30 seconds The receiving endpoint did not respond within 30 seconds. This is the maximum allowed timeout. Check whether the endpoint is slow to process or has a cold start delay.