Overview

Push real-time alerts directly into your own tools and workflows the moment a monitor changes state: no polling, no middleware, no delays. Webhook integrations let UptimeRobot send HTTP requests to any URL you specify whenever a monitor goes down, comes back up, or an SSL/domain certificate is about to expire.

Key capabilities:

Instant delivery — Receive alerts as HTTP requests the moment an incident starts or resolves
Custom headers — Authenticate with receiving systems by adding your own HTTP headers (e.g., Authorization, X-Api-Key)
Rich payloads — Get all the context you need in a single notification: dashboard URL, incident timestamps, monitoring regions, monitor type, HTTP status code, tags, and group
Flexible delivery formats — Send data as JSON, POST parameters, query string values, or a fully custom POST body
Custom POST body — Define your own payload structure using built-in notification variables
API management — Create, update, and manage webhooks programmatically through the public API v3

Webhook integrations are available on Team and Scale plans.

Example Use Cases

Use Case	How Webhooks Help
Route alerts to your incident management tool	Push structured alert data directly into your on-call workflow, your team gets notified instantly with full context
Trigger automated remediation scripts	Fire a webhook to your automation platform to restart services or scale infrastructure the moment downtime is detected
Feed monitoring data into your observability platform	Stream incident events into your centralized dashboard so downtime data lives alongside metrics and logs
Post alerts to an internal chat channel	Deliver formatted alert messages to your team's communication tool via an incoming webhook URL
Sync incidents with your ticketing system	Automatically create and resolve tickets when monitors go down and come back up, no manual triage needed
Build a custom status dashboard	Consume webhook events to power a real-time status board tailored to your organization's needs
Log incidents to an audit trail	Forward every alert to a logging service so you have a complete, searchable record of all monitoring events
Filter and route alerts by tag or group	Use the `monitorTags` and `monitorGroup` fields in the payload to route alerts to different teams or channels based on ownership

How It Works

Setting up a webhook

Go to Integrations in the left sidebar and click Add Integration
Select Webhook from the list
Fill in the Webhook URL — the endpoint where UptimeRobot will send notifications
Configure how default notification variables are delivered (see Delivery Formats)
Optionally add a custom POST value to define your own payload structure
Optionally add custom headers for authentication or routing (see Custom Headers)
Under Events to notify about, choose which events trigger a notification:
- Down events: When a monitor goes down
- Up events: When a monitor recovers
- SSL & Domain expiry: When an SSL certificate or domain is about to expire
Click Save to create the webhook

After saving, the webhook will fire automatically whenever a connected monitor triggers a matching event.

Editing a webhook

When editing an existing webhook, you can also set a Friendly name to help identify the integration in your list.

Custom Headers

Add custom HTTP headers to authenticate with receiving services or pass routing metadata, without needing to build a proxy in between.

Add up to 10 custom headers per webhook
Each header is a key-value pair (e.g., Authorization: Bearer your-token)
Headers are included in every outgoing webhook request
Header names must follow standard HTTP header naming rules
Duplicate header names (case-insensitive) are not allowed
Custom headers are capped at 10 headers and a combined 4 KB (4096 bytes) across all header names and values
If you go over either limit, all custom headers are dropped from the request — not just the extra ones — including any header you use for authentication, such as Authorization or X-Api-Key. The webhook still fires, just without any of the configured headers. After saving, check that your headers are actually arriving at your endpoint.

This is especially useful when your receiving endpoint requires authentication headers, API keys, or custom routing identifiers.

Notification Variables

Every webhook notification includes a set of built-in variables that provide context about the event. You can use these variables in the webhook query string, POST parameters, or a custom POST body by wrapping them in asterisks (e.g., *monitorURL*).

List of variables

Variable	Description
`monitorID`	The ID of the monitor
`monitorURL`	The URL of the monitor
`monitorFriendlyName`	The friendly name of the monitor
`alertType`	1: down, 2: up, 3: SSL & Domain expiry
`alertTypeFriendlyName`	"Down" or "Up"
`alertDetails`	Additional info about the alert (if available)
`alertDuration`	Duration in seconds (only for up events)
`alertDateTime`	Timestamp of the alert (Unix timestamp)
`monitorAlertContacts`	The alert contacts associated with the alert
`sslExpiryDate`	SSL certificate expiry date (only for SSL expiry notifications)
`sslExpiryDaysLeft`	Days until SSL expiry (only for SSL expiry notifications)
`domainExpireDate`	Domain expiry date (only for SSL & Domain expiry notifications). Note the different spelling from the SSL variables above — there is no `domainExpiryDate` variable.
`dashboardUrl`	Direct link to the monitor in the UptimeRobot dashboard
`customFields`	Custom fields (key-value metadata) assigned to the monitor. Note: If you use this variable, use it as `customFields`, instead of `"customFields"`. See example below.
`incidentStartTime`	When the incident began
`incidentEndTime`	When the incident was resolved (only for up events)
`monitoringRegions`	The monitoring regions that detected the event
`monitorType`	The type of monitor (HTTP, Keyword, Ping, Port, etc.)
`httpStatusCode`	The HTTP status code returned (for HTTP-based monitors)
`monitorTags`	Tags assigned to the monitor
`monitorGroup`	The group the monitor belongs to
`responseTime`	Response time in milliseconds (only for response-time-related alerts)

Delivery Formats

You can control how notification data is delivered in each webhook request. These options are found under Send default variables in the webhook form.

Format	Description
As query string of webhook URL	Appends default variables as query parameters to the webhook URL
As POST parameters	Sends default variables as form-encoded POST parameters
POST value (custom body)	Define a fully custom request body using notification variables
Send as JSON (application/json)	When using a custom POST value, sends the body with `Content-Type: application/json` instead of form encoding

You can enable multiple delivery methods at once. For example, you can send default variables as query string parameters while also including a custom JSON POST body.

Custom POST body example

In the POST value field, you can define a custom JSON structure using notification variables:

{
"monitor": "*monitorFriendlyName*",
"status": "*alertTypeFriendlyName*",
"url": "*monitorURL*",
"details": "*alertDetails*",
"custom_metadata": *customFields*
}

Enable Send as JSON (application/json) to ensure the receiving endpoint gets a properly formatted JSON payload.

Delivery reliability

Webhook delivery for Down and Up events is a single attempt. If the request fails — a timeout, a non-2xx response, or a connection error — it is not retried, and no notification is sent to you that delivery failed.

If your receiving endpoint was unreachable when an alert fired, that webhook is gone; UptimeRobot will not send it again. Because of this, build your receiving endpoint to be highly available and to handle repeated or out-of-order requests idempotently, and don’t treat a webhook as the only trigger for automated remediation or ticketing without another way to confirm delivery.

API Access

Webhook integrations are fully supported in the public API v3. You can create, list, update, and delete webhooks programmatically.

Create a webhook integration

curl -X POST https://api.uptimerobot.com/v3/integrations \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "type": "Webhook",
    "data": {
      "friendlyName": "Production Alerts",
      "urlToNotify": "https://your-server.com/webhook",
      "sendAsJSON": true,
      "postValue": "{\"monitor\": \"*monitorFriendlyName*\", \"status\": \"*alertTypeFriendlyName*\"}",
      "sendAsQueryString": false,
      "sendAsPostParameters": false,
      "enableNotificationsFor": "UpAndDown",
      "sslExpirationReminder": true,
      "customHeaders": {
        "Authorization": "Bearer your-service-token",
        "X-Source": "uptimerobot"
      }
    }
  }'

Update a webhook integration

curl -X PATCH https://api.uptimerobot.com/v3/integrations/12345 \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "type": "Webhook",
    "data": {
      "customHeaders": {
        "Authorization": "Bearer updated-token",
        "X-Environment": "production"
      }
    }
  }'

List integrations

curl https://api.uptimerobot.com/v3/integrations \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"

The response includes all integration details, including configured custom headers.

Webhook Integration