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

# Deploy Webhook Debugger & Logger: Apify or self-hosted

> Run Webhook Debugger & Logger on the Apify platform with no setup required, or self-host with Node.js or Docker in your own environment.

Webhook Debugger & Logger runs in two modes: on the Apify platform, where you get a public webhook URL within seconds, or self-hosted via Node.js or Docker for environments where you control the infrastructure. Choose the path that fits your workflow.

<Tabs>
  <Tab title="Apify platform">
    ## Run on Apify

    The Apify platform is the fastest way to get a live webhook endpoint. No installation, no port forwarding — Apify handles the public URL and storage for you.

    <Steps>
      <Step title="Open the actor in the Apify Store">
        Go to [apify.com/ar27111994/webhook-debugger-logger](https://apify.com/ar27111994/webhook-debugger-logger) and click **Try for free**.
      </Step>

      <Step title="Configure your input">
        Set your preferred options in the input form. A minimal configuration to get started:

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

        See [Input reference](/configuration/input-reference) for all available options.
      </Step>

      <Step title="Start the actor">
        Click **Start**. The actor generates your webhook endpoints immediately and exposes them through the Apify web server URL.
      </Step>

      <Step title="Find your webhook URLs">
        Once the actor is running, open the web server URL and call `/info` to retrieve your active webhook endpoints and the full API surface.
      </Step>
    </Steps>

    <Note>
      Keep the actor warm with **Apify Standby mode** so your webhook endpoints stay ready for incoming traffic without paying a cold-start penalty on each request. This is especially useful for long-running debug sessions or when you need the endpoint available on demand.
    </Note>
  </Tab>

  <Tab title="Node.js">
    ## Self-host with Node.js

    Run the server directly with Node.js if you have the runtime available and want the simplest local setup.

    **Requirements:** Node.js 20 or later.

    <Steps>
      <Step title="Clone the repository and install dependencies">
        ```bash theme={null}
        git clone https://github.com/ar27111994/webhook-debugger-logger.git
        cd webhook-debugger-logger
        npm install
        ```
      </Step>

      <Step title="Configure your environment">
        Copy `.env.example` to `.env` and set your preferred values:

        ```bash theme={null}
        cp .env.example .env
        ```

        At minimum, you can set the actor input via the `INPUT` variable:

        ```dotenv theme={null}
        ACTOR_WEB_SERVER_PORT=8080
        INPUT={"urlCount":3,"retentionHours":24,"authKey":"your-secret-key"}
        APIFY_LOCAL_STORAGE_DIR=./storage
        ```
      </Step>

      <Step title="Start the server">
        ```bash theme={null}
        npm start
        ```

        The server listens on `http://localhost:8080` by default. Open `/info` to confirm it is running and to retrieve your webhook URLs.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Docker">
    ## Self-host with Docker

    Use Docker to run a self-contained, production-ready container without installing Node.js locally.

    <Steps>
      <Step title="Build the image">
        ```bash theme={null}
        docker build -t webhook-debugger-logger .
        ```

        The default build target produces the standard image. To build the standalone target explicitly:

        ```bash theme={null}
        docker build --target runtime-standalone -t webhook-debugger-logger .
        ```
      </Step>

      <Step title="Run the container">
        ```bash theme={null}
        docker run --rm -p 8080:8080 \
          -e ACTOR_WEB_SERVER_PORT=8080 \
          -e APIFY_LOCAL_STORAGE_DIR=/app/storage \
          webhook-debugger-logger
        ```

        Pass your actor input as the `INPUT` environment variable to configure the run:

        ```bash theme={null}
        docker run --rm -p 8080:8080 \
          -e ACTOR_WEB_SERVER_PORT=8080 \
          -e APIFY_LOCAL_STORAGE_DIR=/app/storage \
          -e INPUT='{"urlCount":3,"retentionHours":24,"authKey":"your-secret-key"}' \
          webhook-debugger-logger
        ```
      </Step>

      <Step title="Verify the server is ready">
        The container exposes a `/ready` endpoint you can use to confirm startup:

        ```bash theme={null}
        curl http://localhost:8080/ready
        ```

        Then call `/info` to retrieve your active webhook URLs and the full API surface.
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Environment configuration

These are the key environment variables for both Node.js and Docker deployments.

| Variable                  | Purpose                                                                                                 | Default     |
| ------------------------- | ------------------------------------------------------------------------------------------------------- | ----------- |
| `ACTOR_WEB_SERVER_PORT`   | HTTP port the server listens on                                                                         | `8080`      |
| `INPUT`                   | Full actor input as a JSON string — sets `urlCount`, `retentionHours`, `authKey`, and all other options | unset       |
| `APIFY_LOCAL_STORAGE_DIR` | Directory for captured events, webhook state, and large payload offloads                                | `./storage` |
| `LOG_LEVEL`               | Logging verbosity (`info`, `debug`, `warn`, `error`)                                                    | `info`      |

For the full list of environment variables and advanced tuning options, see [Environment variables](/configuration/environment-variables).

<Warning>
  Generated webhook URLs are public unless you set `authKey`, `allowedIps`, or `signatureVerification` in your input. Do not point sensitive production traffic at unsecured endpoints.
</Warning>