Introducing the Hookbase Terraform Provider: Webhook Infrastructure as Code

Webhook Infrastructure Deserves the Same Rigor as the Rest of Your Stack

Your servers are defined in Terraform. Your DNS is in Terraform. Your databases, queues, and monitoring — all in Terraform. But your webhook routing? That lives in a dashboard, configured by hand, with no version history, no code review, and no way to reproduce it.

Today we're changing that. The Hookbase Terraform Provider is now available on the Terraform Registry.

What You Can Manage

The provider covers 9 resource types across both inbound and outbound webhooks — making it the only Terraform provider in the webhook space that handles both directions.

Inbound Resources

| Resource | What It Does | |----------|-------------| | hookbase_source | Webhook receivers with signature verification, IP filtering, deduplication | | hookbase_destination | HTTP endpoints that receive delivered events | | hookbase_route | Rules that connect sources to destinations with optional transforms and filters | | hookbase_transform | JSONata, JavaScript, Liquid, or XSLT transformations applied to events | | hookbase_filter | Conditional logic that controls which events get routed |

Outbound Resources

| Resource | What It Does | |----------|-------------| | hookbase_event_type | Event catalog with schemas and example payloads | | hookbase_webhook_application | Customer-facing webhook apps with rate limiting | | hookbase_webhook_endpoint | Delivery endpoints with circuit breakers, retry policies, and signing | | hookbase_webhook_subscription | Subscriptions connecting endpoints to event types |

Every resource supports create, read, update, delete, and import.

Quick Start

terraform {
  required_providers {
    hookbase = {
      source  = "HookbaseApp/hookbase"
      version = "~> 0.1"
    }
  }
}

provider "hookbase" {
  api_key = var.hookbase_api_key
}

Set your API key via the HOOKBASE_API_KEY environment variable or pass it directly. The provider auto-detects your organization from the key — no org ID needed.

Example: Full Inbound Pipeline

Define a complete Stripe-to-Slack webhook pipeline in a single file:

resource "hookbase_source" "stripe" {
  name          = "stripe-production"
  slug          = "stripe-prod"
  provider_type = "stripe"
  signing_secret = var.stripe_webhook_secret
  reject_invalid_signatures = true
  dedup_enabled  = true
  dedup_strategy = "provider_id"
}

resource "hookbase_transform" "stripe_to_slack" {
  name           = "format-for-slack"
  transform_type = "jsonata"
  code           = <<-EOT
    {
      "text": "Payment received: $" & $string(data.object.amount / 100),
      "event": type
    }
  EOT
}

resource "hookbase_destination" "slack" {
  name = "slack-payments"
  slug = "slack-payments"
  url  = var.slack_webhook_url
}

resource "hookbase_route" "stripe_to_slack" {
  name           = "stripe-to-slack"
  source_id      = hookbase_source.stripe.id
  destination_id = hookbase_destination.slack.id
  transform_id   = hookbase_transform.stripe_to_slack.id
}

Run terraform apply and your pipeline is live. Change the transform, open a PR, get it reviewed, merge, apply. That's it.

Example: Outbound Webhooks for Your Customers

Set up a complete outbound webhook system for a customer:

resource "hookbase_event_type" "order_created" {
  name        = "order.created"
  description = "Fired when a new order is placed"
  category    = "orders"
}

resource "hookbase_webhook_application" "acme" {
  name        = "Acme Corp"
  external_id = "cust_acme_123"
  rate_limit_per_second = 50
}

resource "hookbase_webhook_endpoint" "acme_orders" {
  application_id  = hookbase_webhook_application.acme.id
  url             = "https://acme.com/webhooks/orders"
  timeout_seconds = 15
}

resource "hookbase_webhook_subscription" "acme_order_created" {
  endpoint_id   = hookbase_webhook_endpoint.acme_orders.id
  event_type_id = hookbase_event_type.order_created.id
}

One terraform apply creates the event type, the customer's application, their endpoint with signing and circuit breakers, and the subscription linking them together.

Why This Matters

Version Control for Webhook Config

Every change to your webhook routing goes through git. You can see who changed what, when, and why. Roll back by reverting a commit.

Code Review for Infrastructure Changes

No more "who changed the transform and broke deliveries?" Changes go through pull requests. A teammate reviews the diff before it hits production.

Reproducible Environments

Spin up identical webhook pipelines across dev, staging, and production with different variable files:

terraform apply -var-file=staging.tfvars
terraform apply -var-file=production.tfvars

Import Existing Resources

Already using Hookbase? Import your existing resources into Terraform state:

terraform import hookbase_source.stripe <source-id>
terraform import hookbase_destination.slack <destination-id>

Both Directions, One Provider

Most webhook platforms focus on one direction — either receiving webhooks or sending them. Hookbase handles both, and now the Terraform provider does too. One terraform apply configures your entire webhook infrastructure: inbound sources, routing rules, transforms, outbound event types, customer endpoints, and subscriptions.

No other Terraform provider in the webhook space offers this.

Get Started

1. Install from the Terraform Registry
2. Browse the documentation for all 9 resources
3. Check out the source code on GitHub

The provider is open source and we welcome contributions. If you run into issues or want to request a feature, open an issue.