outpost
npx machina-cli add skill hookdeck/agent-skills/outpost --openclawHookdeck Outpost
Open-source outbound event delivery infrastructure by Hookdeck. Delivers your platform events directly to your users' preferred event destinations (webhooks, message queues, streaming platforms).
Deployment Options
| Option | Description | Best for |
|---|---|---|
| Self-hosted | Run via Docker, Kubernetes, or Railway. Full control. Apache-2.0 license. | Production with custom infra requirements |
| Managed | Hookdeck Cloud. No infrastructure to operate. | Teams wanting zero-ops setup |
For managed, sign up at hookdeck.com. For self-hosted, see the quickstart below.
Supported Destination Types
Available: Webhooks (HTTP), Hookdeck Event Gateway, AWS SQS, AWS Kinesis, AWS S3, Azure Service Bus, GCP Pub/Sub, RabbitMQ (AMQP)
Planned: AWS EventBridge, Apache Kafka
Core Concepts
Tenants -- Represent a user, team, or organization in your product. Each tenant manages their own Destinations.
Destinations -- A specific instance of a destination type belonging to a tenant. For example, a webhook destination with a particular URL, or an SQS queue.
Topics -- Categorize events using a Pub/Sub pattern (e.g., user.created, payment.completed). Destinations subscribe to one or more topics, or * for all.
Events -- Data representing an action in your system. Published to a topic and delivered to all matching destinations.
Delivery Attempts -- Records of each attempt to deliver an event to a destination, including request/response data.
Self-Hosted Quick Start (Docker)
Requires Docker. Uses RabbitMQ for message queuing.
git clone https://github.com/hookdeck/outpost.git
cd outpost/examples/docker-compose/
cp .env.example .env
# Edit .env and set your API_KEY value
docker-compose -f compose.yml -f compose-rabbitmq.yml -f compose-postgres.yml up
Verify the services are running:
curl localhost:3333/api/v1/healthz
API Access
The Outpost API is a REST-based JSON API. The base URL and authentication differ by deployment:
| Deployment | Base URL | Authentication |
|---|---|---|
| Self-hosted | http://localhost:3333/api/v1 (or your configured host) | Authorization: Bearer $API_KEY (the API_KEY env var you configured) |
| Managed | Provided in your Hookdeck project | Authorization: Bearer $HOOKDECK_API_KEY (from Dashboard > Settings > Secrets) |
The OpenAPI spec for the self-hosted API is at: https://github.com/hookdeck/outpost/blob/main/docs/apis/openapi.yaml
All curl examples below use the self-hosted base URL. Replace localhost:3333/api/v1 with the managed URL and use your Hookdeck API key when using the managed version.
Publish Your First Event
Set shell variables for convenience:
BASE_URL=localhost:3333/api/v1
API_KEY=your_api_key
TENANT_ID=your_org_name
URL=https://your-webhook-endpoint.example.com
Create a tenant, add a webhook destination, and publish an event:
# Create tenant
curl -X PUT "$BASE_URL/$TENANT_ID" \
-H "Authorization: Bearer $API_KEY"
# Create webhook destination subscribing to all topics
curl -X POST "$BASE_URL/$TENANT_ID/destinations" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $API_KEY" \
-d '{
"type": "webhook",
"topics": ["*"],
"config": { "url": "'"$URL"'" }
}'
# Publish an event
curl -X POST "$BASE_URL/publish" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $API_KEY" \
-d '{
"tenant_id": "'"$TENANT_ID"'",
"topic": "user.created",
"eligible_for_retry": true,
"data": { "user_id": "usr_123" }
}'
Tenant Portal
Outpost includes a built-in portal UI where tenants manage their destinations and inspect events:
curl "$BASE_URL/$TENANT_ID/portal" \
-H "Authorization: Bearer $API_KEY"
# Returns { "redirect_url": "...?token=<jwt>" }
Architecture
Outpost consists of three services (deployable together as a single binary or separately for horizontal scaling): API Service (captures events, configuration APIs), Delivery Service (delivers to destinations via message queues), and Log Service (stores events, status, responses). Requires Redis 6.0+, PostgreSQL, and one supported message queue. See concepts for details.
Future Skills
Destination-specific skills (outpost-webhooks, outpost-sqs, outpost-rabbitmq, etc.) will be added as Outpost documentation matures.
Deployment Quickstarts
Related Skills
- hookdeck -- skill router for all Hookdeck skills
- event-gateway -- Hookdeck Event Gateway (inbound webhooks)
Source
git clone https://github.com/hookdeck/agent-skills/blob/main/skills/outpost/SKILL.mdView on GitHub Overview
Hookdeck Outpost is an open-source outbound event delivery infrastructure that sends platform events to customer destinations like webhooks, queues, and streaming platforms. It supports self-hosted deployments or Hookdeck Cloud for managed delivery. Destinations include HTTP webhooks, SQS, Pub/Sub, RabbitMQ, and more, with tenant-based organization.
How This Skill Works
Events are published to topics within a Tenant, and Destinations subscribed to those topics receive matching events. Each delivery attempt is recorded for retries and observability. You manage Outpost via a REST API and choose between self-hosted or managed deployment options.
When to Use It
- You need to deliver outbound events to customer webhooks with reliable retries.
- You want to build a webhook delivery infrastructure that supports multiple destinations (HTTP, SQS, RabbitMQ, Pub/Sub, EventBridge, Kafka in the future).
- You need multi-tenant support with separate tenants, destinations, and topic subscriptions.
- You prefer a self-hosted deployment (Docker/Kubernetes) for full control or custom infra requirements.
- You want a managed, zero-ops option via Hookdeck Cloud.
Quick Start
- Step 1: Deploy Outpost (choose Self-hosted via Docker/Kubernetes or sign up for Hookdeck Cloud).
- Step 2: Create a Tenant, add a Destination (e.g., a webhook) and subscribe it to relevant Topics.
- Step 3: Publish an Event to a Topic and verify delivery using delivery logs or health checks.
Best Practices
- Model tenants and destinations clearly to keep multi-tenant access isolated.
- Use Topics to categorize events and subscribe destinations to relevant topics (or use * for all).
- Monitor Delivery Attempts to detect failures and implement appropriate retries.
- Choose deployment mode based on ops capacity: Self-hosted for control, Managed for zero-ops.
- Secure APIs and endpoints, verify health with healthz checks, and test deliveries in staging before production.
Example Use Cases
- Deliver user.created events to a customer HTTP webhook endpoint.
- Route order events to an AWS SQS queue for downstream processing.
- Publish payment.completed events to a Google Pub/Sub topic for real-time analytics.
- Send shipping updates to a RabbitMQ queue for internal processing.
- Organize events in a multi-tenant app where each tenant subscribes to its own topics and destinations.