Destinations

A destination is an outbound target that receives routed events from FastHook.

Destinations define where accepted and processed events go next. A source proves whether FastHook should accept an inbound request, a connection decides which branch should receive it, and a destination owns the final delivery target, method, auth, rate limit, disabled state, and attempt evidence.

Good destination configuration helps teams protect downstream services from overload while keeping delivery behavior explicit and observable.

Destination Types

FastHook supports fifteen destination types. Use Destination types for the full field-by-field reference.

  • HTTP: deliver routed events directly to an HTTP or HTTPS receiver.
  • CLI: deliver routed events through fasthook-cli to a localhost service.
  • MOCK_API: deliver to a fixed FastHook mock receiver for tests and demos.
  • POSTGRESQL: insert routed events into an existing PostgreSQL table.
  • GOOGLE_SHEET: append routed events as rows in Google Sheets.
  • GMAIL: send routed events as Gmail messages.
  • SENDGRID_EMAIL: send routed events as email through SendGrid.
  • SLACK: post routed events to Slack channels.
  • DISCORD_WEBHOOK: post routed events through Discord webhooks.
  • TELEGRAM_MESSAGE: post routed events to Telegram chats or channels.
  • CLOUDFLARE_R2: archive routed events as objects in Cloudflare R2.
  • AWS_S3: archive routed events as objects in AWS S3.
  • TWILIO_WHATSAPP: send routed events as WhatsApp messages through Twilio.
  • TWILIO_SMS: send routed events as SMS messages through Twilio.
  • TWILIO_MMS: send routed events as MMS messages with media through Twilio.

Use HTTP destinations for deployed production and staging services. Use CLI destinations for local development and controlled replay into localhost. Use mock destinations when a route needs a safe test receiver. Use PostgreSQL when events should become database rows, and Cloudflare R2 or AWS S3 when they should be archived as objects. Use Google Sheet, Gmail, SendGrid Email, Slack, Discord Webhook, Telegram Message, Twilio WhatsApp, Twilio SMS, or Twilio MMS destinations when the receiver is a human workflow rather than a service endpoint.

What A Destination Owns

Destination config is intentionally separate from source and connection config.

  • Target: receiver URL, CLI path, PostgreSQL table, Google Sheet settings, Gmail recipient templates, or mock endpoint.
  • Method: outbound HTTP method for HTTP-like delivery.
  • Auth: outbound receiver auth such as FastHook signature, custom header, OAuth2, Google OAuth, or service account credentials.
  • Rate limit: max delivery rate at the destination boundary.
  • State: active or disabled.
  • Evidence: delivery attempts, response status, response body, response latency, and recent attempt metrics.

When several connections target the same receiver, reuse one destination id. That keeps credentials, delivery capacity, and attempt history attached to one operational object.

HTTP Destinations

HTTP destinations represent deployed receivers such as application APIs, webhook consumers, workflow engines, internal gateways, or staging endpoints.

Configure:

  • Endpoint URL.
  • HTTP method: POST, PUT, PATCH, or DELETE.
  • Destination auth: no auth, FastHook signature, custom header, OAuth2 client credentials, OAuth2 authorization code, or Google OAuth for Google APIs.
  • Optional max delivery rate.

Use FastHook signature auth when your receiver should verify that the outbound request came through FastHook. See Destination delivery signatures.

CLI Destinations

A CLI destination forwards deliveries through an authenticated local tunnel.

Shell
fasthook login --api-key fhp_xxx
fasthook tunnel --destination des_xxx --to 8080

A CLI destination stores the destination id, name, status, method, rate limits, and optional path such as /webhooks/orders. It does not store localhost host, localhost port, tunnel token, or the local URL. The active CLI session supplies those values with --to.

The CLI sends the local response status, status text, response headers, and response body back through the tunnel. FastHook stores those details on the event attempt just like it does for HTTP destinations.

See CLI & Tunneling for the full command reference.

Mock API Destinations

Mock API destinations route deliveries to https://mock.fasthook.io/.

Use them for:

  • Quickstarts and demos.
  • Route validation before a real receiver exists.
  • Testing source auth, filters, transformations, retries, and metrics without side effects.
  • Verifying that request, event, and attempt evidence is created correctly.

The mock endpoint is fixed by design. Use an HTTP destination when you need a custom receiver URL.

Google Sheet Destinations

Google Sheet destinations append delivered events as rows.

Configure:

  • Spreadsheet ID.
  • Sheet name, defaulting to Sheet1.
  • Value input option: RAW or USER_ENTERED.
  • Optional dotted-path columns such as payload.customer.email.
  • Optional metadata mode when explicit columns are not configured.
  • Google OAuth refresh token or Google service account auth.

Google Sheet destinations are paced at one request per second to avoid write bursts. See Google Sheet Destination Guide for row layout and authentication examples.

PostgreSQL Destinations

PostgreSQL destinations insert one row per delivered event into an existing table.

Configure:

  • A publicly reachable PostgreSQL host, port, and database.
  • A least-privilege username and password with INSERT access to the target table.
  • TLS mode. verify-full is the secure default; disable sends unencrypted database traffic and should be used only when explicitly acceptable.
  • Schema and table names.
  • A required JSONB payload column.
  • Optional event ID (text), metadata (JSONB), and delivery time (timestamptz) columns.
  • Optional duplicate suppression with a unique event ID column and ON CONFLICT DO NOTHING.

FastHook does not create or migrate the table. Delivery is at least once, so use a unique event ID column when duplicate rows are not acceptable. The PostgreSQL driver is loaded only for PostgreSQL deliveries, and every insert uses query parameters rather than interpolating event values into SQL.

PostgreSQL destinations default to five inserts per second. Adjust the rate limit to match the database connection and write capacity. See the PostgreSQL destination reference for table DDL, API config, TLS guidance, and troubleshooting.

Gmail Destinations

Gmail destinations turn routed events into email messages.

Configure:

  • To, Cc, Bcc, and Reply-To recipient fields.
  • Subject template, defaulting to FastHook event {{event_id}}.
  • Text body template, defaulting to {{payload}}.
  • Optional HTML body template.
  • Google OAuth refresh token with Gmail send access.

Use Gmail destinations for human notification workflows such as operations alerts, customer-support handoff, manual review queues, or low-volume lifecycle messages. Put filters on the connection before the Gmail destination so only email-worthy events create messages.

Gmail destinations are paced at one request per second.

SendGrid Email Destinations

SendGrid Email destinations turn routed events into email messages through SendGrid Mail Send.

Configure:

  • From email: a SendGrid verified sender identity or an address on an authenticated sending domain.
  • Optional From name and Reply-To.
  • To, Cc, and Bcc recipients. Recipient fields can use FastHook template tokens.
  • Subject template, defaulting to FastHook event {{event_id}}.
  • Text body template, defaulting to {{payload}}.
  • Optional HTML body template.
  • SendGrid API region: https://api.sendgrid.com or https://api.eu.sendgrid.com.
  • SendGrid API key that starts with SG. and has Mail Send access.

Use SendGrid Email destinations for operational alerts, transactional notifications, customer lifecycle messages, and other email workflows that should come from a dedicated SendGrid account instead of a personal Gmail mailbox.

FastHook blocks fasthook.io and subdomains as the SendGrid sender domain for normal users. FastHook admins can use those sender domains for system messages. For customer-owned destinations, use your own verified sender or authenticated domain. A single rendered delivery can include up to 10 total To, Cc, and Bcc recipients.

SendGrid Email destinations are paced at one request per second.

SendGrid Email setup checklist

  1. Open SendGrid and verify a Single Sender identity or authenticate the sending domain.
  2. Create a SendGrid API key with Mail Send permission.
  3. In FastHook, choose SENDGRID_EMAIL.
  4. Set From email to the verified sender. Use fasthook.io only for FastHook admin-owned system destinations.
  5. Add To recipients, subject, text body, and optional HTML body.
  6. Choose the SendGrid API region that matches the account.
  7. Put filters on the connection before the SendGrid destination so only email-worthy events create messages.

Common SendGrid Email failures:

  • HTTP 401 or 403: the API key is wrong, revoked, missing Mail Send permission, or belongs to the wrong SendGrid region.
  • Sender verification errors: the From email is not a verified Single Sender and is not on an authenticated domain.
  • HTTP 202 but no email appears: SendGrid accepted the message for processing. Check SendGrid activity, bounces, blocks, deferrals, spam placement, and suppression lists.
  • Too many emails: tighten connection filters and keep the built-in one request per second pacing.

Official SendGrid references: Mail Send API, sender identity, and domain authentication.

Cloudflare R2 Destinations

Cloudflare R2 destinations archive delivered events as objects in a client-provided R2 bucket through Cloudflare's S3-compatible API.

Configure:

  • Cloudflare account ID and bucket name.
  • R2 Access Key ID and Secret Access Key with Object Read & Write access to the bucket.
  • Optional S3 endpoint for jurisdiction-specific buckets.
  • Object key template, defaulting to archives/{{team_id}}/{{source_id}}/{{event_id}}.json.
  • Content type, defaulting to application/json.
  • Optional body template.
  • Optional metadata envelope mode when the body template is empty.

Use Cloudflare R2 destinations for audit trails, recovery snapshots, offline inspection, or batch consumers that read object storage. If the connection has no transformation, the archive stores the original routed payload. If a transformation runs first, R2 stores the transformed payload.

AWS S3 Destinations

AWS S3 destinations archive delivered events as objects in a client-provided S3 bucket.

Configure:

  • AWS region and bucket name.
  • AWS Access Key ID and Secret Access Key with s3:PutObject access to the bucket.
  • Optional S3 endpoint and path-style URL mode for compatible endpoints.
  • Object key template, defaulting to archives/{{team_id}}/{{source_id}}/{{event_id}}.json.
  • Content type, defaulting to application/json.
  • Optional body template.
  • Optional metadata envelope mode when the body template is empty.

Use AWS S3 destinations for audit trails, recovery snapshots, data lake ingestion, offline inspection, or batch consumers that read object storage. If the connection has no transformation, the archive stores the original routed payload. If a transformation runs first, S3 stores the transformed payload.

Slack Destinations

Slack destinations post delivered events to a channel.

Configure:

  • Channel name or channel ID. Prefer channel IDs such as C123... for production, private channels, and channels that may be renamed.
  • Message text template. This is also Slack's fallback text for notifications and assistive clients when Block Kit is used.
  • Optional Block Kit JSON template. FastHook renders template tokens first, then parses the result as JSON.
  • Slack bot token from a Slack app installed in the same workspace.

Use Slack destinations for channel-visible alerts such as incidents, approvals, review queues, deployment notices, or operational notifications. Put filters on the connection before the Slack destination so only action-worthy events create messages.

Slack destinations are paced at one request per second.

Slack setup checklist

  1. Create or open a Slack app for the workspace that owns the target channel.
  2. Open OAuth & Permissions and add the Bot Token Scope chat:write.
  3. Optionally add chat:write.public if the app should post to public channels without being invited first.
  4. Install or reinstall the app to the workspace after changing scopes.
  5. Copy the Bot User OAuth Token that starts with xoxb-.
  6. Invite the app bot to the target channel, especially for private channels.
  7. Create the FastHook SLACK destination with the channel, message template, optional Block Kit JSON, and bot token.

Common Slack failures:

  • missing_scope: add chat:write, reinstall the Slack app, and update the saved bot token if Slack rotated it.
  • channel_not_found or not_in_channel: use the channel ID and invite the app bot to the channel.
  • invalid_auth: the xoxb- token is wrong, revoked, or from a different workspace.
  • invalid_blocks: render the template with a sample event and validate that it becomes a Block Kit JSON array or an object with a blocks array.

Official Slack references: chat.postMessage and chat:write.

Twilio WhatsApp Destinations

Twilio WhatsApp destinations send delivered events as WhatsApp messages through Twilio.

Configure:

  • From sender such as whatsapp:+14155238886 for the Twilio Sandbox, an approved production WhatsApp sender, or a Messaging Service SID.
  • To recipient such as whatsapp:+37120000000, with optional FastHook template tokens. From and To must be different WhatsApp addresses.
  • Message body template for free-form replies inside WhatsApp's customer service window.
  • Optional Content SID and Content variables JSON for approved WhatsApp templates.
  • Twilio Account SID and Auth Token from Twilio Console.

Use Twilio WhatsApp destinations for urgent human notifications, support workflows, lifecycle alerts, or approved customer messaging. Outside WhatsApp's service window, use an approved Twilio content template with content_sid and content_variables_template.

Twilio WhatsApp destinations are paced at one request per second.

Twilio WhatsApp setup checklist

For Sandbox testing:

  1. Open Twilio Console and activate the WhatsApp Sandbox.
  2. Copy the Sandbox join code.
  3. From the exact WhatsApp or WhatsApp Business account that should receive messages, send join <code> to +14155238886.
  4. In FastHook, set From sender to whatsapp:+14155238886.
  5. Set To recipient to the recipient number in whatsapp:+E.164 format, for example whatsapp:+37126430246.
  6. Paste the Twilio Account SID and Auth Token from API keys & tokens.

For production:

  • Use an approved Twilio WhatsApp sender or a Messaging Service SID configured for WhatsApp.
  • Use approved Content templates for business-initiated messages outside the 24-hour customer service window.
  • Set content_sid to the HX... Content SID and content_variables_template to a JSON object such as {"1":"{{payload.customer.name}}"} when using template variables.

Common Twilio WhatsApp failures:

  • Error 63015: the recipient has not joined the Twilio Sandbox. Send the current join <code> from that recipient's WhatsApp account and retry.
  • Error 63031: From and To are the same WhatsApp address. Use the Sandbox sender, an approved sender, or a Messaging Service SID that is different from the recipient.
  • HTTP 400 Bad Request: check whatsapp:+E.164 formatting, sender approval, Sandbox membership, and whether the message needs an approved Content template.
  • Twilio returns 201 but no message appears: open Twilio message logs for the message SID; FastHook stores the Twilio response body on the delivery attempt.

Official Twilio references: WhatsApp Sandbox, error 63015, and error 63031.

Twilio SMS Destinations

Twilio SMS destinations send delivered events as text messages through Twilio Programmable Messaging.

Configure:

  • From sender: an SMS-capable Twilio number, short code, approved alphanumeric sender ID, or a Messaging Service SID.
  • To recipient: a phone number in +E.164 format, with optional FastHook template tokens.
  • Message body template. Payload fields can be referenced as {{payload.message}} or, when there is no FastHook metadata name conflict, {{message}}.
  • Optional Messaging Service SID for sender pools and Twilio-managed sender selection.
  • Twilio Account SID and Auth Token from Twilio Console.

Use Twilio SMS destinations for operator alerts, low-volume customer notifications, or test messages where a normal text message is enough. There is no WhatsApp Sandbox join code for SMS: on a Twilio trial account, recipients usually must be verified in Twilio first; on a paid account, the sender number, country permissions, and compliance rules decide whether Twilio can deliver.

Twilio SMS destinations are paced at one request per second.

Twilio SMS setup checklist

  1. Open Twilio Console and copy the Account SID and Auth Token from API keys & tokens.
  2. Use an SMS-capable Twilio number, or create a Messaging Service and add SMS-capable senders.
  3. If the account is still in trial mode, verify each recipient phone number in Twilio.
  4. Confirm Messaging Geo Permissions allow sending SMS to the recipient country.
  5. In FastHook, choose TWILIO_SMS, set From sender or Messaging Service SID, set To recipient, and enter the message body template.
  6. Put filters on the connection before the SMS destination so only SMS-worthy events create messages.

Common Twilio SMS failures:

  • Error 21608: the recipient is not verified on a Twilio trial account.
  • Error 21606: the sender cannot send SMS to the destination number. Use an SMS-capable Twilio sender or a properly configured Messaging Service.
  • Error 21408: Twilio Geo Permissions do not allow SMS to that country.
  • Twilio returns 201 but no SMS appears: open Twilio message logs for the message SID and final error code; FastHook stores the Twilio response body on the delivery attempt.

Official Twilio references: Send SMS messages, trial account limits, error 21608, and error 21408.

Twilio MMS Destinations

Twilio MMS destinations send delivered events as text messages with media through Twilio Programmable Messaging.

Configure:

  • From sender: an MMS-capable Twilio number, or a Messaging Service SID with MMS-capable senders.
  • To recipient: a phone number in +E.164 format, with optional FastHook template tokens.
  • Message body template. Payload fields can be referenced as {{payload.message}} or, when there is no FastHook metadata name conflict, {{message}}.
  • Media URLs: one to ten public HTTP or HTTPS URLs. Twilio must be able to fetch each URL. Template media fields can use either {{payload.media_url}} or {{media_url}}.
  • Optional Messaging Service SID for sender pools and Twilio-managed sender selection.
  • Twilio Account SID and Auth Token from Twilio Console.

Use Twilio MMS destinations for operator alerts or customer notifications where an image, receipt, screenshot, or other media makes the message actionable. MMS is stricter than SMS: the sender, recipient country, carrier route, account status, and media URL fetchability all matter.

Twilio MMS destinations are paced at one request per second.

Twilio MMS setup checklist

  1. Open Twilio Console and copy the Account SID and Auth Token from API keys & tokens.
  2. Use an MMS-capable Twilio number, or create a Messaging Service and add MMS-capable senders.
  3. Prepare public HTTP or HTTPS media URLs that Twilio can fetch.
  4. If the account is still in trial mode, verify each recipient phone number in Twilio.
  5. Confirm Messaging Geo Permissions and route support allow MMS to the recipient country and carrier.
  6. In FastHook, choose TWILIO_MMS, set From sender or Messaging Service SID, set To recipient, enter the message body template, and add media URLs.
  7. Put filters on the connection before the MMS destination so only MMS-worthy events create messages.

Common Twilio MMS failures:

  • Error 21608: the recipient is not verified on a Twilio trial account.
  • Error 21606: the sender or Messaging Service cannot send to the destination number, or is not MMS-capable for that route.
  • Error 21408: Twilio Geo Permissions do not allow messaging to that country.
  • Media fetch failures: make sure every media URL is public, HTTP or HTTPS, and points to a supported content type.
  • Twilio returns 201 but no MMS appears: open Twilio message logs for the message SID and final error code; FastHook stores the Twilio response body on the delivery attempt.

Official Twilio references: Send MMS messages, Message resource, trial account limits, error 21608, and error 21408.

What You Can Do In Dashboard

Create a destination

Set name, destination type, target fields, delivery method, destination auth, and optional or built-in delivery rate limit.

Edit a destination

Update name, target settings, auth settings, HTTP method, and delivery rate. Google Sheet, Gmail, SendGrid Email, Slack, Twilio WhatsApp, Twilio SMS, and Twilio MMS destinations keep their built-in one request per second pacing.

Enable or disable a destination

Temporarily disable outbound delivery to a destination during receiver maintenance or incident response.

Delete a destination

Delete a destination when it is no longer used by connections.

Delivery Practices

  • Use descriptive names that reflect the consumer, such as payments-api, warehouse-sync, ops-events-sheet, or support-alerts.
  • Keep production, staging, local, and mock destinations separate.
  • Reuse one destination id when several connections deliver to the same receiver.
  • Set max delivery rate when the downstream system has tight capacity.
  • Disable a destination temporarily during maintenance instead of letting noisy attempts pile up.
  • Put filters on connections before human-facing destinations such as Gmail, SendGrid Email, Slack, Twilio WhatsApp, Twilio SMS, or Twilio MMS, and before archive destinations such as Cloudflare R2 or AWS S3 when you only need selected events.

Delivery Notes

  • FastHook forwards the routed request payload from the connected source flow.
  • Destination health and status are visible from the Destinations view.
  • Attempt metrics are loaded separately from destination list data so the list stays lightweight.
  • HTTP 502 Local Fetch Failed on a CLI destination means the CLI was connected, but the local --to URL did not answer successfully.
  • Source authentication and destination authentication are separate trust boundaries.

Related Docs