---
title: Uptime alerts on Telegram, ntfy, Slack and your phone: send them where someone looks
description: The alert fired at 2 a.m. into an inbox nobody reads. How to route uptime alerts to Telegram, ntfy, Slack or phone push so the right person sees them.
canonical: https://watchfor.io/blog/uptime-alerts-telegram-ntfy-slack
---

# Uptime alerts on Telegram, ntfy, Slack and your phone: send them where someone looks

2026-10-20 · WatchFor Team · Reliability · alerting, on-call, incidents, monitoring

The alert fired at 2 a.m. into an inbox nobody reads. How to route uptime alerts to Telegram, ntfy, Slack or phone push so the right person sees them.

The payments API went down at 2:14 on a Saturday. The monitor noticed within
a minute, confirmed it from three locations, opened an incident and sent the
alert exactly as configured: to `ops@`, a shared inbox with a filter that
moves anything from a monitoring tool into a folder called *Later*.

Someone read it at 9:40.

Nothing in that chain was broken. The check worked, the confirmation worked,
the email was delivered. The alert simply went to a place nobody looks at
2 a.m. Most "we didn't get alerted" stories are this one: not a missing
alert, but an alert in the wrong place.

So this post is about the last step — where the alert lands — and how to pick
it by asking who has to act, and how fast.

## First, what an alert actually is

WatchFor only notifies about **confirmed** incidents. One location failing
marks the monitor *Degraded* on the dashboard, but nobody is paged until the
failure is confirmed (the
[confirmation post](/blog/confirm-outage-before-paging) explains how). That
matters for channel choice: if you are going to put something on a phone at
night, it had better be real.

Every message carries the same story, rendered natively for each channel:

- a title that says what happened — 🔴 **DOWN**, 🟡 **Degraded**, 🟢 **UP**;
- a plain-language diagnosis such as *Unexpected HTTP Status*, with
  **Expected** and **Detected** values;
- which locations confirmed the failure, when it started and, on recovery,
  how long it lasted;
- a link straight to the incident.

You get one message when an incident opens and one when it resolves. If you
want reminders while something stays down, turn on **Repeat reminders while
down** on the monitor; they stop as soon as someone acknowledges or it
resolves.

## Sixteen places an alert can go

![The New channel dialog in the Acme organization with 16 channel types: Email, Slack, Discord, Telegram, Microsoft Teams, Google Chat, Mattermost, Rocket.Chat, ntfy, Gotify, Pushover, Pushbullet, PagerDuty, Opsgenie, Webhook and Zapier](/blog/uptime-alerts-telegram-ntfy-slack-channels.webp)

WatchFor ships 16 channel types. They fall into four groups, and the group
matters more than the brand:

| Group | Channels | Good for |
| --- | --- | --- |
| Inbox | Email | A record, daily awareness, people outside the team |
| Team chat | Slack, Discord, Microsoft Teams, Google Chat, Mattermost, Rocket.Chat, Telegram groups | The team that should *know*, during working hours |
| Your phone | Telegram (personal), ntfy, Pushover, Gotify, Pushbullet, push from the installed app | The person who has to *act*, at any hour |
| Incident tools | PagerDuty, Opsgenie, Webhook, Zapier | Teams that already run on-call or automation elsewhere |

SMS is not offered yet; the phone row above is how people get woken up
today.

## Pick the channel by who has to wake up

The question is never "which app do we like". It is: when this monitor goes
down, who needs to do something, and how soon?

| If… | Send it to |
| --- | --- |
| A customer-facing outage needs someone in minutes, any hour | A phone channel for the on-call person: ntfy, Pushover, personal Telegram or app push — or PagerDuty/Opsgenie if you already page from there |
| The team should know, but nobody has to jump | Team chat |
| It's a warning (slow response, certificate expiring in 14 days) | Team chat or email, not a phone |
| Someone outside engineering needs to know | Email, or a [status page](/status-pages) |
| A system should react (open a ticket, restart a job) | Webhook or Zapier |

Two settings make this work without a rulebook:

**Contact groups.** A monitor sends to its contact groups; a channel is
attached to one or more groups. Put the payments API in a *Payments* group,
attach the payments team's Slack channel and their ntfy topic to it, and that
is the routing. There is no separate rules table to keep in sync.

**A severity filter on each channel.** Every channel delivers *Critical* and
*Warning* by default. Untick *Warning* on the phone channels and the 14-days
certificate notice stays in Slack, where it belongs, instead of buzzing
someone at dinner.

## Telegram: about twenty seconds

Telegram is the quickest way to get alerts on your own phone, because there
is nothing to build. Alerts come from the official **@WatchForAlertsBot**.

![The New channel dialog with Telegram selected: alerts are delivered by @WatchForAlertsBot, and the only field to fill in is the Chat ID](/blog/uptime-alerts-telegram-ntfy-slack-telegram.webp)

1. Open [@WatchForAlertsBot](https://t.me/WatchForAlertsBot) in Telegram and
   press **Start**. It replies with your chat ID. (Pressing Start is also what
   allows the bot to message you; Telegram bots can never write first.)
2. In WatchFor: **Alerting → Channels & contacts → New channel → Telegram**,
   paste the chat ID, pick the contact groups.
3. **⋯ → Send test.** A `[TEST]` message arrives in a couple of seconds.

For a team, add the bot to a Telegram group instead. It posts the group's
chat ID (a negative number, which is normal) the moment it joins.

Full walkthrough: [Telegram](/docs/notifications/telegram).

## ntfy: push without an account

[ntfy](https://ntfy.sh) is a free, open-source push service popular with
developers and self-hosters. You subscribe to a topic name you invent, and
anything published to it pops up on your phone. No account, no API key.

![The New channel dialog with ntfy selected: a topic name, an optional server URL for self-hosted ntfy and an optional access token](/blog/uptime-alerts-telegram-ntfy-slack-ntfy.webp)

What makes it good for on-call is priority. Critical alerts go out at ntfy's
**max** priority, which you can allow to break through Do Not Disturb;
warnings go out at high, recoveries at normal. Tapping the notification opens
the incident.

Two honest caveats:

- **The topic name is the secret.** Anyone who knows it can read your alerts.
  Use something long and random like `acme-alerts-x7k2q`, not `alerts`.
- **Self-hosted servers must be reachable from the internet.** Private
  addresses are rejected, at save time and again at send time. If your server
  needs authentication, paste an access token; it's stored encrypted.

Setup and the priority table: [ntfy](/docs/notifications/ntfy).

## Push from the installed app

If you have [installed WatchFor](/blog/uptime-monitoring-app-pwa) on your phone
or desktop, you can turn on push for that device under **Settings →
Notifications → Push notifications**. It is personal and per device, and you
choose what pushes: incidents opening (on by default), incidents resolving
(on) and someone acknowledging (off).

On Android and desktop Chrome or Edge, the notification has an
**Acknowledge** button: it acknowledges as you, without opening anything, and
the activity log records it like an acknowledgement made in the dashboard.
That stops repeat reminders, and the rest of the team can see that someone
took it.

The limits are platform ones. On iPhone and iPad, push works only from the
installed app (iOS 16.4 or later), and there is no Acknowledge button there —
tapping opens the incident instead. Safari and Firefox don't show action
buttons either.

## Slack and Discord: where the team watches

Slack and Discord need an incoming-webhook URL from the channel you want
alerts in (Discord: *Server Settings → Integrations → Webhooks*). Both get
colour-coded messages — red, amber, green — rather than a blob of text.

The thing that keeps team chat usable during a bad night is **grouping**.
When one failure takes several monitors down at once, chat and email
channels don't get a message per incident. The first message goes out within
30 seconds and carries everything that fired in that window:

> 🔴 **5 new incidents**
> 🔴 api.example.com — Probe failed to connect
> 🔴 www.example.com — Unexpected HTTP Status
> …

Follow-ups about incidents already announced, such as recoveries, are batched
for up to five minutes. A lone incident still arrives promptly as a normal,
fully detailed message. Phone channels (ntfy, Pushover, Gotify, Pushbullet)
and incident tools deliver per incident instead, because on a phone each
alert should be its own thing.

## When it has to reach a person, not a room

Shared channels are for teams. When a specific person is on call, use
[on-call schedules](/blog/on-call-scheduling-in-watchfor): escalations page
people through their **own** notification methods (email, Telegram, ntfy,
Pushover, Gotify or Pushbullet), set up once under **Alerting → On-call → My
notifications**. Whoever is on call this week gets paged on *their* phone,
not on a topic someone set up two years ago.

And if you already run on-call in PagerDuty or Opsgenie, send alerts there.
Incidents open there when they open in WatchFor and close when they resolve.

## Check the wiring before you need it

Three habits catch most routing mistakes before they cost you a Saturday:

- **Send test** on every new channel (**⋯ → Send test**). Note that a test to
  PagerDuty or Opsgenie opens a real `[TEST]` incident there, which you close
  by hand.
- Look at the dashboard's **Silent Monitors** card: it lists monitors whose
  incidents would reach no channel at all.
- After an incident, open the **Delivery log**. It shows every message per
  channel, whether it was sent, and for which incident.

![The Delivery log in the Acme organization filtered to Payments API: each critical incident delivered to the default email channel, the Payments phones ntfy channel and the Payments webhook, all marked Sent](/blog/uptime-alerts-telegram-ntfy-slack-delivery.webp)

Need quiet for an hour while you work on something? **Mute alerts** from the
monitor's ⋯ menu for 1, 8 or 24 hours or 7 days. Checks keep running and
incidents keep recording; only the notifications pause. For planned work,
[maintenance windows](/blog/maintenance-windows-done-right) do the same and
keep it out of your uptime.

## The short version

- Put the alert where the person who has to act will see it at the hour it
  happens. For outages at night, that's a phone, not an inbox.
- Use contact groups for *who* and the severity filter for *how loud*.
- Telegram and ntfy take a minute to set up and work well for one person or a
  small team; app push adds a one-tap Acknowledge on Android and desktop.
- Test every channel once, and keep an eye on Silent Monitors.

Every channel and its exact setup: [notification channels](/docs/notifications).
The full list of integrations: [alerting integrations](/alerting-integrations).

---

Canonical page: https://watchfor.io/blog/uptime-alerts-telegram-ntfy-slack · All articles: https://watchfor.io/blog/all.md · Site guide: https://watchfor.io/llms.txt
