Integrations

Connect Runframe to your existing monitoring, alerting, and communication tools.

Overview

Runframe integrates with the tools you already use to create incidents automatically, sync updates, and streamline incident response. Reduce toil and ensure no alert goes unnoticed.

Why integrate?

Slack

Runframe’s deepest integration is with Slack, your incident command center.

Features

Installation

1. Visit the Slack App Directory or use the link from your Runframe dashboard
2. Click Add to Slack
3. Grant Runframe permissions:
   • Create channels
   • Send messages
   • View user information
4. Complete installation and sign in to Runframe

Slash commands

Once installed, use these commands from any Slack channel:

See the Slash Commands guide for complete documentation.

Webhook configuration

For bi-directional sync, configure the Slack webhook URL in Runframe:

1. Navigate to Settings → Integrations → Slack
2. Copy the webhook URL provided by Runframe
3. Paste into your Slack app configuration
4. Test the connection

Incident channel naming

Runframe creates incident channels with a consistent naming pattern:

inc-YYYY-MM-DD-###

Example: inc-2025-01-15-001

Customize the naming pattern in Settings if needed.

Datadog

Create incidents automatically from Datadog monitors and alerts.

Setup from Runframe

1. Navigate to Settings → Integrations → Datadog
2. Click Connect Datadog
3. Enter your Datadog API key and application key
4. Click Test Connection to verify
5. Configure which monitors should create incidents

Setup from Datadog

1. In Datadog, navigate to Integrations → Webhooks
2. Create a new webhook
3. Use the Runframe webhook URL: https://api.runframe.io/webhooks/datadog
4. Customize the payload to include incident details
5. Associate the webhook with your monitors

Datadog to Runframe field mapping

Severity mapping

Configure how Datadog alert priorities map to Runframe severities:

Bi-directional sync

When enabled, Runframe status updates post back to Datadog:

• Investigating → Alert acknowledges
• Identified → Alert updates with root cause
• Monitoring → Alert notes fix deployed
• Resolved → Alert resolves

Sentry

Create incidents from Sentry error events and alerts.

Setup

1. Navigate to Settings → Integrations → Sentry
2. Click Connect Sentry
3. Enter your Sentry organization slug and authentication token
4. Click Test Connection
5. Configure which projects and alert rules should create incidents

Sentry to Runframe field mapping

Severity mapping

Bi-directional sync

Enable bi-directional sync to link Runframe incidents to Sentry issues:

• Runframe creates a Sentry issue note when incident is created
• Status updates in Runframe post to Sentry issue comments
• Resolved Runframe incidents resolve Sentry issues (optional)

Prometheus

Create incidents from Prometheus alert rules via Alertmanager.

Setup

1. Navigate to Settings → Integrations → Prometheus
2. Copy the Runframe webhook URL
3. In Alertmanager, configure a webhook receiver:

receivers:
  - name: 'runframe'
    webhook_configs:
      - url: 'https://api.runframe.io/webhooks/prometheus'
        send_resolved: true

4. Associate the receiver with your alert routes

Prometheus to Runframe field mapping

Severity mapping

Alertmanager configuration example

route:
  group_by: ['alertname', 'cluster', 'service']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 12h
  receiver: 'runframe'
 
receivers:
  - name: 'runframe'
    webhook_configs:
      - url: 'https://api.runframe.io/webhooks/prometheus?api_key=YOUR_KEY'
        send_resolved: true

PagerDuty

Migrate from PagerDuty or run both tools in parallel during transition.

Migration mode

Runframe can receive PagerDuty webhooks to create incidents while you transition:

1. Navigate to Settings → Integrations → PagerDuty
2. Copy the Runframe webhook URL
3. In PagerDuty, create a webhook extension:
   • Go to Service → Integrations → Extensions
   • Add a Generic Webhook extension
   • Paste the Runframe URL
4. Configure which services should send webhooks

PagerDuty to Runframe field mapping

Bi-directional sync

Enable bi-directional sync to:

• Update PagerDuty incidents when Runframe status changes
• Acknowledge PagerDuty alerts from Runframe
• Resolve PagerDuty incidents when Runframe incidents resolve

Custom webhooks

Create incidents from any tool that supports webhooks.

Setup

1. Navigate to Settings → Integrations → Custom Webhooks
2. Click New Webhook
3. Copy the unique webhook URL
4. Configure your tool to POST to this URL

Webhook payload format

Send a JSON payload with these fields:

{
  "title": "Incident title",
  "description": "What's happening",
  "severity": "P1",
  "service": "service-name",
  "affected_services": ["api", "database"],
  "customer_impact": true,
  "tags": {
    "environment": "production",
    "region": "us-east-1"
  }
}

Required and optional fields

Example: Custom monitoring script

curl -X POST https://api.runframe.io/webhooks/custom/YOUR_WEBHOOK_ID \
  -H "Content-Type: application/json" \
  -d '{
    "title": "High memory usage on production servers",
    "description": "Memory usage above 90% on 3 servers",
    "severity": "P1",
    "service": "backend-api",
    "customer_impact": true
  }'

API

Build custom integrations with the Runframe REST API.

Authentication

All API requests require an API key:

curl https://api.runframe.io/v1/incidents \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

Create an incident

curl https://api.runframe.io/v1/incidents \
  -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "API latency spike",
    "severity": "P1",
    "description": "API response times > 5s",
    "affected_services": ["api-backend"],
    "customer_impact": true
  }'

Update an incident

curl https://api.runframe.io/v1/incidents/INC-042 \
  -X PATCH \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "status": "identified"
  }'

See the API reference for complete documentation.

Testing integrations

After setting up an integration, verify it works correctly.

Test incident creation

1. Trigger a test alert from your monitoring tool
2. Verify Runframe creates the incident
3. Check that field mapping is correct
4. Confirm the right people were notified

Test bi-directional sync

1. Create an incident in Runframe
2. Update the status
3. Verify the update reflects in the integrated tool
4. Resolve the incident and confirm sync

Monitoring integration health

Runframe tracks integration health:

View integration health in Settings → Integrations.

Best practices

Integration strategy

Do:

• Start simple – Begin with 1 to 2 critical integrations
• Test thoroughly – Verify integrations work before relying on them
• Document customizations – Keep records of field mappings and severity rules
• Monitor health – Check integration status regularly

Don’t:

• Don’t create duplicate incidents – Deduplicate alerts from multiple sources
• Don’t over-automate – Manual control for high-severity incidents
• Don’t ignore errors – Failed webhooks need investigation
• Don’t set and forget – Review integration quarterly

Reducing alert noise

Integrations can create too many incidents. Reduce noise:

• Aggregate alerts – Group similar alerts into a single incident
• Set thresholds – Only create incidents for alerts exceeding severity
• Time-based windows – Suppress repeated alerts within a time window
• Smart deduplication – Link duplicate incidents instead of creating new ones

Need more?

• Slash Commands – Complete /inc command reference
• Incidents – Incident lifecycle and severity
• On-Call – Scheduling and rotations
• Webhooks – Custom webhook integrations
• Web Dashboard – Integration management UI