Shipeasy
Bugs & Requests

Inbound alerts

File incidents from Google Cloud Monitoring, Prometheus Alertmanager, Grafana, AWS CloudWatch, Azure Monitor, Datadog — or any tool that can POST JSON — as alert tickets in your ops queue, with no relay to build or keep alive.

BetaOn this page · 12 min readWorks with · Google Cloud · Prometheus · Grafana · AWS · Azure · Datadog · any webhook

Infrastructure signals never reach your app's SDK: a load balancer's 5xx ratio, an SLO burn rate, a database at 95% CPU, a service that stopped serving. Inbound alerts let your monitoring stack deliver them into the same queue as your app errors and metric alerts. Each incident becomes an alert ticket that works like a native one. Routing rules, Slack and bell notifications, tags and coding-agent triggers all apply.

The endpoint runs on Shipeasy's edge, not inside your app. So when your API is failing, the alert that says so still lands.

Supported providers

ProviderHow it deliversOne ticket perCloses on
Google Cloud MonitoringWebhook channel, or Pub/Sub push (retries)Alerting policyclosed incident
Prometheus Alertmanagerwebhook_configs receiverAlert rule (alertname)resolved alert
GrafanaWebhook contact point (unified or legacy alerting)Folder + alert ruleresolved / ok
AWS CloudWatchSNS HTTPS subscription, or an EventBridge API destinationAlarmOK state
Azure MonitorAction group webhook (common alert schema)Alert ruleResolved
DatadogWebhooks integrationMonitorRecovered
Generic JSONAny tool that can POST a custom JSON bodygroup (or title)status: "closed"

The generic shape covers New Relic, Uptime Kuma, Checkly, Zabbix, Nagios, cron jobs and your own scripts. See the recipes.

Set up an endpoint

Pick the provider

Open Settings → Notifications → Inbound alerts and choose your provider. Each one is a separate endpoint with its own URL. A connected provider shows a green dot.

Generate the URL

Click Generate URL and copy it right away, because it is shown only once. It looks like this:

https://api.shipeasy.ai/inbound/alerts/<provider>/seinb_…

Point your monitoring at it

Follow that provider's section below, then send a test notification. Each delivery shows up in the log under the card.

The URL is the credential

The seinb_… secret at the end is the whole credential, so treat the URL like a password. It is not your admin key. All it can do is file alert tickets for one provider in one project. Only a hash of it is stored.

  • Rotate URL replaces it, and the old URL stops working at once.
  • Revoke turns the endpoint off. Tickets that are already open stay open.
  • If your tool can't put a secret in a URL, you can send the token two other ways. Either way, POST to https://api.shipeasy.ai/inbound/alerts/<provider> with no token at the end:
HowSend
HTTP basic authAny username, and the seinb_… token as the password
Bearer headerAuthorization: Bearer seinb_…

A token only works on its own provider's path. A Grafana token posted to the Datadog path is refused.

How incidents become tickets

Every provider runs the same lifecycle. Its parser only decides what counts as "the incident" and what counts as "the policy".

DeliveryWhat happens
Open, and the policy has no open ticketA new alert ticket, titled <policy> · <condition>
Open again, or another incident of the same policyFolded into the open ticket, with no duplicate. Its delivery count goes up
ClosedA comment with the recovery time. If auto-resolve is on and no other incident of the policy is still open, the ticket resolves
Open, after the policy's ticket was closedA new ticket. Each firing episode gets its own ticket, the same as native alerts
Neither open nor closed (INSUFFICIENT_DATA, a mute, an ack)Logged and ignored

Batched providers (an Alertmanager or Grafana group, a generic alerts[] array) run the lifecycle for each alert in the batch. Ten instances of one alert rule firing together make one ticket, which resolves once the last instance recovers.

Auto-resolve is on by default. Turn it off per provider if a person should close each ticket. The recovery comment is still posted.

Severity → priority

One table covers every provider, so a Datadog P1 and a Cloud Monitoring CRITICAL land with the same priority:

Upstream severityTicket priority
CRITICAL, P1, P0, Sev0, page, fatal, emergencycritical
ERROR, HIGH, P2, Sev1, major, no severityhigh
WARNING, P3–P5, Sev2–Sev4, info, lowmedium

A later incident of the same policy folds into the open ticket. If its severity differs, the ticket's priority moves to match, unless someone changed the priority by hand.

The ticket's Source links back to the incident in the provider's console. context.alert.external holds the upstream details for agents and the API: policy, condition, severity as sent, resource labels, incident ids, and which incidents are still open.

Google Cloud Monitoring

Create the channel

In the Google Cloud console, open Monitoring → Alerting → Edit notification channels → Webhooks → Add new. Paste the URL as the endpoint.

Or use basic auth

To keep the token out of the URL, set the endpoint to https://api.shipeasy.ai/inbound/alerts/gcp instead. Turn on Use HTTP Basic Auth and paste the token as the password.

Attach it to your alerting policies

Add the channel to each policy that should file tickets, then click Send test notification.

A webhook channel makes one delivery attempt. Routing through Pub/Sub gets you Pub/Sub's retries and dead-lettering instead.

Point Monitoring at a topic

Create a Pub/Sub notification channel for a topic. Grant the Monitoring service agent roles/pubsub.publisher on that topic.

Add a push subscription

On that topic, create a push subscription whose endpoint is the generated URL. Turn on Enable authentication, pick a service account, and set an audience. The endpoint URL without the token works well as the audience.

Require Google's signed token

Back in Shipeasy, enter the same audience under Pub/Sub OIDC audience (and, optionally, the service account's email) and save. From then on, every delivery must carry a Google-signed token for that audience. Plain webhook posts are refused.

Each incident's incident_id is the incident, and its alerting policy is the policy.

Prometheus Alertmanager

Add a webhook receiver and route alerts to it. Keep send_resolved: true (the default), because that is what closes tickets.

alertmanager.yml
receivers:
  - name: shipeasy
    webhook_configs:
      - url: https://api.shipeasy.ai/inbound/alerts/alertmanager/seinb_…
        send_resolved: true
        # Or keep the token out of the URL:
        # url: https://api.shipeasy.ai/inbound/alerts/alertmanager
        # http_config:
        #   authorization:
        #     credentials: seinb_…   # sent as "Authorization: Bearer seinb_…"

route:
  receiver: shipeasy
  # …or add it as a child route for the alerts that should become tickets:
  # routes:
  #   - matchers: [ 'severity=~"critical|warning"' ]
  #     receiver: shipeasy
  • Incident is each alert's fingerprint; policy is its alertname.
  • Severity comes from the severity label (or priority).
  • Summary comes from the summary annotation, falling back to description.
  • Link is the alert's generatorURL.
  • Resource labels are the alert's other labels (job, instance, …).
Repeat notifications

Alertmanager re-sends firing alerts every repeat_interval. Repeats fold into the open ticket and raise its delivery count, so you never get a duplicate.

Grafana

Create a webhook contact point

In Grafana, go to Alerting → Contact points → Add contact point. Pick the Webhook integration and paste the URL. Or use the token-free URL and set Authorization header → Bearer with the token.

Route alerts to it

Add the contact point to a notification policy (or pick it on individual alert rules), then click Test.

  • One ticket per alert rule. A rule is identified by its grafana_folder and alertname labels, and each fingerprint is an incident.
  • Link is the panel (panelURL), falling back to the dashboard.
  • Observed value is the first number in the alert's values.
  • Severity comes from a severity label on the rule.

Legacy dashboard alerting (Grafana 10 and older) works on the same URL:

  • alerting and no_data open a ticket;
  • ok closes it;
  • pending and paused are ignored.

AWS CloudWatch

Subscribe the URL to the alarm's topic

In SNS → Topics, open the topic your CloudWatch alarms notify and choose Create subscription. Set the protocol to HTTPS and the endpoint to the generated URL. Leave raw message delivery off.

Nothing to confirm by hand

SNS sends a SubscriptionConfirmation first. Shipeasy checks its signature and confirms it for you. The log shows accepted · subscribe, and the subscription turns Confirmed in the AWS console.

Pin the topic (recommended)

Enter the topic ARN under SNS topic ARN and save. From then on, the endpoint only accepts signed SNS messages from that topic.

Make sure the alarm notifies on recovery

On each alarm, add the topic to both the In alarm and OK actions, so a recovery closes the ticket.

Every SNS message is signature-checked. The certificate must come from an sns.<region>.amazonaws.com host, and SignatureVersion 1 and 2 are both supported. A tampered or forged message is rejected and logged.

Create an API destination

In EventBridge → API destinations, create a connection with API key authorization. Use the header Authorization with the value Bearer seinb_…. Then create a destination that POSTs to https://api.shipeasy.ai/inbound/alerts/aws.

Add a rule

Create a rule with the event pattern {"source": ["aws.cloudwatch"], "detail-type": ["CloudWatch Alarm State Change"]} and target the API destination. EventBridge retries failed deliveries.

Leave SNS topic ARN empty for EventBridge. Setting it requires signed SNS envelopes and refuses everything else.

  • The alarm is both the policy and the incident. It's identified by its ARN, so ALARM opens a ticket and OK resolves it.
  • INSUFFICIENT_DATA is ignored.
  • Resource labels are the metric's dimensions, plus the account and region.
  • Observed value is the datapoint from the state-change reason.
  • Link is the alarm in the CloudWatch console.
  • Priority is high, because CloudWatch alarms carry no severity.

Azure Monitor

Add a webhook action

Open your action group, then Actions → Webhook. Paste the URL and set Enable the common alert schema to Yes.

Attach the action group to your alert rules

Then Test action group to send a sample.

  • Incident is essentials.alertId; policy is the alert rule.
  • Fired opens a ticket and Resolved closes it.
  • Severity: Sev0 → critical, Sev1 → high, Sev2–Sev4 → medium.
  • Resource labels are the target resource and its resource group, parsed from alertTargetIDs.
  • Link is the alert in the Azure portal.

The older per-type metric alert schema (Activated / Resolved) is accepted too. For any other type, turn on the common schema.

Datadog

Add a webhook

In Integrations → Webhooks, add a webhook. Paste the URL and replace the payload with the template below. If you'd rather not put the token in the URL, use the token-free URL and add a custom header Authorization: Bearer seinb_….

Notify it from your monitors

Add @webhook-<name> to each monitor's message. Datadog then notifies the webhook on trigger, re-trigger, warn and recovery.

Datadog webhook payload
{
  "alert_id": "$ALERT_ID",
  "alert_cycle_key": "$ALERT_CYCLE_KEY",
  "alert_transition": "$ALERT_TRANSITION",
  "alert_title": "$ALERT_TITLE",
  "alert_priority": "$ALERT_PRIORITY",
  "body": "$EVENT_MSG",
  "link": "$LINK",
  "date": "$DATE",
  "hostname": "$HOSTNAME",
  "tags": "$TAGS",
  "scope": "$ALERT_SCOPE",
  "metric": "$ALERT_METRIC",
  "value": "$ALERT_VALUE"
}
  • Policy is the monitor (alert_id), and incident is one trigger → recover cycle (alert_cycle_key). A multi-alert monitor's groups all fold into that monitor's ticket.
  • These transitions open (or keep open) the ticket: Triggered, Re-Triggered, Warn, No Data, Renotify.
  • These close it: Recovered, Warn Recovered, No Data Recovered.
  • Priority follows $ALERT_PRIORITY (P1 → critical, P2 → high, P3–P5 → medium).
  • Resource labels are your monitor's $TAGS.

Only alert_id and alert_transition are required. Datadog's default payload also works: the transition is read from the [Triggered] / [Recovered] title prefix.

Generic JSON

For anything else, POST this shape to https://api.shipeasy.ai/inbound/alerts/generic/seinb_…:

One incident
{
  "id": "db-primary-down",
  "status": "open",
  "title": "Primary DB unreachable",
  "group": "db-primary",
  "severity": "critical",
  "summary": "3 consecutive health checks failed from eu-west-1",
  "url": "https://status.example.com/checks/db-primary",
  "condition": "health check",
  "startedAt": "2026-11-12T10:00:00Z",
  "resource": "postgres",
  "labels": { "region": "eu-west-1", "cluster": "prod" },
  "value": 0
}
FieldRequiredMeaning
idyesThe incident. Send the same id when it opens and when it closes
statusyesopen or closed. Also accepted: firing, triggered, alerting, problem, down, created, failed (open); resolved, ok, recovered, up (closed); acknowledged, pending, muted (ignored)
titleyesThe check or policy name. It is the ticket title
groupnoIncidents with the same group fold into one ticket. Defaults to title
severitynocritical, high, error, medium, warning, low, info, P1–P5, Sev0–Sev4
summarynoThe ticket's detail line
urlnoAn https:// link to the incident. It becomes the ticket's Source link
conditionnoShown after the title: <title> · <condition>
startedAt / endedAtnoISO-8601, or unix seconds or milliseconds
resource, labelsnoWhat it fired on. labels is a flat string map
valuenoThe observed value

Common aliases are read too, for tools whose template can't rename a field:

  • incident_id for id
  • state for status
  • name for title
  • message or description for summary
  • link for url
  • started_at for startedAt

To send several incidents at once, use { "alerts": [ … ] } or a top-level array.

From a script or cron job
curl -fsS -X POST "https://api.shipeasy.ai/inbound/alerts/generic" \
  -H "Authorization: Bearer $SHIPEASY_INBOUND_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"id":"nightly-backup","status":"open","title":"Nightly backup failed","severity":"high"}'

Recipes for other tools

Create a Webhook destination with the generated URL, and use this payload template in your workflow:

{ "id":
{{json issueId}}, "status":
{{json state}}, "title":
{{json accumulations.conditionName.[0]}}, "group":
{{json accumulations.policyName.[0]}}, "severity":
{{json priority}}, "summary":
{{json annotations.title.[0]}}, "url":
{{json issuePageUrl}}
}

CREATED and ACTIVATED open a ticket, CLOSED closes it, and ACKNOWLEDGED is ignored.

Add a Webhook notification with the generated URL. Set Request Body to Custom Body:

{
  "id": "kuma-{{ monitorJSON['id'] }}",
  "status": "{% if heartbeatJSON['status'] == 1 %}closed{% else %}open{% endif %}",
  "title": "{{ monitorJSON['name'] }}",
  "summary": "{{ msg }}",
  "severity": "high"
}

Add a Webhook alert channel with the generated URL and this body:

{ "id": "{{CHECK_ID}}", "status": "{{ALERT_TYPE}}", "title": "{{CHECK_NAME}}", "summary": "{{ALERT_TITLE}}",
"url": "{{RESULT_LINK}}" }

ALERT_FAILURE and ALERT_DEGRADED open a ticket, and ALERT_RECOVERY closes it.

Any alert script that can run curl can post the generic shape:

  • Open: post status: "open" with {EVENT.ID} (Zabbix) or $HOSTNAME$-$SERVICEDESC$ (Nagios) as the id.
  • Close: send the same id with status: "closed" when the problem recovers.

The delivery log

The card lists the latest deliveries across every provider. Each one shows its outcome:

  • accepted — it filed a ticket, closed one, or confirmed an SNS subscription;
  • deduped — it folded into an open ticket, or was ignored;
  • rejected — it failed, with the reason (a malformed payload, a missing field, a failed Pub/Sub token or SNS signature check).

A misconfigured channel shows up here instead of silently dropping alerts.

ResponseMeaning
200Accepted, deduped or ignored
400The body couldn't be read as that provider's payload. The reason is in the response and the log
401Unknown or revoked token, a token for another provider, or a failed Pub/Sub / SNS check
404Unknown provider in the path
413Body over 256 KB
500The ticket couldn't be written. The sender retries, and a retry only folds into the open ticket

A request with an unknown or revoked token has no project to log against, so it is refused with 401 and doesn't appear in the log.

What leaves your monitoring

Incident payloads carry metric, policy and resource metadata only, with no request bodies or user data. Only the fields above are stored on the ticket.

Was this page helpful?
Updated November 13, 2026✎ Edit this page

On this page