Never miss a webhook. Free, open-source, deploys to Cloudflare in 30 seconds.

Gateway runs on Cloudflare Workers. SDK (@hookpipe/providers) runs anywhere — Node.js, Deno, Bun, Lambda.

Status: Alpha — Built by a solo developer in TypeScript. Fully functional and tested, not yet proven in production. See Status for details.

Webhooks are deceptively simple — until they aren't. Providers send them once and move on. If your server is down, slow, or returns an error, that event is gone. hookpipe sits between webhook sources and your application to make sure nothing gets lost.

• Built-in providers — Stripe, GitHub, Slack, Shopify, Vercel out of the box. Each provider includes signature verification, typed event catalogs, and setup instructions. Community-extensible via defineProvider() — one file, four fields.
• Payload schemas — Zod schemas for type-safe webhook payload validation. @hookpipe/providers ships createVerifier() and createHandler() — verify signatures and handle webhooks in any TypeScript project, no hookpipe runtime needed.
• Never miss a webhook — Incoming payloads are immediately queued at the edge before your backend even processes them.
• Reliable delivery — Automatic retries with exponential backoff, configurable per destination. Circuit breaker auto-pauses unhealthy destinations.
• Zero infrastructure — No Docker, PostgreSQL, or Redis. Runs entirely on Cloudflare Workers.
• Free to start — Runs on Cloudflare's free tier (~50K events/day). No VM costs, $0 idle.
• Agent-native — Three integration paths: CLI subprocess (--json), event streaming (hp listen), and MCP server (hp mcp). AI agents operate hookpipe without reading docs.

Click the Deploy to Cloudflare button above. Cloudflare will provision D1, KV, Queues, Durable Objects, and R2 automatically.

git clone https://github.com/hookpipe/hookpipe.git
cd hookpipe
pnpm install
pnpm --filter @hookpipe/shared build
pnpm --filter @hookpipe/worker dev

Receive real webhooks on your local machine — no port forwarding, no exposed IP:

npm i -g hookpipe

hookpipe dev --port 3000 --provider stripe --secret whsec_xxx

✓ Tunnel established
✓ Stripe signature verification: enabled

  Webhook URL:  https://random-words.trycloudflare.com
  Forwarding:   → http://localhost:3000

[12:00:01] payment_intent.succeeded  ✓ sig  → localhost:3000 (200, 45ms)

Paste the Webhook URL into your Stripe Dashboard. hookpipe verifies signatures locally and forwards to your app. cloudflared is downloaded automatically if not installed.

npm i -g hookpipe

# Point CLI to your hookpipe instance
hookpipe config set api_url http://localhost:8787

# Create your first API key (only needed once, on fresh deploy)
curl -X POST http://localhost:8787/api/v1/bootstrap \
  -H "Content-Type: application/json" \
  -d '{"name": "admin"}'
# → Returns your API key (hp_sk_xxx). Store it securely — shown only once.

hookpipe config set token hp_sk_xxx

# Connect Stripe in one command
hookpipe connect stripe \
  --secret whsec_your_stripe_webhook_secret \
  --to https://myapp.com/webhooks \
  --events "payment_intent.*"

✓ Connected stripe → https://myapp.com/webhooks

  Source:       src_abc123 (stripe)
  Destination:  dst_def456 (myapp-com)
  Events:       payment_intent.*
  Webhook URL:  http://localhost:8787/webhooks/src_abc123

  Next steps:
    Add the webhook URL as an endpoint in Stripe Dashboard → Developers → Webhooks
    Dashboard: https://dashboard.stripe.com/webhooks

One command creates source, destination, and subscription. Paste the Webhook URL into your provider's dashboard.

hookpipe forwards the original payload to your URL with hookpipe headers added:

app.post('/webhooks', (req, res) => {
  // hookpipe already verified the signature before forwarding
  const eventId = req.headers['x-hookpipe-event-id'];  // for deduplication
  const { type, data } = req.body;                      // original provider payload
  // Return 2xx to acknowledge. Non-2xx triggers retry.
  res.status(200).json({ received: true });
});

# Stream events in real-time (like tail -f)
hookpipe tail --payload

# Agent consumption pipeline — resumable, auto-ack, backpressure
hookpipe listen --consumer my-bot --source src_abc123 | python agent.py

# List recent events
hookpipe events ls --json --limit 10

hookpipe runs entirely on Cloudflare's edge network with zero external dependencies:

Webhook Source (Stripe, GitHub, ...)         Your Application (API)
        |                                           ^
        v                                           |
  [Ingress Worker] --> [Queue] --> [Consumer] --> [Delivery DO] --> fetch()
     |       |                        |               |
     v       v                        v               v
  [Rate    [KV]                     [D1]            [R2]
  Limiter  idempotency           config/logs     payload archive
    DO]

Providers are knowledge-only modules — they describe what to verify and what the payload looks like, not how to verify. The core engine owns all processing logic.

@hookpipe/providers is published as a standalone npm package. Use it with the full hookpipe stack, or independently in any TypeScript project:

import { stripe, createVerifier, createHandler } from '@hookpipe/providers';

// Verify signatures — one API for every provider
const verify = createVerifier(stripe, { secret: 'whsec_xxx' });
const isValid = await verify(rawBody, headers);

// Full webhook handler (verify + parse + challenge)
const webhook = createHandler(stripe, { secret: 'whsec_xxx' });
const result = await webhook.handle(body, headers);
// result.verified, result.eventType, result.eventId, result.payload

// Browse 530+ event types
Object.keys(stripe.events).length;  // 260 — generated from stripe@20.4.1 SDK types

Stripe and GitHub event catalogs are auto-generated from official SDK types (stripe@20.4.1, @octokit/webhooks-types@7.6.1). Custom verification schemes (e.g. HASH IV/KEY for Taiwan payment gateways) are supported via the custom verification type.

Schemas are progressive — added per event as the project matures. Providers also support encrypted payloads (JWS, AES) via the decode capability, enabling integration with services beyond simple HMAC signing. See the Provider Design Guide for the full specification.

Three-tier ecosystem:

hookpipe provides at-least-once delivery. Each stage of the pipeline is protected:

What hookpipe does NOT guarantee:

• Exactly-once delivery — your handler may receive the same event more than once. Use the X-Hookpipe-Event-Id header for idempotency.
• Ordering — events may arrive out of order under retry scenarios.

hookpipe runs on Cloudflare's free tier. Some services (R2, Queues) may require a Cloudflare account with billing enabled.

Free tier capacity: ~50,000 events/day (bottleneck: D1 writes).

Workers Paid ($5/month) — for higher volume:

For comparison: self-hosting Convoy or Svix requires a VM + PostgreSQL + Redis = $15-45/month minimum, regardless of volume.

Three retry strategies, configurable per destination:

Default exponential schedule (10 retries, 1 min base, 24h cap):

Each destination can override strategy, retry count, interval, and which HTTP status codes trigger retries. Destinations can also respond with a Retry-After header to control retry timing.

# npm
npm i -g hookpipe

# Homebrew
brew install hookpipe/hookpipe/hookpipe

hookpipe dev --port 3000 --provider stripe --secret whsec_xxx   # Stripe with verification
hookpipe dev --port 3000 --provider github --secret ghsec_xxx   # GitHub with verification
hookpipe dev --port 3000                                         # Any webhook, no verification

Uses Cloudflare Quick Tunnel — no account needed, no port forwarding, no IP exposure.

hookpipe connect stripe --secret whsec_xxx --to https://api.example.com/hooks --events "payment_intent.*"
hookpipe connect github --secret ghsec_xxx --to https://api.example.com/hooks --events "push,pull_request"
hookpipe connect stripe --secret whsec_stg --to https://staging.example.com/hooks --name stripe-staging

hookpipe providers ls                      # list all providers
hookpipe providers describe stripe --json  # events, presets, verification

The CLI is designed as an agent-first interface with three integration paths:

# Stream events to an agent (resumable after restart)
hp listen --consumer my-bot --source src_stripe | python agent.py

# MCP for Claude Desktop / Cursor / Windsurf
# Add to config: {"mcpServers":{"hookpipe":{"command":"hookpipe","args":["mcp"]}}}

# CLI subprocess: discover → validate → execute
hp providers describe stripe --json
hp connect stripe --secret whsec_xxx --to https://... --dry-run
hp connect stripe --secret whsec_xxx --to https://... --json

All commands support --json, --dry-run, -d/--data, --fields, hookpipe schema. See packages/cli/AGENTS.md for the full agent guide.

Webhook ingestion, queue-based delivery, configurable retry strategies, circuit breaker, API key auth, export/import/migrate, agent-optimized CLI.

• hookpipe connect one-shot command
• hookpipe providers ls/describe catalog
• Built-in Stripe, GitHub, Slack, Shopify, Vercel providers with event type catalogs and Zod payload schemas
• @hookpipe/providers published to npm as standalone package
• Community-extensible via defineProvider() — one file, four fields, publish to npm or GitHub

• hp listen — agent consumption with server-side cursor, auto-ack, backpressure (✅ done)
• hp mcp — MCP server for LLM integration (✅ done)
• hp tail --payload — stream events with full payloads (✅ done)
• createVerifier() / createHandler() — standalone webhook SDK (✅ done)
• 530+ codegen event types from Stripe/GitHub official SDKs (✅ done)
• DLQ notifications via webhook callback (✅ done)
• Structured JSON logging, delivery metrics, Cloudflare Logpush integration (planned)

Static SPA dashboard on Cloudflare Pages. Connects to any hookpipe instance via API URL + token.

Comprehensive test coverage, load testing results, security audit, stable API, semantic versioning.

pnpm install
pnpm --filter @hookpipe/shared build
pnpm --filter @hookpipe/providers build
pnpm --filter @hookpipe/worker dev       # Start local dev server
pnpm --filter @hookpipe/worker test      # Run tests
pnpm --filter @hookpipe/worker typecheck # Type check
pnpm --filter hookpipe build             # Build CLI

123 tests across 10 test files, running on the actual Cloudflare Workers runtime via vitest-pool-workers:

• Ingress: signature verification (Stripe t=,v1=, GitHub HMAC, Shopify Base64), idempotency dedup, event type parsing
• Delivery: retry strategies (exponential/linear/fixed), status code filtering, circuit breaker state transitions
• API: CRUD for all resources, authentication, bootstrap, input validation, secret masking
• Transfer: export/import roundtrip, ID remapping, dedup by name

hookpipe/
├── packages/
│   ├── worker/              # Cloudflare Worker (webhook engine)
│   │   ├── src/
│   │   │   ├── index.ts     # Worker entry point and Hono router
│   │   │   ├── auth/        # API key authentication middleware
│   │   │   ├── ingress/     # Webhook ingestion and signature verification
│   │   │   ├── queue/       # Queue consumer and dispatch logic
│   │   │   ├── delivery/    # Durable Object retry management + circuit breaker
│   │   │   ├── api/         # REST API handlers
│   │   │   ├── db/          # Drizzle ORM schema and queries
│   │   │   └── lib/         # Shared utilities (crypto, errors, IDs)
│   │   ├── migrations/      # D1 database migrations
│   │   └── test/            # Integration tests (vitest + Workers runtime)
│   ├── shared/              # Shared TypeScript types
│   ├── cli/                 # CLI tool (npm: hookpipe)
│   └── providers/           # Provider definitions (npm: @hookpipe/providers)
├── .github/workflows/       # CI (typecheck + test)
├── turbo.json               # Turborepo task config
├── pnpm-workspace.yaml      # pnpm workspaces
└── LICENSE                  # Apache 2.0

hookpipe focuses on receiving and reliably forwarding webhooks. It is not a replacement for outgoing webhook services.

• Zero infrastructure — No Docker, PostgreSQL, or Redis. Runs entirely on Cloudflare Workers.
• Free to start — Runs on Cloudflare's free tier (~50K events/day). No VM costs, $0 idle.
• Deploy in 30 seconds — One-click Cloudflare deploy button provisions everything automatically.
• Agent-optimized — CLI with --json, --dry-run, schema introspection. AI agents can operate hookpipe without reading docs.
• Apache 2.0 — No restrictions on commercial use or self-hosting.
• Local dev tunnel — hookpipe dev creates a secure tunnel to localhost via Cloudflare. No port forwarding, no IP exposure.

These providers are maintained by the community. To add yours, submit a PR.

We welcome contributions! The easiest way to start is building a provider — it's a single file with a well-defined interface, and you don't need npm or a review process.

• Build a provider — ~10 minutes from template to working provider
• Provider Design Guide — full capability specification
• CONTRIBUTING.md — development setup, code style, how to submit PRs

Apache 2.0

hookpipe is not affiliated with, endorsed by, or sponsored by Cloudflare, Inc. "Cloudflare" and the Cloudflare logo are trademarks of Cloudflare, Inc.