Get the FREE Ultimate OpenClaw Setup Guide →

outpost

npx machina-cli add skill hookdeck/agent-skills/outpost --openclaw
Files (1)
SKILL.md
5.8 KB

Hookdeck 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

OptionDescriptionBest for
Self-hostedRun via Docker, Kubernetes, or Railway. Full control. Apache-2.0 license.Production with custom infra requirements
ManagedHookdeck 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:

DeploymentBase URLAuthentication
Self-hostedhttp://localhost:3333/api/v1 (or your configured host)Authorization: Bearer $API_KEY (the API_KEY env var you configured)
ManagedProvided in your Hookdeck projectAuthorization: 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

  1. Step 1: Deploy Outpost (choose Self-hosted via Docker/Kubernetes or sign up for Hookdeck Cloud).
  2. Step 2: Create a Tenant, add a Destination (e.g., a webhook) and subscribe it to relevant Topics.
  3. 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.

Frequently Asked Questions

Add this skill to your agents
Sponsor this space

Reach thousands of developers