> ## 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.

# Get started with Webhook Debugger & Logger

> Learn how to generate a temporary webhook URL, send your first test request, and inspect the captured payload — all in under five minutes.

Webhook Debugger & Logger generates temporary, public endpoints that capture every incoming request in full — headers, body, query params, response, timing, and IP. This guide walks you through starting the actor, sending a test request, and inspecting the result.

<Steps>
  <Step title="Start the actor">
    Configure the actor with a minimal input to generate three webhook endpoints, retain them for 24 hours, and enable JSON parsing and sensitive header masking.

    **On Apify console:** paste this JSON into the input tab and click **Start**.

    **Locally:** save it as your `INPUT` environment variable and run `npm start`.

    ```json theme={null}
    {
      "urlCount": 3,
      "retentionHours": 24,
      "enableJSONParsing": true,
      "maskSensitiveData": true
    }
    ```
  </Step>

  <Step title="Get your webhook URLs">
    After the actor starts, call `GET /info` on your run's base URL to see the active webhook endpoints.

    ```bash theme={null}
    curl "https://<run-id>.runs.apify.net/info"
    ```

    The response includes an `activeWebhooks` array. Each entry has an `id` you use to receive traffic and an `expiresAt` timestamp.

    ```json theme={null}
    {
      "version": "3.0.5",
      "status": "Enterprise Suite Online",
      "system": {
        "authActive": false,
        "retentionHours": 24,
        "maxPayloadLimit": "10.0MB",
        "webhookCount": 3,
        "activeWebhooks": [
          {
            "id": "wh_demo123",
            "expiresAt": "2026-04-03T10:20:14.527Z"
          }
        ]
      }
    }
    ```

    Copy one of the webhook IDs — you'll use it in the next step.
  </Step>

  <Step title="Send a test request">
    POST a JSON payload to your webhook URL. Replace `<run-id>` with your actual run ID and `wh_demo123` with the webhook ID from `/info`.

    ```bash theme={null}
    curl -X POST "https://<run-id>.runs.apify.net/webhook/wh_demo123" \
      -H "Content-Type: application/json" \
      -d '{"event":"payment.success","provider":"stripe","amount":9999}'
    ```

    The actor responds with `200 OK` and stores the full request envelope.
  </Step>

  <Step title="Inspect the captured event">
    Query `GET /logs` to retrieve the captured event. The response includes the method, status code, content type, processing time, and the parsed JSON body.

    ```bash theme={null}
    curl "https://<run-id>.runs.apify.net/logs"
    ```

    ```json theme={null}
    {
      "count": 1,
      "items": [
        {
          "id": "evt_demo123",
          "timestamp": "2026-04-02T10:25:02.319Z",
          "webhookId": "wh_demo123",
          "requestId": "req_demo123",
          "method": "POST",
          "statusCode": 200,
          "contentType": "application/json",
          "processingTime": 10,
          "size": 61,
          "remoteIp": "203.0.113.10",
          "requestUrl": "/webhook/wh_demo123",
          "body": {
            "event": "payment.success",
            "provider": "stripe",
            "amount": 9999
          }
        }
      ]
    }
    ```

    `processingTime` is the server-side processing cost only. It does not include any configured `responseDelayMs` latency simulation.
  </Step>

  <Step title="Stream events live (optional)">
    To watch incoming requests in real time, connect to the SSE stream at `/log-stream`. This is useful when you want to observe events as they arrive without polling `/logs`.

    ```bash theme={null}
    curl -N "https://<run-id>.runs.apify.net/log-stream"
    ```

    The server sends comment frames for connection and keepalive traffic, and `data:` frames for each captured event.

    ```text theme={null}
    : connected

    data: {"id":"evt_123","webhookId":"wh_demo123","method":"POST","statusCode":200}

    : heartbeat
    ```

    Heartbeats are sent every 30 seconds. The stream has no server-side webhook filter — filter by `webhookId` on the client side if you need to isolate a specific endpoint.
  </Step>
</Steps>

## Next steps

<CardGroup cols={2}>
  <Card title="Secure your endpoints" icon="lock" href="/security/authentication">
    Add an API key, restrict access by IP, or mask sensitive headers in stored logs.
  </Card>

  <Card title="Verify provider signatures" icon="shield-check" href="/security/signature-verification">
    Automatically validate Stripe, GitHub, Shopify, Slack, and custom HMAC signatures.
  </Card>

  <Card title="Replay captured events" icon="rotate" href="/features/replay">
    Resend any stored event to a new destination URL after fixing a bug.
  </Card>

  <Card title="Configure API mocking" icon="masks-theater" href="/features/mocking">
    Return custom status codes, headers, bodies, and artificial latency to simulate downstream behavior.
  </Card>
</CardGroup>