WebHook Tester

WebHook Tester is a lightweight, self‑hosted service designed for developers who need an on‑premises solution to capture, inspect, and manipulate HTTP webhook traffic. Built in Go for maximum performance and compiled with a ReactJS UI into a single binary, the application eliminates external asset dependencies and runs out of the box in any container‑friendly environment. Its core purpose is to expose a random, secure endpoint for each session that can be configured with custom status codes, headers, bodies, and artificial latency, making it ideal for debugging integration flows that rely on external callbacks.

The stack is intentionally minimal: the backend is a pure Go HTTP server exposing REST endpoints for creating, retrieving, and deleting webhook records. It leverages the standard library’s net/http along with Gorilla’s mux for routing and the gorilla/websocket package to push real‑time updates to connected clients. Data persistence is abstracted behind a driver interface, with three concrete implementations: an in‑memory map for transient debugging, a Redis client (using go-redis/v8) for shared state across replicas, and a filesystem driver that serializes requests as JSON files. Pub/sub for WebSocket notifications follows the same pattern, allowing either an in‑memory channel or Redis pub/sub to coordinate multiple instances behind a load balancer.

The UI is a single‑page React application bundled with Vite and embedded in the Go binary via embed.FS. This approach removes the need for a separate web server or static file host, simplifying deployment. WebSocket support is native; the UI subscribes to a /ws endpoint and receives push notifications whenever a new request hits an active webhook, providing instant visibility without polling.

• Dynamic Endpoint Generation – Each invocation of /new returns a unique UUID‑based URL that automatically registers the desired response configuration.
• Customizable Responses – Developers can set HTTP status, Content-Type, arbitrary headers, and body payload (JSON or plain text) through a simple query string or JSON payload.
• Artificial Delay – A delay parameter introduces latency, useful for testing timeout handling in downstream services.
• Request Recording – All incoming requests are captured with headers, body, query parameters, and timestamps; they can be queried via /webhooks/{id} or streamed live.
• Pub/Sub – WebSocket notifications are emitted on every new request, enabling dashboards or CI pipelines to react immediately.
• Storage Drivers – Swap between memory (fastest), Redis (distributed, persistent), or filesystem for long‑term retention without code changes.
• Health & Metrics – /healthz liveness probe and JSON/structured logging support facilitate integration with Kubernetes or other orchestrators.

The application ships as a multi‑architecture Docker image built on scratch, ensuring minimal footprint and no runtime dependencies. It runs as an unprivileged user (1000:1000) inside containers, enhancing security. For local development or single‑instance deployments, the default in‑memory storage is sufficient and incurs negligible overhead. In production scenarios where multiple replicas must share state, the Redis driver becomes mandatory; a single Redis cluster can be provisioned behind a load balancer to provide high availability. The ngrok tunnel driver, exposed via the --tunnel-driver flag, allows exposing a local instance to external services without opening inbound ports, simplifying webhook testing from remote CI environments.

WebHook Tester exposes a RESTful API that can be consumed programmatically. Developers can script the creation of endpoints, set response expectations, and poll for captured payloads in CI pipelines. The WebSocket interface is protocol‑agnostic; any client that supports RFC 6455 can subscribe to real‑time events. The modular driver architecture means new storage or pub/sub backends can be added by implementing the corresponding interfaces, making the system highly extensible. Additionally, because the UI is a React SPA, custom widgets or dashboards can be built on top of it without touching the core Go code.

Configuration is driven entirely by command‑line flags, making it straightforward to integrate into Docker Compose or Kubernetes manifests. The source code is well‑documented, with unit tests covering each driver and handler. Community support is active on GitHub; issues and pull requests are promptly reviewed, and the project adheres to permissive MIT licensing. The single‑binary distribution eliminates dependency hell, while the built‑in health checks and structured logs simplify observability in modern cloud environments.

• CI/CD Webhook Testing – Spin up an instance in a pipeline, create a temporary endpoint, and capture payloads from services like GitHub or Stripe.
• Local Development – Test outbound webhooks from a local server without exposing it to the internet; adjust response delays or headers on the fly.
• Performance Benchmarking – Simulate slow responders to evaluate retry logic and timeout handling in downstream systems.
• Security Auditing – Inspect incoming request headers, body payloads, and timing to validate that sensitive data is handled correctly.

WebHook Tester offers a