Forwarding
Send events on as they arrive, to your own server, Slack, Discord, Telegram or an email.
A forwarding rule says: when an event lands in this channel, send it there. Rules are made in the app, under Setup, Forwarding, by the project’s owner. A project holds up to 20.
A rule takes a whole channel, or one event in it by its exact name. Leave the channel empty to take every event in the project.
| Destination | What it needs | What arrives |
|---|---|---|
| Webhook | An https:// address of yours |
The event as JSON, signed |
| Slack | An incoming webhook address | A message with the event’s name, description and tags |
| Discord | A channel’s webhook address | The same, as a message |
| Telegram | A bot token and a chat id | The same, from your bot |
| The owner or a teammate | The same, as a plain email |
Sending happens after the event is stored and never slows the request that posted it. Backfilled events, sent with a timestamp, are not forwarded.
Webhooks
Each event is a POST with a JSON body:
{
"id": 4182,
"project": "acme-store",
"channel": "payments",
"event": "New subscription",
"description": "[email protected] upgraded to Pro",
"icon": "💰",
"notify": true,
"tags": { "plan": "pro" },
"user_id": "user-123",
"created_at": "2026-11-21T10:04:11.000Z"
}
Answer with any 2xx within 8 seconds. An address that redirects is not followed.
Checking the signature
When you make a webhook rule the app shows a signing secret once, starting with whsec_. Every request carries a header made with it:
X-Snekot-Signature: t=1795255451,v1=5257a869e7ecebeda32affa62cdca3fa51cad7e77a0e56ff536d0ce8e108d8bd
t is the time it was sent, in Unix seconds. v1 is the HMAC-SHA256, in hex, of t, a dot, and the body exactly as it arrived, under your secret. Compute the same and compare, and turn away anything more than a few minutes old:
import { createHmac, timingSafeEqual } from 'node:crypto';
function fromSnekot(secret, header, rawBody) {
const { t, v1 } = Object.fromEntries(header.split(',').map((part) => part.split('=')));
if (Math.abs(Date.now() / 1000 - Number(t)) > 300) return false;
const expected = createHmac('sha256', secret).update(`${t}.${rawBody}`).digest('hex');
return v1.length === expected.length && timingSafeEqual(Buffer.from(v1), Buffer.from(expected));
}
Use the raw body, before any JSON parsing, since parsing and writing it out again can change it.
Where a webhook may point
A webhook address must be https:// and reachable from the internet. Addresses on a private network, on the machine itself, or link-local are refused, both when the rule is made and again each time something is sent.
Slack, Discord and Telegram
- Slack: create an incoming webhook for the channel you want and paste its address, which starts with
https://hooks.slack.com/services/. - Discord: in the channel’s settings, under Integrations, create a webhook and copy its address, which starts with
https://discord.com/api/webhooks/. - Telegram: create a bot with BotFather and add it to the chat. The rule needs the bot’s token and the chat’s id, a number such as
-1001234567890, or a public channel’s@name.
These addresses and tokens let anyone who has them post as you, so they are stored sealed and never shown again. A rule shows only the last characters of its address.
Email goes to the project’s owner or a teammate, never to an address outside the project. On a server you run yourself, email is off until RESEND_API_KEY and MAIL_FROM are set; the app then says it is not set up.
When a send fails
A send that could go differently on another try is tried again: after 10 seconds, a minute, and five minutes. That covers a timeout, a network failure, and an answer of 408, 429 or 5xx. Any other answer is final, since asking again would get the same one.
Each rule shows how its latest send went: when it was sent, or when it failed and what the destination said. Send a test event sends a sample at once, marked as a test, and shows the result on the rule. A rule can be paused, which keeps it and sends nothing.
Forwarding is best effort. For a record you can rely on, read the events back with a read key.
Next Keys