> ## Documentation Index
> Fetch the complete documentation index at: https://pulse-41cf5b0d.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Set Up Notification Channels for Alerts
> Connect PulseGuard to Email, Slack, Discord, Webhooks, Telegram, and SMS to receive instant downtime and recovery notifications.
Notification channels are the delivery destinations that PulseGuard uses to reach your team when an alert rule fires. You create channels once and then attach them to as many alert rules as you need across any number of monitors. PulseGuard supports six channel types — covering everything from a personal inbox to a custom webhook endpoint that feeds your own incident tooling.
## Supported Channel Types
PulseGuard delivers alerts over six distinct transports. Each has its own configuration requirements and message format tailored to that medium. You can create multiple channels of the same type — for example, two separate Slack channels, one for a general ops feed and one for a critical-only on-call channel.
PulseGuard delivers alerts via **Resend**, a transactional email API. Emails are rendered as rich HTML using React Email templates and include all the context your team needs to act without opening the dashboard.
**What each email contains:**
* Monitor name and target URL
* Current status (`DOWN` or `UP`) and the previous status
* Detected latency (or `0` for connection failures)
* Error reason (for example, `CONNECTION_REFUSED` or `SSL_HANDSHAKE_FAILED`)
* Downtime duration on recovery emails
* Failed regions, if the outage was isolated to specific locations
* A link to your runbook, if one is configured on the monitor
**How to configure:**
1. Navigate to **Settings → Notification Channels** and click **New Channel**.
2. Select **Email** as the channel type.
3. Enter the destination email address. This can be any address — it does not need to match your PulseGuard account email.
4. Click **Save**.
PulseGuard also automatically emails the monitor owner's account address when a matching alert rule fires, regardless of whether an explicit Email channel is attached. Configure a dedicated Email channel when you want alerts sent to a shared inbox, a distribution list, or a different address entirely.
The Slack integration sends **Block Kit** messages — structured, interactive notifications that go beyond plain text. Downtime alerts include action buttons so your team can acknowledge or resolve an incident directly from Slack without switching to the dashboard.
**What each Slack message contains:**
* Alert header with emoji status indicator
* Target URL and current status
* Alert details and error reason
* Downtime duration on recovery messages
* Failed regions, if applicable
* A link to your runbook, if configured
* **Action buttons** on incident alerts: *View Dashboard*, *Acknowledge*, and *Resolve*
**How to configure:**
1. Navigate to **Settings → Notification Channels** and click **New Channel**.
2. Select **Slack** as the channel type.
3. Click **Authorize with Slack** to start the OAuth flow. You will be redirected to Slack to approve the PulseGuard app for your workspace.
4. After authorization, select the Slack channel where alerts should be posted.
5. Click **Save**.
Create a dedicated `#pulseguard-alerts` channel and route all critical monitors there, then use a separate channel for lower-severity or informational alerts. This makes it easier to triage noise from signal.
The Discord integration posts rich **embedded messages** to any Discord channel via an incoming webhook. Embeds are color-coded by status: red for DOWN, green for UP/recovered, and orange for high-latency or SSL expiry warnings.
**What each Discord embed contains:**
* Color-coded status bar (red / green / orange)
* Title with emoji and monitor name
* Description with the error reason or recovery message
* Inline fields: target URL, timestamp, downtime duration
* Failed regions field, if applicable
* Runbook link, if configured
**How to configure:**
1. In Discord, open your server's **Server Settings → Integrations → Webhooks**.
2. Click **New Webhook**, choose the target channel, and copy the webhook URL.
3. In PulseGuard, navigate to **Settings → Notification Channels** and click **New Channel**.
4. Select **Discord** as the channel type.
5. Paste the webhook URL into the **Discord Webhook URL** field.
6. Click **Save**.
The Webhook channel lets you integrate PulseGuard with any system that can receive an HTTPS POST request — incident management platforms, custom scripts, log aggregators, or your own internal tooling.
PulseGuard sends a `POST` request with a `Content-Type: application/json` header and the following payload shape:
```json theme={null}
{
"type": "INCIDENT_CREATED",
"incidentId": "clx...",
"monitorId": "clx...",
"monitorName": "Production API",
"url": "https://api.example.com/health",
"status": "DOWN",
"previousStatus": "UP",
"latency": 0,
"timestamp": "2024-01-15T10:30:00.000Z",
"reason": "CONNECTION_REFUSED",
"failedRegions": ["us-east-1", "eu-west-1"],
"runbookUrl": "https://docs.example.com/runbooks/api",
"daysRemaining": null
}
```
| Field | Type | Description |
| ---------------- | ----------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| `type` | `"INCIDENT_CREATED" \| "INCIDENT_RESOLVED" \| "HIGH_LATENCY" \| "SSL_EXPIRY"` | The event type that triggered this notification |
| `incidentId` | `string \| undefined` | ID of the associated incident, if one was created |
| `monitorId` | `string` | Unique ID of the monitor |
| `monitorName` | `string` | Human-readable monitor name |
| `url` | `string` | The URL or endpoint being monitored |
| `status` | `"UP" \| "DOWN"` | Current status after the event |
| `previousStatus` | `"UP" \| "DOWN" \| undefined` | Status before this event |
| `latency` | `number \| undefined` | Response time in milliseconds; `0` for connection failures |
| `timestamp` | `string` | ISO 8601 UTC timestamp of the event |
| `reason` | `string \| undefined` | Machine-readable error code or description, if available |
| `failedRegions` | `string[] \| undefined` | List of edge regions that reported failures, if applicable |
| `runbookUrl` | `string \| undefined` | Runbook URL configured on the monitor, if any |
| `daysRemaining` | `number \| undefined` | Days until SSL certificate expiry, present on `SSL_EXPIRY` events |
**How to configure:**
1. Navigate to **Settings → Notification Channels** and click **New Channel**.
2. Select **Webhook** as the channel type.
3. Enter the destination URL. The URL must use HTTPS.
4. Click **Save**.
Your endpoint must respond with a `2xx` status code within the request timeout window. PulseGuard will log delivery failures, but failed webhook deliveries are not automatically retried — ensure your endpoint is reliable and returns promptly.
The Telegram integration sends formatted text messages to any Telegram chat — personal, group, or channel — through a bot you control.
**What each Telegram message contains:**
* Monitor name and current status
* Target URL
* Error reason and timestamp
* Downtime duration on recovery messages
**How to configure:**
1. Open Telegram and start a conversation with **@BotFather**.
2. Send `/newbot` and follow the prompts to create a new bot. Copy the **bot token** BotFather provides.
3. Add the bot to the target chat (group or channel), or start a direct conversation with the bot.
4. Retrieve your **chat ID**. For a personal chat, you can get this by sending a message to your bot and calling `https://api.telegram.org/bot/getUpdates` — the `chat.id` field in the response is your chat ID. For groups, add the bot and use the same method.
5. In PulseGuard, navigate to **Settings → Notification Channels** and click **New Channel**.
6. Select **Telegram** as the channel type.
7. Enter the **Bot Token** and **Chat ID**.
8. Click **Save**.
The SMS channel sends brief plain-text messages to any phone number, providing an ultra-low-friction alert path for on-call engineers who may not have app notifications enabled.
**What each SMS contains:**
* Monitor name and status (`DOWN` or `UP`)
* Brief error reason, if available
* Timestamp
**How to configure:**
1. Navigate to **Settings → Notification Channels** and click **New Channel**.
2. Select **SMS** as the channel type.
3. Enter the destination phone number in E.164 format (for example, `+14155552671`).
4. Click **Save**.
SMS delivery is subject to carrier routing and regional availability. For time-critical on-call workflows, pair SMS with a Slack or webhook channel to ensure delivery redundancy.
## Testing a Channel
Before relying on a channel in production, send a test notification to confirm delivery end-to-end. Test notifications exercise the full delivery pipeline — they go through the same notification handler as live alerts.
Navigate to **Settings → Notification Channels** and click the channel you want to test.
Click **Send Test Notification**. PulseGuard immediately dispatches a sample alert payload to the configured destination using the current channel configuration. The test exercises the full notification pipeline, so delivery confirms your channel is correctly set up end-to-end.
Check the destination — your inbox, Slack channel, Discord server, webhook logs, Telegram chat, or SMS inbox — and confirm the message arrived with the expected format.
If the test notification does not arrive, open **Settings → Notification Channels → Delivery Logs** to inspect the raw response from the downstream service. Common issues include expired OAuth tokens (Slack), incorrect webhook URLs (Discord), or invalid bot tokens (Telegram).
Run a test notification any time you update a channel's configuration — for example, after rotating a Slack token or changing a webhook URL — to confirm the new settings are valid before the next real alert fires.