GetHook is a webhook reliability gateway. Accept inbound webhooks, persist them durably, route to destinations, retry failures automatically — with full observability and replay capability.
The HTTP webhook protocol has no persistence, no retries, and no observability. Every integration you build is one outage away from data loss.
Webhooks fail without any notification. Your backend misses critical events — payments, user signups, order updates — and you find out days later.
A single network blip or deployment restart permanently drops the event. There's no built-in retry mechanism in the HTTP webhook protocol.
You can't see which events succeeded, which failed, or what the destination responded. Debugging is guesswork with provider logs.
Once an event is missed, it's gone. Without persistence, you can't replay events after a bug fix or infrastructure change.
From raw HTTP POST to guaranteed delivery — GetHook handles the entire lifecycle so your team doesn't have to.
Inbound or outbound events
Create a Source and get a unique endpoint URL. Point your webhook provider at it — Stripe, GitHub, Shopify, or anything HTTP. GetHook accepts the request, acknowledges it immediately (200 OK), and persists the payload durably to Postgres.
Pattern-based delivery rules
Define Routes that match events by type pattern (e.g. `payment.*`, `order.completed`, or `*` for all). Routes connect a source to one or more destinations. Multiple destinations can receive the same event simultaneously.
Automatic exponential backoff
The worker picks up queued events and delivers them to destinations over HTTPS with HMAC signatures. If delivery fails, events are automatically retried up to 5 times with exponential backoff: 0s → 30s → 2m → 10m → 1h. Dead-lettered events can be replayed anytime.
GetHook ships the full webhook infrastructure stack — from ingest to delivery to observability — without the enterprise bloat.
Accept webhooks from third-party providers (inbound) and send webhooks to your customers (outbound) — both in one platform. Unlike Svix which focuses only on outbound.
5-attempt exponential backoff: 0s → 30s → 2m → 10m → 1h. Events are never silently dropped. Dead-lettered events are preserved and replayable.
Pattern-based routing rules (e.g. `payment.*`) forward events to specific destinations. One event can fan out to multiple services simultaneously.
Replay any event at any time — even months later. When you fix a bug or add a new integration, replay missed events with one API call.
Every delivery is signed with HMAC-SHA256 in Stripe-compatible format (`t=<unix>,v1=<hex>`). Destinations can verify authenticity. Inbound webhooks are verified too.
Signing secrets and auth credentials are encrypted at rest with AES-256-GCM. API keys are SHA-256 hashed — never stored in plaintext.
Every delivery attempt is logged with status code, response body, and duration. Filter events by status, source, type, or time range. No more guessing.
Custom domains, brand settings (logo, colors, company name), and embedded portal support. Build webhook infrastructure under your own brand.
Sources support bearer token, HMAC signature verification, and custom header auth. Destinations support bearer, basic auth, API key headers, and OAuth2.
No Redis or Kafka required. GetHook uses a durable Postgres-backed queue with safe concurrent delivery — rock-solid reliability with zero extra infrastructure.
Every feature is available via REST API. Automate source creation, rotate API keys, and trigger replays from your CI/CD pipeline or Terraform.
Native SDKs for Node.js, Python, Go, PHP, Java, and Ruby — auto-generated from the OpenAPI spec and published to each language's package registry.
From payment processing to AI agent pipelines — GetHook makes webhooks reliable for any use case.
Never miss a payment event. Retry Stripe and Paddle webhooks automatically with exponential backoff.
Route Shopify order events to inventory, fulfillment, and notifications simultaneously.
Add reliable outbound webhook delivery to your product in days, not months.
Reliable event triggers for agentic pipelines and LLM workflows — with replay for debugging.
Trigger deployments and alerts from GitHub push and PR events, reliably.
Fan-out events from one source to many services with pattern-based routing. No Kafka required.
Buffer high-frequency device events and deliver reliably to your cloud backend.
Route security signals to your fraud engine with zero-loss delivery and immutable audit trails.
Capture every event for Snowflake, BigQuery, and Kafka. Replay for backfills.
Pre-configured signature verification for Stripe, Shopify, GitHub, Twilio, and 10+ more. Pick a provider and GetHook auto-wires the correct HMAC header — no docs-diving required.
Select Stripe, Shopify, GitHub, or any of 10+ presets. Signature verification is pre-configured.
Paste the signing secret from your provider dashboard. GetHook encrypts it with AES-256-GCM.
Copy your ingest URL, paste it in your provider's webhook settings. Events queue automatically.
Pre-configured delivery targets for 12+ services. Pick Slack, Discord, PagerDuty, HubSpot, or any automation tool — auth and headers are pre-wired.
GetHook records every delivery attempt with full context: destination URL, response status, response body, duration, and retry history. Filter by status, event type, or time range. When something goes wrong, you know exactly why.
Events are persisted to Postgres before the ingest endpoint even returns 200. If your destination is down for hours, no problem — events queue up and are delivered when it recovers. Dead-lettered events are preserved forever and replayable with a single API call.
Build customer-facing webhook infrastructure with GetHook. Custom domains, brand settings (logo, primary color, company name), and an embeddable portal — all configurable via API. Your customers never need to know GetHook exists.
Auto-generated from the OpenAPI spec and published to each language's package registry. Always in sync with the API.
import { GetHook } from "@gethook/node"
const client = new GetHook({ apiKey: "hk_..." })
// Send an outbound webhook
await client.events.publish({
eventType: "payment.succeeded",
payload: { amount: 4200, currency: "usd" },
})from gethook import GetHook
client = GetHook(api_key="hk_...")
# Send an outbound webhook
client.events.publish(
event_type="payment.succeeded",
payload={"amount": 4200, "currency": "usd"},
)import "github.com/gethook/gethook-go"
client := gethook.New("hk_...")
// Send an outbound webhook
client.Events.Publish(ctx, &gethook.PublishRequest{
EventType: "payment.succeeded",
Payload: map[string]any{"amount": 4200},
})PHP, Java, and Ruby SDKs available too. View all SDKs in the docs →
GetHook handles both inbound and outbound webhooks — unlike Svix (outbound only) and Hookdeck (inbound only) — at a fraction of the cost.
No per-seat pricing. No surprise bills. Start free, upgrade when you need more.
Perfect for side projects and testing.
For production workloads that need reliability.
For teams with high-volume or compliance requirements.
Inbound webhooks receive events FROM third-party providers (Stripe sending payment.succeeded to you). Outbound webhooks send events TO your customers (you notifying a customer's endpoint when something happens). GetHook handles both.
No. GetHook uses a durable Postgres-backed queue with safe concurrent delivery. This is sufficient for millions of events per day and eliminates the operational complexity of running Redis or Kafka.
Failed deliveries are retried up to 5 times with exponential backoff: immediately, after 30 seconds, 2 minutes, 10 minutes, and 1 hour. After 5 failures, events are moved to dead-letter status where they can be inspected and replayed manually.
Yes. Sources support HMAC signature verification for popular providers. You can configure a shared secret per source and GetHook will verify the provider's signature before persisting the event.
GetHook uses AES-256-GCM encryption for all secrets at rest, SHA-256 hashed API keys (never stored plaintext), HMAC-SHA256 for delivery signatures, and per-tenant data isolation. It's designed for production from day one.
Nothing is lost. Events are persisted to Postgres before the ingest endpoint even returns 200. If your destination is unreachable for hours, GetHook queues the events and delivers them as soon as it recovers — following the full exponential backoff schedule.
Deploy GetHook in under 5 minutes. Your first 10,000 events are free — no credit card, no expiry.