Integrations reference

Notification channel integrations

Configure channels under Settings > Notification channels.

Slack

HowlOps posts a message with the incident summary, severity, and a direct link to the monitor. The message is delivered to whatever channel the incoming webhook was created for (there is no separate channel-override field). Slack must authorize the incoming webhook for your workspace.

To set up: In Slack, go to Apps > Incoming Webhooks > Add to Slack > select channel > copy the webhook URL.

Discord

In Discord: channel settings > Integrations > Webhooks > New Webhook > copy URL.

Telegram

Create a bot via @BotFather on Telegram, then send /newbot to obtain the token.

Email

HowlOps sends email via its own transactional mail provider. No SMTP credentials are required.

PagerDuty

In PagerDuty: Services > select service > Integrations > Add integration > Events API v2 > copy the Integration Key.

OpsGenie

In OpsGenie: Settings > Integrations > API > copy the API Key.

Generic webhook

See Webhooks reference for payload shapes.

Microsoft Teams

In Teams: channel > ... > Workflows > template Post to a channel when a webhook request is received > copy the generated URL.

Microsoft retired Office 365 Connector webhooks in May 2026. Legacy outlook.office.com/webhook/… and <tenant>.webhook.office.com/… URLs are dead and are rejected when you save a channel. See Teams via Workflows to migrate an existing channel.

Google Chat

In Google Chat: space > Apps & integrations > Webhooks > Add > copy URL.

ntfy

Gotify

Apprise

Inbound integrations

HowlOps can receive alerts from external monitoring systems and convert them to incidents. Eight inbound sources are supported: Prometheus Alertmanager, Grafana, Datadog, AWS CloudWatch (via SNS), Sentry, Azure Monitor, Google Cloud Monitoring, and a generic webhook.

Prometheus Alertmanager

HowlOps accepts Alertmanager alerts two ways, and both are free: a native opsgenie_configs receiver, or a plain webhook_configs receiver. Use whichever fits your setup. The opsgenie_configs route is shown first, and the webhook_configs alternative is right below it.

Generate a Prometheus / Alertmanager endpoint from the Integrations hub (the source card → Generate endpoint) to obtain a token (starts with howl_), then use it as the receiver api_key:

receivers:
  - name: howlops
    opsgenie_configs:
      - api_url: https://api.howlops.com/api/v1/prometheus/
        api_key: howl_YOUR_TOKEN_HERE
        send_resolved: true

api_url must end with a trailing slash (Alertmanager appends v2/alerts). Auth is sent as Authorization: GenieKey <token> automatically by the OpsGenie receiver. Incident severity comes from the OpsGenie priority (P1/P2 → critical, P3 → warning, P4/P5 → info); set the receiver's priority field to map it from your labels.

Alternative: plain webhook_configs

If you would rather not use the OpsGenie receiver, point a standard Alertmanager webhook_configs receiver at HowlOps instead. Use the same token from the Integrations hub, sent as a Bearer credential:

receivers:
  - name: howlops
    webhook_configs:
      - url: https://api.howlops.com/api/v1/webhook/alertmanager
        send_resolved: true
        http_config:
          authorization:
            type: Bearer
            credentials: howl_YOUR_TOKEN_HERE

HowlOps parses Alertmanager's native webhook payload, so firing and resolved alerts dedupe and auto-resolve exactly like the opsgenie_configs route. Both routes are free. See the Alertmanager setup guide for a full walkthrough.

Grafana, Datadog, AWS CloudWatch, and generic webhook

Grafana (legacy and unified alerting), Datadog, AWS CloudWatch (delivered via SNS), and any generic system are received on a single token-scoped endpoint. Create an inbound integration from the Integrations hub (pick the source card → Generate endpoint) to obtain a token, then point the source at:

POST https://api.howlops.com/api/v1/webhooks/incoming/<integration_token>
Content-Type: application/json

{
  "title": "Deploy failed",
  "severity": "critical"
}

The payload is parsed according to the source type you selected when you generated the endpoint (Grafana, Datadog, CloudWatch, or generic) — the format is not auto-detected, so pick the matching source when creating the integration.

Sentry, Azure Monitor, and Google Cloud Monitoring

These three also ride the same token-scoped endpoint as Grafana/Datadog/CloudWatch above, but each parses the vendor's own native webhook payload directly — point the tool's alert webhook straight at the URL below, no reshaping required. Create an inbound integration from the Integrations hub (pick the source card → Generate endpoint) to obtain a token, selecting type sentry, azure, or gcp, then configure the vendor with:

POST https://api.howlops.com/api/v1/webhooks/incoming/<integration_token>
Content-Type: application/json

The payload is parsed according to the source type you selected when you generated the endpoint — pick the matching source, since the format is not auto-detected.

Sentry — In Sentry: Settings > Developer Settings > create an Internal Integration, set its Webhook URL to the endpoint above, and subscribe it to the Issue resource (lifecycle events: created/resolved/ignored/assigned/unresolved) and/or enable it as an alert rule action to receive Issue Alert notifications (fires when an alert rule matches). Only an explicit resolved status closes the HowlOps incident — ignored does not, since the underlying problem may still exist. Sentry's level maps to HowlOps severity: fatal/error → critical, warning → warning, info/debug → info.

Azure Monitor — In Azure: your alert rule's Action Groups > add or edit a Webhook action with the endpoint above as its URI, and set Enable the common alert schema to Yes on that action — HowlOps parses the common alert schema's data.essentials envelope, which Azure only sends once the schema is enabled on the action. Metric, log, activity-log, and Prometheus-based alert rules all work the same way. A monitorCondition of Resolved closes the HowlOps incident. Azure's severity (Sev0–Sev4) maps to HowlOps severity: Sev0/Sev1 → critical, Sev2 → warning, Sev3/Sev4 → info.

Google Cloud Monitoring — In Google Cloud Console: Monitoring > Alerting > Edit notification channels > Webhooks > add a channel with the endpoint above as its URL, then attach it to your alerting policy. An incident state of closed closes the HowlOps incident. GCP's webhook payload does not always include a severity field — when it's absent, HowlOps applies its default (warning).

Integration matrix

There are 21 outbound notification channels and 8 inbound integration sources.

CI/CD (GitHub Actions)

Pause a monitor during a deployment to avoid false alarms, then resume it afterward. Store your API token as a repository secret (HOWLOPS_API_KEY) and the monitor ID as MONITOR_ID:

# .github/workflows/deploy.yml
- name: Pause monitor
  run: |
    curl -X POST https://api.howlops.com/api/v1/monitors/$MONITOR_ID/pause \
      -H "Authorization: Bearer $HOWLOPS_API_KEY"

- name: Deploy
  run: ./deploy.sh

- name: Resume monitor
  run: |
    curl -X POST https://api.howlops.com/api/v1/monitors/$MONITOR_ID/resume \
      -H "Authorization: Bearer $HOWLOPS_API_KEY"

The token needs the write scope to pause and resume. See Rotate an API token for scopes. For AI-assistant and programmatic control, see the MCP server.

See also

• Integrations for a guided, one-page-per-tool walkthrough of what each integration brings you and how to set it up.
• Webhooks reference
• Events reference
• REST API reference