Skip to content

Why Sparrow: self-hosted webhooks as a service

Sparrow is open-source webhooks as a service that you host yourself. Your application publishes an event once with one POST; Sparrow fans it out to every subscribed endpoint, signs each request, retries failures, tracks the health of each endpoint, and keeps a full delivery history. No per-message pricing, no vendor lock-in, no external dependencies beyond PostgreSQL.

Sparrow is MIT-licensed, and all core features are available in the open-source codebase (including envelope encryption, webhook signing, retries, and health tracking).

Sending one HTTP request is easy. Sending webhooks to customers reliably is not, which is why “webhooks as a service” exists as a product category. A webhook service takes over:

  • Fan-out: one event, delivered to every endpoint subscribed to its type.
  • Retries: exponential backoff, separating retryable failures (timeouts, 5xx, 429) from permanent ones.
  • Signing: a signature on every request so receivers can verify it came from you (Standard Webhooks).
  • Endpoint health: noticing a receiver that has been failing for hours and pausing it without losing what was sent to it.
  • Delivery log and replay: what was sent, what the receiver answered, and a way to retry it.
  • Customer self-service: a portal where your customers add endpoints, choose events and inspect their own deliveries.

Sparrow does all of these; How it works shows the pipeline.

There are two ways to get webhooks as a service:

Managed (SaaS)

A vendor runs the delivery infrastructure. Nothing to operate; you pay per message or per tier, and every payload passes through the vendor’s network.

Self-hosted (Sparrow)

You run the service next to your application. Payloads never leave your network, there is no per-message price, and the only dependency is a PostgreSQL database you probably already operate.

Pick self-hosted when payloads must stay inside your network (regulated data, internal systems), when message volume makes per-message pricing expensive, or when you would rather run one more container than add a vendor. Pick managed when you want no infrastructure at all.

Production-Grade Delivery

At-least-once delivery with exponential backoff, classified delivery errors, per-webhook health tracking (healthy/degraded/unhealthy state machine), and automatic retry logic that distinguishes retryable failures from permanent ones.

Cryptographic Signing

Every delivery is signed in the Standard Webhooks format — HMAC-SHA256 by default, or Ed25519 per webhook for public-key verification. Ed25519 keypairs are generated automatically on opt-in.

Encryption at Rest

Webhook secrets, signing keys, and sensitive headers are envelope-encrypted with AES-256-GCM and per-record data encryption keys. Not just “encrypted in the database” – actual envelope encryption with key hierarchy.

Zero External Dependencies

PostgreSQL is the only infrastructure requirement. No Redis, no message broker, no object storage. The River job queue runs inside PostgreSQL. One database to back up, monitor, and scale.

Consumer Self-Service Portal

Hand each consumer a scoped, expiring link to a portal where they register their own endpoints, manage subscriptions, and inspect and retry their own deliveries – no admin API key, no visibility into anyone else’s data. One admin call mints the token; it is DB-backed (revocable, expiring) and rides in the URL fragment. This is the App Portal capability Svix is known for – built in, no extra service to run.

The table below compares Sparrow with the main alternatives for webhook delivery: Svix (open-source + cloud), Convoy (source-available, Elastic 2.0), Hookdeck (SaaS platform with open-source Outpost agent), AWS SNS (managed), and building it yourself (DIY).

Capability Sparrow Svix Convoy Hookdeck AWS SNS DIY
Fully open source (MIT) Yes Partial (OSS core, paid features) No (Elastic 2.0, source-available) Partial (Outpost OSS, core platform closed) No Yes
Self-hosted Yes Yes Yes Partial (Outpost self-hosted, platform SaaS) No (Managed) Yes
No vendor per-message pricing (self-hosted) Yes (self-hosted; infra only) No Yes (self-hosted) No No Yes (your infra only)
Infra complexity (core deps) PostgreSQL only PostgreSQL (+ Redis for HA) PostgreSQL + Redis SaaS Managed Varies
Job queue backend PostgreSQL (River) Redis-backed queue/workers Background workers + Redis Managed Managed Varies
Webhook signing Dual HMAC-SHA256 + Ed25519 HMAC-SHA256 HMAC-SHA256 HMAC-SHA256 X.509 signature (not HMAC) Manual
Security model for secrets Envelope encryption with per-record DEKs Encrypted at rest (service-managed keys) Deployment-dependent (no built-in envelope hierarchy) Vendor-managed encryption Vendor-managed encryption Manual
Payload transformation Go templates per subscription (37 functions, incl. structural + arithmetic) Varies by edition/plan Yes (JS transform) Yes (JS transform) No Manual
Per-webhook rate limiting Leaky bucket (DB-backed) Available (details vary) Yes Yes Regional quotas Manual
Delivery semantics At-least-once + explicit idempotency model At-least-once + retries At-least-once + retries At-least-once + replay At-least-once Varies
Delivery health model State machine (healthy/degraded/unhealthy) + configurable auto-disable that holds, not drops, deliveries Endpoint status Circuit breaker Dashboard metrics CloudWatch Manual
Error classification 10 protocol-aware categories with retryability flags Basic status and error reporting Success/failure Categorized CloudWatch Manual
Bulk retry/re-push Deterministic snapshot-based (up to 10K) Not in OSS Manual retry UI retry No Manual
Idempotent ingestion Built-in dedup with idempotency keys Application-level (no OSS ingest dedup) Event IDs Dedup available Message dedup (5min) Manual
REST / OpenAPI API Yes (OpenAPI 3.1 spec) Yes (REST) Yes (REST) Yes (REST) No Manual
Event schema validation Soft validation (warns, never rejects; server-side check on test pushes) JSON Schema defs (not enforced) No Filters (not schema) No Manual
Prebuilt integration recipes Yes (Slack, Discord, PagerDuty, ntfy, ClickHouse, Twilio, SendGrid, CloudEvents — one YAML, rendered server-side) Limited Limited Yes (integrations) Limited destinations Manual
Inbound ingestion (verify provider signatures) Yes (sparrow-sources: Stripe, GitHub, cron schedules) Yes (Ingest product) Yes (incoming webhooks) Yes (core feature) No Manual
Non-HTTP delivery (email, object storage, OTLP) Yes (sparrow-sinks: SMTP, S3/MinIO, OTLP logs) Limited Limited Limited SNS-native targets Manual
Self-monitoring alerts Built-in system events (webhook health, delivery failure, auto-disable) + opt-in email alerts Operational webhooks Alert configs Issue alerts CloudWatch alarms Manual
CLI tooling Yes (push, tail, local listen, apply recipes, debug templates) Yes Yes Yes (localhost tunnels) AWS CLI Manual
Web dashboard Embedded SvelteKit Included Included Included Console No
Tracing & metrics OpenTelemetry (traces + metrics + logs, job-level propagation) + built-in Prometheus /metrics Logging Prometheus metrics Dashboard CloudWatch Manual
SSRF protection Built-in (private IPs, redirects) Built-in controls (plus proxy best practices) Built-in controls / IP filtering Managed N/A Manual
Client SDKs Generated from the OpenAPI 3.1 spec, any language; Go signature library; verification examples in 8 languages Broad coverage Multiple Multiple All AWS SDKs 0
Consumer app portal Yes (embeddable, token-scoped) Yes (embeddable) Yes (Portal Links) Yes (Outpost/managed) No No
Multi-region / HA story PostgreSQL-native HA + stateless workers Vendor/infra-managed Vendor/infra-managed Vendor-managed Global managed service Manual
Multi-tenant SaaS mode No (single-tenant focus) Yes Yes Yes Yes Manual

Since Svix is the closest competitor architecturally, here’s a deeper look:

Capability Sparrow Svix OSS
Event schema validation Soft validation (warnings, never rejects) JSON Schema defs (not enforced)
Consumer isolation Built-in logical separation Application-level
API protocol REST/HTTP on :8080 (OpenAPI 3.1 spec) REST API only
Deployment shape Single binary + Docker image Broader deployment options
Container image Distroless (~15MB), non-root Standard
Consumer self-service portal Built-in, token-scoped – embed or hand off a link App Portal (magic-link session)
  • Operational simplicity – one database, one binary, no Redis. Fewer moving parts means fewer failure modes in production.
  • Cryptographic depth – Standard Webhooks signing (HMAC-SHA256 or Ed25519) and real envelope encryption are production security features that most webhook platforms skip or gate behind paid tiers.
  • Payload transformation – Go text/template transforms per subscription (37 built-in functions, including structural dict/list/merge/append and arithmetic) let you reshape payloads for different consumers (Slack, PagerDuty, custom formats) without proxy layers. This is a deliberate design choice over an embedded JavaScript runtime: templates are parsed once and cached, so each delivery runs with near-zero overhead; there is no per-worker JS VM to pool, no extra dependency, and the server stays a single distroless ~15MB binary with a small, predictable memory footprint. Parsed templates are concurrency-safe and reused across all delivery workers, so transform throughput scales with workers instead of contending on interpreter instances. Every transform is bounded by a 1MB output cap and a 5s execution timeout. Available to all users, not a paid feature.
  • Error intelligence – 11 failure categories, each with a retry decision. You know why a delivery failed (DNS resolution? TLS handshake? Rate limited? Connection refused?), not just that it failed.
  • Bulk operations – snapshot-based batch re-push and retry with deterministic execution. What you filter is exactly what gets retried – no race conditions from new data arriving between search and action.
  • Observability – full OpenTelemetry integration with trace propagation through the job queue. Trace a single event from ingestion through fan-out to every delivery attempt. The same metrics are scrapeable at /metrics in Prometheus format with no collector: delivery success rate and latency, queue backlog, and webhooks by health and status.
  • Idempotency – built-in deduplication on event ingestion prevents double-processing without application-level workarounds.
  • Rate limiting – per-webhook delivery rate limiting with leaky bucket and HTTP 429 Retry-After parsing, all backed by PostgreSQL (no Redis).
  • No Redis – Sparrow uses PostgreSQL for everything including job queuing (via River). This keeps operational complexity lower for teams that want fewer infrastructure dependencies.
  • Satellites – companion tools built entirely on the public REST API: a CLI (push, tail, local listen, template debugging), recipes (Slack, Discord, PagerDuty, ntfy, ClickHouse, Twilio, SendGrid, CloudEvents as one YAML file each, rendered server-side), sources (Stripe/GitHub signature verification + cron schedules re-published as typed events), and sinks (SMTP email, S3/MinIO archives, OTLP log export). The core stays one small server; delete every satellite and Sparrow still works.
  • Self-monitoring – Sparrow emits its own system events (sparrow.webhook.health_changed, sparrow.webhook.delivery_failed, sparrow.webhook.disabled) through the same pipeline it delivers with, and can email you about them via opt-in alert configs – your webhook infrastructure alerts on itself, no external monitoring stack required.
  • Pauses never lose events – pausing a webhook or subscription, or Sparrow auto-disabling a receiver that has failed for days, holds every delivery as paused. Resume, then retry exactly what was held.
  • Consumer self-service – mint a scoped, expiring token for one consumer and hand them the embedded portal: they register endpoints, manage subscriptions, and inspect and retry their own deliveries with no API key and no visibility into any other consumer. Tokens are DB-backed and individually revocable, with automatic purging of expired entries – the same end-user portal Svix ships as its App Portal, without the SaaS.
  • First-party SDKs – Sparrow publishes no SDK packages: you generate a client from its OpenAPI spec with a standard generator (plus a Go signature verification library and examples in 8 languages). Some alternatives ship maintained SDKs you install from a package registry.
  • Multi-tenant SaaS mode – Svix, Convoy, and Hookdeck are designed for SaaS platforms where each customer manages their own webhooks. Sparrow is designed for teams running their own infrastructure.
  • Managed cloud offering – Svix Cloud and Hookdeck handle infrastructure for you. Sparrow is self-hosted only.
  • JavaScript transforms – Convoy and Hookdeck use JavaScript for payload transformation, which is more familiar to many web developers. Sparrow uses Go templates (see Payload transformation above for why); the trade-off is that familiarity, and anything a template can’t express needs a receiver of your own.
  • Ecosystem maturity – alternatives may offer larger ecosystems and more prebuilt integrations. Sparrow’s recipes cover Slack, Discord, PagerDuty, ntfy, ClickHouse, Twilio, SendGrid, and CloudEvents receivers today; anything else is a Go template away, but not prebuilt.
  • Hookdeck OSS scope – Hookdeck Outpost is open source and can be self-hosted, while Hookdeck’s core platform remains SaaS.
  • Comparison drift – vendor plans and packaging change frequently; verify critical buying decisions against current vendor docs.

Sparrow runs anywhere you can run one container and connect it to PostgreSQL:

  • Docker Compose for local development and small deployments
  • Any container platform – the distroless image is ~15MB with zero OS-level attack surface