Discord Alerts for MCP Server Downtime — webhook routing guide

Why Discord for MCP server alerting

Discord is the de-facto community platform for the MCP ecosystem. The official MCP Discord has thousands of members. The r/ClaudeAI and r/MCP communities cross-post to Discord servers. If you have published an MCP server, there is a reasonable chance your early adopters are on a Discord server where you are also present.

This creates a monitoring advantage that PagerDuty and OpsGenie do not have: proximity to users. When your server goes down and AliveMCP fires an alert to your #ops-alerts channel, users on your community Discord who encounter issues can be pointed to that channel thread for status updates. You can respond to both the alert and the community inquiry in the same tool. The alert becomes a live status post, not a private ops notification.

The key limitation of Discord for production alerting: Discord respects Do Not Disturb mode on mobile. A phone on DND will not vibrate for Discord notifications. PagerDuty and OpsGenie bypass DND using high-priority notification channels on iOS and Android. For MCP servers where downtime during sleeping hours is a critical business issue, layer Discord over a dedicated on-call tool rather than using it as the sole alerting channel.

Creating a Discord webhook

In your Discord server, go to Server Settings → Integrations → Webhooks → New Webhook. Name it "AliveMCP Alerts" and assign it to your #ops-alerts channel (create the channel first if needed). Copy the webhook URL — it looks like https://discord.com/api/webhooks/{id}/{token}. This URL is a secret: anyone with it can post to your channel. Store it in an environment variable, never in source code.

Consider creating a separate webhook for different severity tiers if your team monitors many servers:

• #ops-critical — production MCP servers, immediate response expected
• #ops-dependency — third-party MCP servers you depend on
• #ops-log — all events including resolved and brief blips

Embed format for MCP server alerts

Discord embeds are the structured message format that adds color, fields, and metadata to a message. For MCP server alerts, the embed color conveys status at a glance: red for down, green for recovered, orange for degraded/warning.

// discord-alert-bridge.js

const DISCORD_WEBHOOK_URL = process.env.DISCORD_WEBHOOK_URL;
const messageIdStore = new Map();  // in production: persist in Redis or DB

async function handleAliveMCPWebhook(req, res) {
  const event = req.body;
  const { type, server_slug, server_name, failure_reason, check_url, downtime_seconds } = event;

  const storeKey = `discord-msg-${server_slug}`;

  if (type === 'alert.triggered') {
    const existingMsgId = messageIdStore.get(storeKey);

    const embed = {
      title: `🔴 MCP server down: ${server_name}`,
      description: failure_reason,
      color: 0xE53E3E,          // red
      fields: [
        { name: 'Endpoint', value: `\`${check_url}\``, inline: true },
        { name: 'Status', value: 'DOWN', inline: true },
        { name: 'Dashboard', value: `[View on AliveMCP](https://alivemcp.com/status/${server_slug})`, inline: true },
      ],
      timestamp: new Date().toISOString(),
      footer: { text: 'AliveMCP · MCP endpoint monitoring' },
    };

    if (existingMsgId) {
      // Server is still down — update the existing message, don't spam
      await discordPatch(existingMsgId, { embeds: [embed] });
    } else {
      // First alert — post new message, ping the on-call role
      const resp = await discordPost({
        content: '<@&YOUR_ONCALL_ROLE_ID> MCP server alert',
        embeds: [embed],
      });
      const data = await resp.json();
      messageIdStore.set(storeKey, data.id);
    }
  }

  if (type === 'alert.resolved') {
    const msgId = messageIdStore.get(storeKey);

    const embed = {
      title: `✅ MCP server recovered: ${server_name}`,
      description: `Downtime: ${Math.ceil(downtime_seconds / 60)} minutes`,
      color: 0x38A169,          // green
      fields: [
        { name: 'Endpoint', value: `\`${check_url}\``, inline: true },
        { name: 'Status', value: 'UP', inline: true },
        { name: 'Dashboard', value: `[View on AliveMCP](https://alivemcp.com/status/${server_slug})`, inline: true },
      ],
      timestamp: new Date().toISOString(),
      footer: { text: 'AliveMCP · MCP endpoint monitoring' },
    };

    if (msgId) {
      await discordPatch(msgId, { content: '', embeds: [embed] });   // remove ping from resolved message
      messageIdStore.delete(storeKey);
    } else {
      await discordPost({ embeds: [embed] });   // no prior message to update
    }
  }

  res.status(200).json({ ok: true });
}

async function discordPost(body) {
  return fetch(`${DISCORD_WEBHOOK_URL}?wait=true`, {    // ?wait=true returns the message object
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(body),
  });
}

async function discordPatch(messageId, body) {
  return fetch(`${DISCORD_WEBHOOK_URL}/messages/${messageId}`, {
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(body),
  });
}

Three critical details in this bridge:

• ?wait=true on the initial POST. By default Discord webhooks return an empty 204 response. Adding ?wait=true makes Discord return the full message object including the id you need for subsequent PATCH calls.
• PATCH the existing message, don't POST new ones. AliveMCP sends alert.triggered every minute while the server is down. Without message deduplication, your channel would receive a new alert message every minute — 30 messages for a 30-minute outage. The PATCH approach updates the timestamp and failure reason on the existing message, creating a single running "incident ticket" in the channel.
• Remove the role ping on PATCH. The role ping (<@&ROLE_ID>) in the content field is only needed on the initial alert to notify the on-call person. On subsequent updates, set content: '' to avoid re-pinging every minute.

Thread-based incident tracking

For outages lasting more than 5 minutes, create a Discord thread on the alert message to keep status updates out of the main channel. The main channel message becomes the incident summary; the thread contains the timeline of updates.

// Create a thread on the alert message when downtime exceeds 5 minutes
async function createIncidentThread(messageId, serverName) {
  const resp = await fetch(
    `https://discord.com/api/v10/channels/${CHANNEL_ID}/messages/${messageId}/threads`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bot ${DISCORD_BOT_TOKEN}`,   // requires bot, not just webhook
      },
      body: JSON.stringify({
        name: `Incident: ${serverName} — ${new Date().toISOString().slice(0, 10)}`,
        auto_archive_duration: 1440,   // archive after 24h of inactivity
      }),
    }
  );
  return (await resp.json()).id;   // thread channel ID
}

async function postThreadUpdate(threadId, message) {
  await fetch(`https://discord.com/api/v10/channels/${threadId}/messages`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bot ${DISCORD_BOT_TOKEN}`,
    },
    body: JSON.stringify({ content: message }),
  });
}

Thread creation requires a Discord bot token (not just a webhook URL) because webhooks cannot create threads via the webhook API directly. If you prefer not to create a bot, post thread updates as regular messages in a dedicated #incident-log channel and reference the alert message with a message link.

Role setup for MCP server on-call

Create a Discord role named @mcp-oncall and assign it to yourself and any team members who should be paged for MCP server incidents. In Discord's notification settings for the server, set this role to always notify (bypass user's notification settings for server-level). On mobile, add the Discord server to your notification exceptions so role pings wake you up even when the phone is on DND — but note this is less reliable than PagerDuty's guaranteed phone call.

For a team with rotation, manually update the @mcp-oncall role membership at the start of each shift. If your team uses Google Calendar for on-call rotation, you can automate role membership updates with a small script that reads the calendar event and calls the Discord API to add/remove the role.

Layering Discord with PagerDuty

The most robust MCP server alerting setup combines Discord for visibility with PagerDuty for guaranteed escalation. The pattern:

1. AliveMCP fires the webhook to your bridge.
2. Your bridge simultaneously posts to Discord (for team awareness and community communication) AND calls PagerDuty Events API (for guaranteed on-call notification).
3. The on-call person acknowledges in PagerDuty (which stops the escalation) and posts a status update in the Discord incident thread (which keeps the community informed).
4. When the server recovers, AliveMCP sends alert.resolved, your bridge updates both the Discord message (green embed) and resolves the PagerDuty incident.

This pattern is standard practice for teams that have community MCP servers: Discord for the public-facing status thread, PagerDuty for the private on-call page. The Discord thread also serves as the public incident timeline if users ask "what happened?"

Further reading

• PagerDuty for MCP Servers — guaranteed on-call escalation
• OpsGenie for MCP Servers — team-based routing and scheduling
• MCP Server Alert Routing Architecture — multi-channel and deduplication design
• MCP Server Slack Alerts — channel routing and message formatting
• MCP Server Webhook Alerts — securing and verifying outbound webhooks
• MCP Server Incident Runbook — response playbook for common failures