Relay vs Hookdeck: Choosing the Right Webhook Infrastructure

2026-06-05

#webhooks #comparison #relay #hookdeck

Hookdeck and Relay both work with webhooks. They solve fundamentally different problems.

Hookdeck is a full webhook platform for managing incoming webhooks. Routing, transformation, filtering, event history, connections model. Enterprise webhook infrastructure.

Relay is scheduled webhook delivery. One API call, fires later, retries automatically. No routing, no transformation, no dashboard.

This isn’t a hit piece. Hookdeck is excellent at what it does. The question is whether what it does is what you need.

What Hookdeck Gives You

Webhook ingestion and routing: Accept webhooks from providers, route them to multiple destinations based on rules. Stripe payments go to your billing service. New orders go to your fulfillment service. One incoming webhook, multiple handlers.

Transformations: Modify webhook payloads before delivery. Map field names. Filter out unnecessary data. Normalize different providers into a standard format.

Event storage and replay: Every webhook is stored with full payload and headers. Replay events to test changes. Debug webhook issues with complete history.

Connections model: Define sources (Stripe, GitHub, Shopify) and destinations (your services). Configure routing rules, filters, and transformations per connection.

Dashboard and CLI: Web interface for managing connections, viewing events, monitoring deliveries. CLI for automation.

Retry logic: Automatic retries with exponential backoff. Dead letter queues for permanent failures. Webhooks reach their destination.

Rate limiting and throttling: Control how fast webhooks are delivered to your services. Prevent webhook floods from overwhelming your infrastructure.

If you’re building a platform that receives webhooks from multiple providers and needs to orchestrate complex routing, Hookdeck is a serious solution.

What Relay Gives You

Scheduled delivery: Send a webhook after a delay. No routing, no transformation. Just HTTP POST to a URL at a specific future time.

curl -X POST https://api.solenoid.systems/v1/relay \
  -H "Authorization: Bearer sm_your_api_key" \
  -d '{
    "target_url": "https://your-app.com/webhooks",
    "method": "POST",
    "delay": "3d",
    "payload": {"event": "trial_expiring", "user_id": "123"}
  }'

Automatic retries: 5xx errors and network failures retry up to 3 times with exponential backoff. 2xx means success. 4xx means permanent failure.

Edge deployment: Runs on Cloudflare Workers and Durable Objects. Global low latency. No central point of failure.

Signature verification: Every delivered webhook includes X-Solenoid-Signature for HMAC verification.

No dashboard: API-only. Build your own UI or use curl.

Unified billing: Same API key as Gate, Meter, and Witness. One vendor for edge infrastructure primitives.

The Fundamental Difference

Hookdeck answers: “How do I manage incoming webhooks from multiple providers?”

Relay answers: “How do I schedule an HTTP callback to fire later?”

These are different problems.

Hookdeck is event-driven infrastructure for receiving webhooks. Providers send to Hookdeck. Hookdeck routes to your services. The flow is inbound → processing → outbound.

Relay is scheduled delivery for sending webhooks. You tell Relay what to send and when. Relay delivers it. The flow is schedule → wait → deliver.

When to Use Hookdeck

Choose Hookdeck when:

You receive webhooks from multiple providers. Stripe, GitHub, Shopify, custom webhooks from partners. Each has different payload formats. You need transformation and normalization.

You need complex routing. Payment webhooks go to the billing service. Fulfillment webhooks go to the warehouse API. Support ticket webhooks go to the CRM. One source, multiple destinations.

You want webhook event history. Compliance requires storing every webhook. Debugging requires replaying events. Hookdeck stores everything with full payloads.

You need rate limiting. Your API can handle 100 req/sec. A webhook provider sends 1,000 events in a burst. Hookdeck throttles delivery to protect your infrastructure.

You’re building a webhook-heavy platform. Multi-tenant SaaS where each customer configures webhook endpoints. Hookdeck’s connections model fits this pattern.

You want managed infrastructure. Don’t want to run your own webhook receivers. Hookdeck handles ingestion, storage, retry logic, monitoring.

When to Use Relay

Choose Relay when:

You need to schedule webhooks. Trial expiration notices. Payment reminders. Delayed notifications. Time-based HTTP callbacks.

You’re replacing job queues. Redis + Bull for scheduling? Celery with RabbitMQ? Relay eliminates the queue infrastructure. One API call schedules the work.

You want minimal infrastructure. No event history to manage. No routing rules to configure. Just “send this payload to this URL after this delay.”

You’re already using Solenoid. Gate for flags, Meter for credits, Relay for webhooks. One API key, one vendor, one bill.

Latency matters. Relay runs at the edge. Scheduling and delivery happen globally with low latency.

You don’t need transformations. The payload you provide is the payload that gets sent. No mapping, no filtering, no normalization.

The Hybrid Approach

Some architectures use both patterns.

Hookdeck for receiving webhooks. Stripe sends to Hookdeck. Hookdeck routes to your billing service. Event history and replay available.

Relay for sending webhooks. Your app schedules reminders via Relay. Relay delivers them later. No queue infrastructure to manage.

// Receive webhook with Hookdeck
app.post('/webhooks/stripe', async (req, res) => {
  const event = req.body

  if (event.type === 'customer.subscription.created') {
    const trialEnd = event.data.object.trial_end

    // Schedule trial expiration webhook with Relay
    await fetch('https://api.solenoid.systems/v1/relay', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.SOLENOID_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        target_url: 'https://your-app.com/webhooks/trial-expiring',
        method: 'POST',
        delay: `${Math.floor((trialEnd - Date.now() / 1000) / 86400)}d`,
        payload: { customer_id: event.data.object.customer }
      })
    })
  }

  res.json({ received: true })
})

Hookdeck handles inbound webhook complexity. Relay handles outbound scheduling. Each tool does what it’s good at.

Operational Complexity

Hookdeck Cloud is managed infrastructure. You configure connections via dashboard or API. Hookdeck handles ingestion, storage, delivery, retries, monitoring.

Operational load: minimal. You monitor delivery rates and handle failures. Hookdeck manages the infrastructure.

Relay is API-only. No infrastructure to run. No dashboards to monitor. Call the API when you want to schedule a webhook. Cloudflare handles the rest.

Operational load: zero. No servers, no databases, no queues.

Both are low-ops solutions. Hookdeck gives you more control and visibility. Relay gives you maximum simplicity.

Pricing Comparison

Hookdeck uses event-based pricing with a generous free tier. Paid plans scale with event volume and feature requirements. Enterprise pricing for high-volume use cases.

Relay pricing:

Free: 10,000 calls/month
Starter ($19.99/mo): 100,000 calls
Pro ($49.99/mo): Unlimited
Scale ($149.99/mo): Unlimited

Relay becomes unlimited at Pro tier. If you’re scheduling thousands of webhooks daily, Pro pays for itself quickly.

Migration Paths

From Relay to Hookdeck: If you need complex routing or event history for your scheduled webhooks, migration is possible. Your Relay calls become Hookdeck connection configurations. Schedule via Hookdeck’s delay feature.

From Hookdeck to Relay: Only makes sense if you’re simplifying to pure scheduling. If you’re using Hookdeck’s routing, transformations, or event history, Relay doesn’t replace those features.

Most teams don’t migrate between these tools. They solve different problems.

The Decision

Use Hookdeck if:

You receive webhooks from multiple providers
You need routing, transformations, or filtering
Event history and replay matter for compliance
You want managed webhook infrastructure
You’re building a webhook-heavy platform

Use Relay if:

You need to schedule webhooks for delivery later
You’re replacing job queue infrastructure
Your use case is simple: send payload X to URL Y after delay Z
You want minimal operational overhead
You’re already using Solenoid for other primitives

Both are good tools. The question is whether you’re managing incoming webhooks or scheduling outgoing ones.

Try Relay

If scheduled webhook delivery fits your use case:

# Schedule a webhook 5 minutes from now
curl -X POST https://api.solenoid.systems/v1/relay \
  -H "Authorization: Bearer sm_your_api_key" \
  -d '{
    "target_url": "https://webhook.site/your-unique-id",
    "method": "POST",
    "delay": "5m",
    "payload": {"test": "hello"}
  }'

Visit webhook.site. Watch your webhook arrive exactly 5 minutes later.

No routing. No transformations. Just scheduled delivery.