> ## Documentation Index
> Fetch the complete documentation index at: https://supahooks.ar27111994.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Debug webhooks from Zapier, Make, and n8n

> Use Webhook Debugger as a buffer between your source system and Zapier, Make, or n8n to inspect payloads, map fields, and replay events to fix flows.

Low-code automation tools like Zapier, Make (Integromat), and n8n consume webhooks from source systems, but the field names and payload structure aren't always obvious until you see a real delivery. Use the Webhook Debugger as a transparent buffer — capture the real payload first, use the logged structure to build your mapping, then forward the traffic to your automation tool.

## Use case: intercept webhooks before they reach your automation tool

Instead of pointing your source system directly at Zapier or Make, point it at the actor first. The actor captures the full request and forwards it onward. If the downstream tool fails or you need to rebuild a flow, you can replay any captured event without waiting for a new real delivery.

The built-in forwarder always uses `POST`. If your automation tool expects a different method or shape, use `customScript` to normalize the event before it is forwarded.

## Start in observe mode

Run the actor in observe mode first while you collect a representative sample of the real payload. Do not add a `jsonSchema` gate until you know the field structure is stable.

```json theme={null}
{
  "urlCount": 1,
  "retentionHours": 48,
  "authKey": "automation-bridge-key",
  "enableJSONParsing": true,
  "maskSensitiveData": true,
  "forwardUrl": "https://hooks.zapier.com/hooks/catch/11111/aaaaa/",
  "forwardHeaders": true,
  "defaultResponseCode": 200,
  "defaultResponseBody": "{\"received\":true}"
}
```

Replace the `forwardUrl` with your Zapier catch hook URL, Make webhook URL, or n8n webhook trigger URL.

<Steps>
  <Step title="Start the actor">
    Launch the actor with the observe-mode config above. Call `/info` to get the generated `/webhook/:id` URL.
  </Step>

  <Step title="Point your source system at the actor URL">
    In your source system (for example, Shopify, Stripe, or a custom app), set the webhook destination to the `/webhook/:id` URL from `/info` instead of your automation tool's URL.
  </Step>

  <Step title="Trigger a few real events">
    Perform the actions in the source system that send webhooks — place a test order, fire a test event, or use the source system's built-in test webhook button.
  </Step>

  <Step title="Inspect the captured payloads">
    Query `/logs` to see the full payload structure, including exact field names and nesting:

    ```bash theme={null}
    GET /logs?webhookId=wh_abc123&limit=10
    ```

    Use the parsed JSON body to identify the exact field paths you need to map in your Zap, Make scenario, or n8n workflow.
  </Step>
</Steps>

## Understand the payload structure

With `enableJSONParsing: true`, every captured JSON body is stored as a structured object you can query by field:

```bash theme={null}
GET /logs?webhookId=wh_abc123&body.financial_status=paid
```

This lets you verify that the field name and value your automation tool expects actually matches what the source system sends.

A captured payload from an order system might look like this:

```json theme={null}
{
  "id": "evt_8m2L5p9xR",
  "webhookId": "wh_abc123",
  "method": "POST",
  "statusCode": 200,
  "body": {
    "order_id": "1001",
    "financial_status": "paid",
    "line_items": [
      { "sku": "WIDGET-001", "quantity": 2 }
    ]
  }
}
```

Copy the exact field paths from the captured body into your Zap field mapper, Make module, or n8n expression.

## Add schema enforcement after your mapping is stable

Once you know the payload structure and your automation mapping is working, optionally add a `jsonSchema` gate to reject malformed events before they reach your tool:

```json theme={null}
{
  "urlCount": 1,
  "retentionHours": 48,
  "authKey": "automation-bridge-key",
  "enableJSONParsing": true,
  "maskSensitiveData": true,
  "forwardUrl": "https://hooks.zapier.com/hooks/catch/11111/aaaaa/",
  "forwardHeaders": true,
  "defaultResponseCode": 200,
  "defaultResponseBody": "{\"received\":true}",
  "jsonSchema": "{\"type\":\"object\",\"required\":[\"financial_status\"],\"properties\":{\"financial_status\":{\"const\":\"paid\"}}}"
}
```

<Warning>
  `jsonSchema` is a hard gate. Payloads that fail validation receive a `400` response and are not stored as captured events. Start without it so you can observe the full range of payloads your source system sends.
</Warning>

## Replay to your real endpoint after mapping fields

If the downstream automation tool fails or you need to rebuild a flow, replay any captured event without triggering a new source action:

```bash theme={null}
curl -X POST \
  "https://<run-id>.runs.apify.net/replay/wh_abc123/evt_8m2L5p9xR?url=https%3A%2F%2Fhooks.zapier.com%2Fhooks%2Fcatch%2F11111%2Faaaaa%2F"
```

## Common pain points

| Pain point                                   | What the actor supports                                                                                                               |
| :------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------ |
| Mapping nested JSON into Zapier or Make      | Capture the real payload first with `enableJSONParsing`, then copy exact field paths from `/logs` into your workflow tool             |
| Silent downstream failures                   | Check `/system/metrics` for forwarding error counts to surface failures that occurred after the sender received a successful response |
| Rejecting noise without losing observability | Avoid starting with `jsonSchema` — sample the traffic first, then enable the schema once the event shape is stable                    |