Set Up Slack Alerts for API Breaking Changes

You shouldn't have to check a dashboard to find out if a critical API changed. When a breaking change happens, your team should know immediately — in the channel where they're already working.

This tutorial shows you how to connect Rumbliq to Slack so your team gets an instant notification the moment a monitored API changes its schema. We'll also cover how to use Rumbliq's outbound webhooks for custom integrations with PagerDuty, Discord, Microsoft Teams, or any endpoint that accepts HTTP POST requests.

Prerequisites

• A Rumbliq account with at least one monitor set up
• A Slack workspace where you want to receive alerts
• Slack admin permissions to create an incoming webhook (or ask your Slack admin)

Part 1: Configure Slack Alerts in Rumbliq

Step 1: Create a Slack Incoming Webhook

First, create the webhook in Slack:

1. Go to api.slack.com/apps and click Create New App
2. Choose From scratch, name it Rumbliq Alerts, select your workspace
3. In the left sidebar, click Incoming Webhooks
4. Toggle Activate Incoming Webhooks to On
5. Click Add New Webhook to Workspace
6. Choose the channel where you want alerts (e.g., #api-alerts or #engineering)
7. Click Allow
8. Copy the webhook URL — it looks like:

   https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX
   

Tip: Create a dedicated #api-drift-alerts channel. This keeps API change notifications organized and searchable, separate from general engineering chat.

Step 2: Add the Alert in Rumbliq

1. Log in to rumbliq.com
2. Click Alerts in the left sidebar
3. Click New Alert
4. Choose Slack as the destination type
5. Paste your Slack webhook URL
6. Give it a name: Slack - #api-alerts

Step 3: Configure Alert Severity

Each alert has a single minimum severity threshold. The alert fires for any change at or above that level:

For a high-traffic #api-alerts channel, set the threshold to Info so you see every change. For a narrower #incidents channel, set it to Breaking so only the most serious changes get through.

Note: Alerts are account-wide (or team-wide if the alert belongs to a team) — they apply to every monitor on the account or team. Rumbliq doesn't scope an individual alert to a subset of monitors. To route different severities to different channels, create multiple alert destinations, each with its own minimum severity (see Part 3).

Step 4: Test the Alert

Click Test Alert in the alert settings. Rumbliq sends a sample notification to your Slack channel:

🔔 Rumbliq Test Alert
Monitor: Stripe Payment Intents
This is a test notification from Rumbliq.

If you see it in Slack, your integration is working. If not, double-check the webhook URL — Slack webhook URLs are long and easy to truncate accidentally.

What a Real Alert Looks Like

When Rumbliq detects a breaking change, your Slack message will look something like this:

🚨 Breaking API Change Detected

Monitor: Stripe Payment Intents
URL: https://api.stripe.com/v1/payment_intents
Detected at: 2026-03-27 14:32:11 UTC

Changes:
• amount: type changed number → string (breaking)
• currency: changed from required → optional (breaking)
• amount_decimal: new field added (non-breaking)

View full diff → https://rumbliq.com/monitors/mon_abc123/checks/chk_xyz

For non-breaking changes:

ℹ️ API Schema Update (Non-Breaking)

Monitor: GitHub OAuth
URL: https://api.github.com/user
Detected at: 2026-03-27 09:15:44 UTC

Changes:
• notification_email: new field added (non-breaking)
• two_factor_authentication: new field added (non-breaking)

View full diff → https://rumbliq.com/monitors/mon_ghi789/checks/chk_abc

The direct link takes your team straight to the Rumbliq diff view so they can understand the full change in context.

Part 2: Use the Webhook Alert Type for Custom Integrations

Rumbliq's Webhook alert type sends a structured HTTP POST to any URL when drift is detected. This lets you build custom integrations with any platform.

Webhook Payload Format

When Rumbliq fires a webhook alert, it sends:

{
  "check_id": "chk_xyz789",
  "monitor_id": "mon_abc123",
  "monitor_name": "Stripe Payment Intents",
  "endpoint_url": "https://api.stripe.com/v1/payment_intents",
  "detected_at": "2026-03-27T14:32:11.000Z",
  "summary": "BREAKING: type_changed at $.data.amount\nINFO: field_added at $.data.amount_decimal",
  "changes": [
    {
      "type": "type_changed",
      "path": "$.data.amount",
      "previousType": "number",
      "currentType": "string",
      "severity": "breaking"
    },
    {
      "type": "field_added",
      "path": "$.data.amount_decimal",
      "currentType": "string",
      "severity": "info"
    }
  ]
}

The payload is flat and uses snake_case. Each entry in changes is a drift change with a type (field_removed, field_added, type_changed, nullability_changed, or array_shape_changed), a JSONPath path, optional previousType / currentType, and a severity of info, warning, or breaking.

Create a Webhook Alert

1. In Rumbliq, go to Alerts → New Alert
2. Choose Webhook as the destination type
3. Paste your target URL
4. Set the minimum severity that should trigger delivery

Rumbliq POSTs the JSON payload above with a Content-Type: application/json header. Custom headers aren't supported, so if you need to authenticate inbound requests, put a secret token in the URL itself (e.g., a path segment or query parameter) and validate it on your side.

Example: Receive Webhooks in an Express Server

Here's a minimal Node.js/Express handler that receives Rumbliq alerts and logs breaking changes:

import express from 'express'

const app = express()
app.use(express.json())

app.post('/webhooks/rumbliq', (req, res) => {
  const { monitor_name, changes } = req.body

  const breakingChanges = changes.filter((c: any) => c.severity === 'breaking')

  if (breakingChanges.length > 0) {
    console.error(`🚨 Breaking changes on ${monitor_name}:`)
    breakingChanges.forEach((change: any) => {
      console.error(`  - ${change.path}: ${change.type}`)
    })

    // Trigger your incident workflow here
    // e.g., create a PagerDuty incident, post to your ops channel, etc.
  }

  res.status(200).send('ok')
})

app.listen(3000, () => console.log('Webhook receiver running on port 3000'))

Return 200 OK promptly. Rumbliq treats any non-2xx response (or no response within the 15-second timeout) as a delivery failure. It does not retry, so keep your handler fast — respond first, then do any heavy work asynchronously.

Integrate with PagerDuty

For critical APIs where breaking changes require an immediate on-call page, route Rumbliq webhooks to PagerDuty using their Events API v2:

import express from 'express'

const app = express()
app.use(express.json())

const PAGERDUTY_ROUTING_KEY = process.env.PAGERDUTY_ROUTING_KEY!

app.post('/webhooks/rumbliq', async (req, res) => {
  // Respond immediately to avoid delivery failure
  res.status(200).send('ok')

  const { monitor_id, monitor_name, endpoint_url, check_id, changes } = req.body
  const breakingChanges = changes.filter((c: any) => c.severity === 'breaking')

  if (breakingChanges.length === 0) return

  // Create PagerDuty incident
  await fetch('https://events.pagerduty.com/v2/enqueue', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      routing_key: PAGERDUTY_ROUTING_KEY,
      event_action: 'trigger',
      dedup_key: `rumbliq-${monitor_id}-${check_id}`,
      payload: {
        summary: `Breaking API change: ${monitor_name}`,
        severity: 'critical',
        source: 'Rumbliq',
        custom_details: {
          monitor_url: endpoint_url,
          breaking_changes: breakingChanges.map((c: any) =>
            `${c.path}: ${c.type}`
          ).join(', '),
          rumbliq_check_url: `https://rumbliq.com/monitors/${monitor_id}/checks/${check_id}`
        }
      }
    })
  })
})

Integrate with Microsoft Teams

Microsoft Teams uses its own incoming webhook format. Here's how to forward Rumbliq alerts to a Teams channel:

app.post('/webhooks/rumbliq', async (req, res) => {
  res.status(200).send('ok')

  const { monitor_id, monitor_name, endpoint_url, changes } = req.body
  if (!changes || changes.length === 0) return

  const TEAMS_WEBHOOK_URL = process.env.TEAMS_WEBHOOK_URL!

  const breakingChanges = changes.filter((c: any) => c.severity === 'breaking')
  const emoji = breakingChanges.length > 0 ? '🚨' : 'ℹ️'
  const severity = breakingChanges.length > 0 ? 'Breaking Change' : 'Non-Breaking Update'

  await fetch(TEAMS_WEBHOOK_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      '@type': 'MessageCard',
      '@context': 'http://schema.org/extensions',
      themeColor: breakingChanges.length > 0 ? 'FF0000' : 'FFA500',
      summary: `${emoji} API ${severity}: ${monitor_name}`,
      sections: [{
        activityTitle: `${emoji} ${severity}: ${monitor_name}`,
        activitySubtitle: endpoint_url,
        facts: changes.map((c: any) => ({
          name: c.path,
          value: `${c.type}${c.severity === 'breaking' ? ' ⚠️ breaking' : ''}`
        })),
        potentialAction: [{
          '@type': 'OpenUri',
          name: 'View in Rumbliq',
          targets: [{
            os: 'default',
            uri: `https://rumbliq.com/monitors/${monitor_id}`
          }]
        }]
      }]
    })
  })
})

Part 3: Routing Alerts to the Right Channels

For larger engineering teams, routing every change to a single channel creates noise. Because each alert has a single minimum-severity threshold, you control the volume per channel by creating multiple alert destinations at different thresholds:

Set this up in Rumbliq by creating multiple alert destinations, each with:

• Different Slack webhook URLs (pointing to different channels)
• Different minimum-severity thresholds

Note that alerts apply account-wide (or team-wide); Rumbliq doesn't route an individual alert to a hand-picked subset of monitors. To separate alerting by team or service, use separate teams — each team's alerts cover only that team's monitors.

Verifying Your Setup End-to-End

Before relying on these alerts in production, verify the full pipeline works:

1. Trigger a test alert: In Rumbliq, go to your alert and click Test Alert. Confirm it arrives in Slack.

2. Simulate drift detection: If you have a test API endpoint under your control, change its response structure and wait for Rumbliq to detect it. Verify the full alert arrives with the correct diff.

3. Verify webhook delivery: If using the Webhook alert type, check your server logs to confirm Rumbliq reached your endpoint successfully.

4. Test alert routing: For multiple alert destinations, verify each one routes correctly by sending test alerts from each.

Troubleshooting

No alert in Slack after test:

• Check that the webhook URL wasn't truncated when pasting
• Verify the Slack app is still installed in your workspace (Settings → Integrations)
• Check if the target channel was deleted or archived

Webhook deliveries failing:

• Ensure your endpoint returns a 2xx response within the 15-second timeout
• Confirm your endpoint is publicly reachable (Rumbliq blocks private and internal addresses for SSRF safety)
• If you authenticate via a token in the URL, verify it's still valid

Getting too many alerts (noise):

• Raise the minimum severity on noisy alert destinations (e.g., from Info to Breaking)
• Create separate alert destinations with different minimum-severity thresholds
• Split monitors across teams so each team's alerts only cover its own monitors

Related Posts

• API alerting best practices
• API breaking change alerts
• how to detect breaking API changes

Summary

In under 15 minutes, you've set up:

1. A Slack channel dedicated to API drift alerts
2. Rumbliq wired to send immediate notifications on breaking changes
3. Optionally: a custom webhook receiver for PagerDuty, Teams, or any integration

Your team will know about breaking API changes the moment Rumbliq detects them — without anyone having to check a dashboard.

Set up your first alert →