New: temperature, fans, power supplies and SSD health per server. View hardware health

Try it free

PeakNode’s interfaces let you connect your ticket system, build your own reports and create monitors automatically, for example from a deployment script. For this there is a REST API, an export in Prometheus format and webhooks that send events to your system.

Illustration: the agent only sends outbound, over port 443. Can be rotated with the mouse.

What is API and webhooks?

The PeakNode API is a REST interface at /api that uses an API key with bearer authentication. It lets you retrieve and manage uptime monitors, heartbeats, server monitors, DNS monitors, domains, status pages, channels, maintenance windows and incidents. A separate endpoint provides the current values in Prometheus format. Webhooks work the other way round: when an event occurs, PeakNode sends a POST request to your URL.

Four ways to your data

Manage via the REST API, metrics via Prometheus, events via webhooks, lists via export.

Authentication with an API key

Every account has an API key, found in the account under “API”, where it can also be regenerated. It is sent as Authorization: Bearer in the header. The key applies to the whole account; there are no scoped or read-only keys. Treat it like a password.

Create and manage monitors automatically

Uptime monitors, heartbeats, server monitors, DNS monitors, domains, status pages, notification channels, projects and maintenance windows can be listed, retrieved individually, created, changed and deleted. A deployment script can thus create the monitor for a new server at the same time. Every change made via the API appears in the change log.

Read and acknowledge incidents

Incidents can be filtered, retrieved, commented on and acknowledged via POST /api/incidents/{incident_id}/acknowledge. This corresponds to “I’m on it” in the portal and stops reminders and escalation, so a ticket system can report back that someone has taken over. Incidents exist for uptime monitors and heartbeats: a server monitor that is offline has no incident and can only be acknowledged in the portal or from the alert email.

Metrics for Prometheus

GET /api/metrics returns the account’s current values in the Prometheus text format: uptime monitors, heartbeats, server monitors with GPUs, remaining validity of domains and certificates, open incidents. All metrics carry the prefix peaknode_. Unknown values are omitted and never reported as 0.

Webhooks for events

The webhook notification channel sends a POST request to your URL for every notification routed to it, form-encoded, with the user agent PeakNode/1.0: for alerts and all-clears as well as for reminders, escalations, thresholds or DNS changes. If your server cannot be reached or responds with 408, 425, 429 or an error from 500 upwards, PeakNode retries delivery over around 4 hours and adds the field original_datetime. If the connection is established and only the response fails to arrive, there is no retry, so that your system does not trigger anything twice. The request carries no signature.

Export and import

Lists and history can be downloaded as CSV or JSON, for example a monitor’s checks over a chosen period. PDF is produced via the browser’s print view; a ready-made PDF is available for the SLA report. Monitors, heartbeats, server monitors, DNS monitors and domains can be imported via CSV. Which export types an account can use depends on the plan.

Fields of a webhook for an outage

Uptime monitor offline

FieldExample valueMeaning
nameapi-prodName of the uptime monitor
targethttps://api.example.com/healthChecked target
is_ok00 = outage, 1 = all-clear
errorConnection refusedReason in plain text, in the account’s language
start_datetime2026-11-11 02:14:00Start of the incident
incident_urlhttps://peaknode.de/incident/123Address of the incident in the portal
datetime_timezoneUTCTime zone of all date fields

Example: fields of an uptime monitor’s webhook, sent as a form-encoded POST request. In addition there are monitor_id and monitor_url, and for the all-clear end_datetime and length.

Resources and methods

The endpoints follow one pattern: GET lists or reads, POST creates or changes, DELETE deletes. Changes are made with a POST to the address of the individual entry.

ResourceEndpointMethods
Uptime monitors/api/monitorsGET, POST, DELETE
Heartbeats/api/heartbeatsGET, POST, DELETE
Server monitors/api/server-monitorsGET, POST, DELETE. The response contains the latest report per server and per GPU
DNS monitors/api/dns-monitorsGET, POST, DELETE
Domains and SSL/api/domain-namesGET, POST, DELETE
Incidents/api/incidentsGET, POST for the comment, POST to /acknowledge to acknowledge, DELETE
Maintenance windows/api/maintenance-windowsGET, POST, DELETE
Status pages/api/status-pagesGET, POST, DELETE
Notification channels/api/notification-handlersGET, POST, DELETE
Projects/api/projectsGET, POST, DELETE
Change log/api/change-logGET
Prometheus export/api/metricsGET, response as text in Prometheus format

Base URL: https://peaknode.de/api. Lists accept page and results_per_page (fixed steps from 10 to 1,000, default 25 according to the documentation). Errors are returned as JSON with a status code, 429 when the limit is exceeded. The Prometheus export is cached per account for 15 seconds and accepts 30 requests per minute. All parameters and example responses are in the API documentation.

Which fields a webhook sends per event

The webhook transmits the event data as individual form fields. A field without a value is omitted, for example error if there is no reason. For server monitor notifications, by contrast, unused fields arrive empty.

EventFields
Uptime monitor offline or back onlinemonitor_id, name, target, is_ok, monitor_url, incident_url, start_datetime, for an outage error, for the all-clear end_datetime and length
Heartbeat missed or backheartbeat_id, name, is_ok, heartbeat_url, incident_url, start_datetime, for the all-clear end_datetime and length
Server monitor: threshold, offline, online, hardware eventserver_monitor_id, name, target, alert_metric, alert_metric_value, alert_rule, alert_trigger, alert_trigger_value, url. For offline and online the state is in alert_metric_value, and the rule and trigger fields are then empty
Reminder or escalation for an ongoing outagemonitor_id, heartbeat_id or server_monitor_id, name, target (not for heartbeats), event with reminder or escalation, start_datetime, url, for incidents incident_id, plus reminder and reminders_max or escalation_minutes
DNS changedns_monitor_id, name, target, url. The individual changes are not in the webhook but on the linked page
Expiry of a domain or certificatedomain_name_id, name, target, expires_in_days, url, plus the fields with whois_ or ssl_ such as whois_end_datetime or ssl_end_datetime

Every request is a POST with Content-Type: application/x-www-form-urlencoded and the additional field datetime_timezone with the value UTC. The URL must be publicly reachable and use http or https. PeakNode waits at most 5 seconds for the response.

Connected in three steps

This requires a plan with API access. Webhooks are a notification channel and do not need an API key.

  1. Get the API key

    In the portal, copy the key from the account under “API”. Regenerating it there invalidates the old one.

  2. Send the first request

    Retrieve the list of uptime monitors. {api_key} stands for your key.

    curl --request GET \
      --url 'https://peaknode.de/api/monitors/' \
      --header 'Authorization: Bearer {api_key}'
  3. Connect Prometheus or a webhook

    For metrics, add the entry under scrape_configs to your prometheus.yml. For events, create a notification channel of type webhook with your system’s URL and select it on the monitor.

    scrape_configs:
      - job_name: peaknode
        scrape_interval: 60s
        scheme: https
        metrics_path: /api/metrics
        authorization:
          type: Bearer
          credentials: {api_key}
        static_configs:
          - targets: ['peaknode.de']

Frequently asked
questions about API and webhooks

Continue to:

Does PeakNode have an API, and what do I need it for?

Yes. The PeakNode REST API lets you retrieve and manage uptime monitors, heartbeats, server monitors, DNS monitors, domains, status pages, notification channels, projects, maintenance windows and incidents, for example for your own reports or to create monitors automatically. It requires a plan with API access. The reference with all parameters is in the API documentation.

How do alerts get into our ticket system?

Via the webhook notification channel: when an event occurs, PeakNode sends a POST request to your URL with the event’s fields as form data. For an uptime monitor these include name, target, state, reason, start and the address of the incident, and for the all-clear also end and duration. All times are UTC. PeakNode does not include a signature for verifying the origin.

How does a ticket system acknowledge an incident?

With a POST to /api/incidents/{incident_id}/acknowledge. The incident then shows the owner of the API key as the person and “via the API” as the way. If the incident has already been acknowledged or has ended, the API responds with 409.

How do I authenticate with the API?

With your account’s API key, sent as the header Authorization: Bearer. You find the key in the account under “API”. It applies to the whole account; a two-factor requirement does not affect it.

Is there a rate limit?

Yes, 60 requests in 60 seconds per API key. Every response states the limit and the remainder in the headers X-RateLimit-Limit and X-RateLimit-Remaining. Beyond that, the API responds with status code 429. The Prometheus export also has its own limit of 30 requests per minute and account.

Can I pull the metrics into Prometheus?

Yes. The endpoint /api/metrics returns your account’s current values in the Prometheus text format, authenticated with the API key. It includes utilization, memory, temperature and power per GPU, CPU and RAM per server, the state of monitors and heartbeats and the remaining validity of certificates, among other things. A scrape interval of 60 seconds matches the rhythm of the checks.

Can I retrieve metrics from the last few weeks via the API?

No. For each server monitor the API returns the state of the latest report, not a time series. For history there are two options: scrape the Prometheus export regularly and store it yourself, or export the data for a period from the portal as CSV or JSON.

Can I show PeakNode metrics in Grafana?

Yes, through Prometheus: a Prometheus server pulls /api/metrics with the API key and stores the values, and Grafana displays them with Prometheus as the data source. PeakNode does not ship a ready-made Grafana dashboard. Without Grafana, the metrics are in the portal, for example in GPU server monitoring.

Connect PeakNode to your own tools

Create an account, copy the API key, send the first request. This requires a plan with API access.