ForHosting KIT · Notifications & Flows

Route an alert to the right channel

The same underlying failure firing ten times in five minutes shouldn't page ten people ten times. This endpoint takes one alert, applies your routing rules and dedupe window, and sends it to exactly the channel that should see it, once.

● BetaPer request + per alert$0.002
Use it from WebAPIEmailApp soonTelegram soon

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

Built for the gap between 'something broke' and 'the right person knows'

Most systems can detect a problem; fewer can decide, consistently, who should hear about it and through what channel without a human writing that logic into every single integration separately. notify.alert centralizes that decision — severity thresholds, on-call schedules, channel preference by alert type — so your monitoring, application code and third-party integrations all send alerts through one door instead of each hardcoding its own Slack webhook.

How routing and dedupe work together

POST /notify/alert takes an event with a source, severity and a dedupe key you choose — often a combination of the alert type and the affected resource. If an alert with the same dedupe key arrives again inside the configured window, it's folded into the existing alert instead of firing a second notification; once the window passes or the alert is acknowledged, the next occurrence starts fresh. Routing rules then decide the destination — Slack for warnings, a phone-reaching channel for critical severity, email for informational events — based on criteria you define once.

Alert fatigue is an old, well-documented problem

The pattern of teams silencing or ignoring alerts because too many low-value ones arrived alongside the important ones predates modern cloud monitoring by decades — it's the same failure mode that shows up in industrial control rooms and hospital equipment, which is part of why deduplication and severity-based routing became standard practice in incident management rather than a nice-to-have. We built this endpoint around that lesson instead of treating every alert as equally urgent by default.

Where it sits relative to the other notification endpoints

Think of this as the decision layer that sits in front of notify.slack, notify.discord, notify.webhook and notify.digest: your monitoring or application code sends everything here, and the routing configuration decides which of those channels actually fires for a given alert, or whether it should instead wait for the next digest. That keeps the routing logic in one place instead of duplicated across every service that can raise an alert.

What comes back to confirm it worked

You receive the routing decision made — which channel was used and why, plus whether the alert was new or deduplicated against an existing one — through a signed webhook or a signed link valid for 24 hours. If no rule matches an alert, that's reported explicitly rather than the alert quietly going nowhere, so gaps in your routing configuration surface immediately instead of during an actual incident.

Deduplicating flapping monitoring checks

A health check that flaps between pass and fail fires alerts every minute; dedupe collapses them into one active incident instead of paging on-call repeatedly.

Severity-based on-call routing

Critical database alerts route to the on-call phone channel while low-severity warnings route to a Slack channel nobody needs to be paged for.

Centralizing alerts from many services

A dozen microservices each raise alerts through the same endpoint, and one routing configuration decides destinations instead of twelve separate integrations.

Escalation by alert type

Security-related alerts always route to the security channel regardless of severity, while infrastructure alerts follow the standard severity-based rules.

How does deduplication work in the alert routing API?

You supply a dedupe key with each alert; repeated alerts sharing that key inside the configured window are folded into the existing alert instead of triggering a new notification.

Which channels can notify.alert route to?

It routes to any of the other notification endpoints on your account — Slack, Discord, webhook or digest — based on the rules you configure for severity, source or alert type.

Is notify.alert free?

There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.

What does alert routing cost?

It's $0.002 per POST /notify/alert request; the routing decision itself doesn't add extra charges beyond the underlying channel's own per-notification cost when it actually fires.

What happens if no routing rule matches an alert?

The response reports explicitly that no rule matched, rather than silently discarding the alert, so you can catch gaps in your routing configuration before they matter.

Can I set different dedupe windows per alert type?

Yes, dedupe windows are configurable per rule, so a flapping health check and a rare critical failure can use different windows suited to each.

Can one alert notify multiple channels at once?

Yes, a routing rule can fan out to more than one channel — for example Slack and a phone-reaching channel together for critical severity.

Is alert data kept after it's routed?

No, alert payloads and routing history are deleted after the stated retention window and are never used for training.

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

POSThttps://api.kit.forhosting.com/notify/alert

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

curl -X POST https://api.kit.forhosting.com/notify/alert \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input":"…"}'
{
  "input": "…"
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "notify.alert",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Read the full KIT documentation →