# Uptimeify Dokumentation, Vollständiger Export
> Erweiterter, textbasierter Export der Uptimeify-Dokumentation mit Seiteninhalten.
Compact index: https://docs.uptimeify.io/de/llms.txt
## MCP-Server
Uptimeify betreibt einen zustandslosen Model-Context-Protocol-Server. 20 Check-Tools sind ohne Account und ohne Token nutzbar; 23 weitere lesen mit einem API-Token die eigenen Monitore, Alarmierung, Statusseiten, das Incident Management (Vorfaelle, Rufbereitschaft, Teams, Dienstplaene) und Kontodaten.
- Endpoint: `POST https://uptimeify.io/mcp` (Streamable HTTP, zustandslos)
- Server Card: https://uptimeify.io/.well-known/mcp/server-card.json
- Registry-Manifest: https://uptimeify.io/.well-known/mcp/server.json
- Uebersicht: https://uptimeify.io/de/mcp-server
- Technische Referenz: https://docs.uptimeify.io/de/api/mcp
- Limits: 120 Anfragen/Minute pro IP auf dem Endpoint, zusaetzlich 15-30/Minute je anonymem Tool und 60/Minute je authentifiziertem Tool. Ueberschreiten liefert HTTP 429.
- Anonyme Tools: check_ssl, check_dns, dns_propagation, mx_lookup, spf_check, dkim_check, dmarc_check, dnsbl_check, whois, domain_expiry, http_headers, hsts_check, redirect_check, port_check, ping_test, website_status, response_time, ip_geolocation, asn_lookup, reverse_dns
- Tools mit API-Token (nur lesend): list_monitors, monitor_status, list_incidents, check_history, uptime_summary, list_alert_channels, alert_history, list_status_pages, list_status_page_components, list_status_page_maintenances, get_status_page_maintenance, list_maintenance_windows, list_im_incidents, get_im_incident, who_is_on_call, list_im_teams, get_im_team, list_im_schedules, get_im_schedule, get_organization, list_users, list_customers, billing_summary
- 65 Schreib-Tools ueber eine OAuth-Verbindung mit passendem Schreib-Scope, je nach Bereitstellung ein- oder ausgeschaltet, niemals ueber ein API-Token: pause_monitor, resume_monitor, rename_monitor, set_check_interval, create_website_monitor, delete_monitor, acknowledge_incident, resolve_incident, post_incident_update, delete_incident, create_incident, update_incident, publish_postmortem, backfill_incident, create_maintenance_window, update_maintenance_window, delete_maintenance_window, create_status_page, update_status_page, update_status_page_design, delete_status_page, add_status_page_domain, verify_status_page_domain, activate_status_page_domain, delete_status_page_domain, create_status_page_component, update_status_page_component, delete_status_page_component, create_status_page_component_group, update_status_page_component_group, delete_status_page_component_group, create_status_page_maintenance, update_status_page_maintenance, complete_status_page_maintenance, cancel_status_page_maintenance, post_status_page_maintenance_update, create_notification_channel, update_notification_channel, delete_notification_channel, create_tag, update_tag, delete_tag, add_monitor_tag, remove_monitor_tag, create_custom_field, update_custom_field, delete_custom_field, create_report, update_report, delete_report, update_user, create_customer, update_customer, delete_customer, add_customer_domain, delete_customer_domain, add_customer_ip, delete_customer_ip, acknowledge_im_incident, resolve_im_incident, set_im_incident_status, comment_on_im_incident, assign_im_incident, set_im_incident_severity, snooze_im_incident
## Kostenlose Statusseiten
Statusseiten von Uptimeify sind dauerhaft kostenlos. Sie brauchen keinen bezahlten Plan, keine Testphase und kein Monitoring, und sie bleiben kostenlos online, wenn ein Monitoring-Plan endet. Sie sind in der EU gehostet.
- White-Label: eigene Domain mit automatischem HTTPS, neun Layouts, eigenes Logo und eigene Farben, kein Uptimeify-Branding, die optionale Zeile „Powered by“ zeigt deinen eigenen Produktnamen
- Vorfälle und Wartungen: Updates in Phasen, Vorlagen, geplante Wartungen, öffentliche Postmortems
- Abonnenten: E-Mail, Slack, Microsoft Teams, Webhook, RSS und Atom
- Private Seiten: Login, SSO, Passwort, IP-Allowlist und Zielgruppen
- Einbindung: Status-Badge und Iframe-Widget
- Komponenten: aus eigenen Monitoren, von Drittanbietern, von Hand oder per API
- Übersicht: https://uptimeify.io/de/status-seiten
- Preise: https://uptimeify.io/de/preise
- Dokumentation: https://docs.uptimeify.io/de/status-pages
## Overview
### Willkommen bei Uptimeify
URL: https://docs.uptimeify.io/de
Description: White-Label Uptime-, SSL- & synthetisches Monitoring für Agenturen, gehostet in der EU.
Summary: Uptimeify ist eine **White-Label-Monitoring-Plattform für Agenturen und MSPs**. Überwache die Websites und Infrastruktur deiner Kunden, alarmiere die richtigen Leute in dem Moment, in dem etwas ausfällt, und gib jedem Kunden eine gebrandete Statusseite plus automatischen Bericht, alles unter deiner eigenen Marke, gehostet in der EU. ## Was du überwachen kannst Aus einem einzigen Dashboard: - **Websites**: Uptime, SSL-Zertifikat, Antwortzeit, Keyword-Präsenz, Seitengröße und HTTPS-Weiterleitungs-Checks. - **Server & Dienste**: DNS, ICMP (Ping), SSH, FTP, SMTP, IMAP/POP, TCP-Port, DNSBL-Blacklist- und Domain-Ablauf-Checks. - **Synthetisch & geplant**: mehrstufige Browser-Flows mit Playwright und Heartbeat (Cron)-Checks für Hintergrund-Jobs. Unter [Monitoring](/de/monitoring) findest du jeden Check-Typ und wie du Intervalle, Schwellenwerte und Standorte feinjustierst. ## Alarme, die nicht ständig falsch anschlagen Ein Fehlschlag wird von **einem weiteren EU-Standort** bestätigt, bevor ein Vorfall geöffnet wird. Du wirst also bei echten Ausfällen alarmiert, nicht bei Netzwerk-Schluckaufs. Wie viele Standorte bestätigen müssen, stellst du je Paket ein (1 = sofort alarmieren). Leite Alarme an **29 Benachrichtigungskanäle** (Slack, Microsoft Teams, PagerDuty, Opsgenie, SMS, E-Mail, Webhooks und mehr) mit mehrstufiger, zeitbasierter Eskalation weiter, sodass ein nicht bestätigter Alarm automatisch an den nächsten Verantwortlichen geht. Wie die Erkennung funktioniert, erfährst du unter [Vorfälle](/de/incidents); Kanäle richtest du unter [Integrationen](/de/integrations) ein. ## Kundenseitig, unter deiner Marke - **Statusseiten**: gebrandet, öffentlich oder passwortgeschützt, auf deiner eigenen Domain. Siehe [Statusseiten](/de/status-pages). - **Automatische PDF-Berichte**: mit deinem Logo, um wiederkehrende Gebühren zu rechtfertigen. - **Wartungsfenster**: unterdrücken Alarme bei geplanten Arbeiten. Siehe [Wartung](/de/maintenance). ## Gebaut für Agenturen Unbegrenzte Unter-Accounts pro Kunde, Margen-Kontrolle bei Care-Plänen und eine vollständige **REST-API**, um Kunden, Monitore, Statusseiten und Benachrichtigungskanäle zu automatisieren. Starte mit der [API-Dokumentation](/de/api) oder verwalte alles als Code mit [Terraform & OpenTofu](/de/terraform). ## Wähle ein Thema Website-, Uptime-, SSL- und synthetische Monitore einrichten und ihre Checks feinjustieren. Gebrandete, öffentliche oder passwortgeschützte Statusseiten für deine Kunden veröffentlichen. Verstehen, wie Incidents erkannt, bestätigt und gelöst werden. Wartungsfenster planen, um Alerts bei geplanten Arbeiten zu unterdrücken. Slack, Webhooks und weitere Benachrichtigungskanäle anbinden. Alles per REST-API automatisieren: Kunden, Monitore, Statusseiten. Monitore, Statusseiten und Incident Management als Code verwalten.
## API Reference
### API Dokumentation
URL: https://docs.uptimeify.io/de/api
Description: Übersicht über die REST API. Wähle links eine Ressource aus.
Summary: ## KI / LLM Text-Exporte - [LLMS-Index für KI-Agenten](https://uptimeify.io/llms) - [LLMS-Vollreferenz für KI-Ingestion](https://uptimeify.io/llms-full) - [Deutscher LLMS-Index für KI-Agenten](https://uptimeify.io/de/llms) - [Deutsche LLMS-Vollreferenz für KI-Ingestion](https://uptimeify.io/de/llms-full) ## Base URL Alle Beispiele nutzen eine Platzhalter-Base-URL: ```bash BASE_URL="https://uptimeify.io" ``` ## Authentifizierung Die meisten Endpunkte benötigen Authentifizierung. ```bash TOKEN="wsm_" curl -H "Authorization: Bearer $TOKEN" "$BASE_URL/api/websites" ``` API-Tokens aus dem Dashboard starten immer mit `wsm_`. Bitte den kompletten Token (inkl. Prefix) verwenden, sonst kommt `401 Unauthorized`. ## UUID-Pfadparameter Bei migrierten Ressourcen verwenden die Docs und Beispiele die `publicId`-UUID im Pfad. - Nutze UUIDs in Pfaden wie `/api/websites/:websitePublicId`, `/api/customers/:customerPublicId`, `/api/organizations/:organizationPublicId`, `/api/incidents/:incidentPublicId`, `/api/customer-ips/:customerIpPublicId`, `/api/customer-domains/:customerDomainPublicId` und monitor-spezifischen `:...PublicId`-Parametern. - Interne numerische `id`-Felder können in Responses weiterhin vorkommen. - Query-/Body-Felder wie `customerId`, `websiteId` oder `organizationId` bleiben numerisch, sofern die jeweilige Endpoint-Seite nichts anderes sagt. ## Antworten und Fehler - `2xx` bedeutet Erfolg - `4xx` bedeutet Request/Auth-Problem - `5xx` bedeutet Serverfehler - [Fehlerliste und bekannte API-Fallen](/de/api/error-codes-and-known-pitfalls) Beispiel-Fehlerantwort: ```json { "statusCode": 401, "statusMessage": "Unauthorized" } ```
### Globale Administration
URL: https://docs.uptimeify.io/de/api/admin
Description: Dieser Abschnitt deckt die Endpunkte der globalen Administration ab, die geschützt sind und nur für Plattform-Administratoren zugänglich sind.
Summary: *(Endpunkte werden noch dokumentiert)* ## Endpunkte
### Agent-Authentifizierung (agentische Registrierung)
URL: https://docs.uptimeify.io/de/api/agent-auth
Description: Registriere einen KI-Agenten und erhalte ein kurzlebiges, nur lesendes Zugriffstoken für die Uptimeify-API.
Summary: Uptimeify betreibt unter `https://uptimeify.io` einen agentischen Registrierungs- Autorisierungsserver im WorkOS-Stil. Agenten registrieren sich, tauschen eine dienstsignierte Identitäts-Assertion gegen ein kurzlebiges, opakes Zugriffstoken und rufen die **nur lesende** API auf. Alle Endpunkte unten werden ausschließlich auf dem kanonischen Host `uptimeify.io` bereitgestellt (auf Custom-Domains liefern sie `404`). ## Entdecken ```bash curl https://uptimeify.io/.well-known/oauth-authorization-server curl https://uptimeify.io/.well-known/oauth-protected-resource ``` Die Metadaten des Autorisierungsservers folgen [RFC 8414](https://www.rfc-editor.org/rfc/rfc8414) (`token_endpoint`, `revocation_endpoint`, `jwks_uri`, `grant_types_supported`, `scopes_supported`) und ergänzen einen `agent_auth`-Erweiterungsblock mit `identity_endpoint`, `claim_endpoint`, `identity_types_supported` (`["anonymous", "service_auth"]`, dazu `"identity_assertion"`, sobald Uptimeify einem Identity-Provider vertraut) und einem `skill`-Verweis auf `/auth.md`. Nur im letzten Fall trägt der Block zusätzlich `identity_assertion`, `events_supported` und `events_endpoint`; siehe [Identity Assertion (ID-JAG)](/de/api/agent-auth/identity-assertion). Die Protected-Resource-Metadaten folgen [RFC 9728](https://www.rfc-editor.org/rfc/rfc9728). ## Registrieren (anonym) ```bash curl -X POST https://uptimeify.io/agent/identity \ -H 'Content-Type: application/json' \ -d '{"type":"anonymous"}' ``` ```json { "registration_id": "reg_…", "identity_assertion": "", "pre_claim_scopes": ["tools.public"], "post_claim_scopes": ["api.read"], "token_endpoint": "https://uptimeify.io/oauth2/token" } ``` Die `identity_assertion` ist ein EdDSA-JWT mit rund 24 Stunden Gültigkeit: dein langlebiges Berechtigungsmerkmal. Rate-Limit: 30 Anfragen/Minute pro Aufrufer. `post_claim_scopes` beschreibt den Scope, den eine geclaimte Registrierung erreicht (`api.read`). Eine anonyme Registrierung ist sofort aktiv mit `tools.public` und **direkt nutzbar**: das Claimen ist optional. Die Antwort enthält außerdem ein einmal verwendbares `claim_token` (`clm_…`) und eine `claim_url`: Willst du diese Registrierung auf `api.read` hochstufen, findest du im [Claim-Flow](/de/api/agent-auth/claim-flow), wie du es einlöst. ## Registrieren (service_auth) Die `service_auth`-Registrierung ist ausschließlich claimbar: Sie startet als `pending` und erzeugt kein Token, bis ein angemeldeter Nutzer sie autorisiert hat. Im [Claim-Flow](/de/api/agent-auth/claim-flow) findest du den vollständigen Request `POST /agent/identity {"type":"service_auth", "login_hint":"…"}`, den menschlichen Zustimmungsschritt und wie du `/oauth2/token` auf das resultierende `api.read`-Zugriffstoken pollst. ## Registrieren (identity_assertion) Ein Agent, der bei einem vertrauenswürdigen Identity-Provider angemeldet ist, registriert sich mit einem ID-JAG. Gehört seine bestätigte E-Mail zu einem Uptimeify-Konto, gibt die Kontoinhaberin oder der Kontoinhaber ihn auf `/claim` frei und wählt, welche Schreibbereiche er nutzen darf (vorausgewählt ist keiner); das Token geht nie über die aktuelle Rolle dieser Person hinaus. Siehe [Identity Assertion (ID-JAG)](/de/api/agent-auth/identity-assertion). ## Gegen ein Zugriffstoken tauschen ```bash curl -X POST https://uptimeify.io/oauth2/token \ -H 'Content-Type: application/x-www-form-urlencoded' \ --data-urlencode 'grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer' \ --data-urlencode 'assertion=' ``` ```json { "access_token": "wsma_…", "token_type": "Bearer", "expires_in": 3600, "scope": "tools.public" } ``` Das Zugriffstoken ist opak, läuft nach 1 Stunde (3600s) ab und muss danach erneut aus der Identitäts-Assertion erzeugt werden. Rate-Limit: 60 Anfragen/Minute pro Aufrufer. ## Verwenden (nur lesend) ```bash curl https://uptimeify.io/api/tools/dns-lookup?domain=deinkunde.com \ -H 'Authorization: Bearer wsma_…' ``` Agent-Tokens sind nur lesend, mit einer Ausnahme: Das Token eine…
### Claim-Flow (service_auth & anonym)
URL: https://docs.uptimeify.io/de/api/agent-auth/claim-flow
Description: Wie ein Agent aus einer Registrierung ein nur lesendes, kontogebundenes Zugriffstoken macht, indem ein angemeldeter Nutzer ihn autorisiert.
Summary: # Claim-Flow Ein **Claim** bindet die Registrierung eines Agenten an die Organisation eines angemeldeten Nutzers (oder an einen einzelnen Kunden darin) und gewährt ein **nur lesendes** (`api.read`) Zugriffstoken. `anonymous`- und `service_auth`-Agenten erhalten auf diesem Weg nie Schreibzugriff; Schreibbereiche freigeben lassen kann nur ein ID-JAG-Agent (siehe [Identity Assertion (ID-JAG)](/de/api/agent-auth/identity-assertion), das die Schritte 3 und 4 unten mitbenutzt). Auf dieser Seite gibt es zwei Wege zu einem Claim: - **`service_auth`** startet die Claim-Zeremonie sofort und liefert den `user_code` direkt an den aufrufenden Agenten zurück (eine vertrauenswürdige Integration im Device-Flow-Stil). - Eine **`anonymous`**-Registrierung (siehe [Agent-Authentifizierung](/de/api/agent-auth)) ist sofort nutzbar und kann *optional* später per `POST /agent/identity/claim` hochgestuft werden: der `user_code` wird dem Agenten auf diesem Weg nie zurückgegeben; nur der angemeldete Nutzer sieht ihn. ## 1. Mit `service_auth` registrieren `POST https://uptimeify.io/agent/identity` | Feld | Typ | Erforderlich | Beschreibung | | --- | --- | --- | --- | | `type` | string | ja | `"service_auth"` | | `login_hint` | string | ja | E-Mail des Nutzers, der den Agenten autorisieren wird. Muss ein `@` enthalten. | ```bash curl -X POST https://uptimeify.io/agent/identity \ -H 'Content-Type: application/json' \ -d '{"type":"service_auth","login_hint":"user@deinkunde.com"}' ``` ```json { "registration_id": "reg_…", "claim": { "user_code": "WDJB-MJHT", "verification_uri": "https://uptimeify.io/claim", "expires_in": 600, "interval": 5 }, "claim_token": "clm_…", "post_claim_scopes": ["api.read"] } ``` Zeige `verification_uri` und `user_code` deinem Nutzer an (ein Prompt im Stil des RFC-8628-Device-Flows). Die Registrierung startet mit `status: pending` und erzeugt kein Zugriffstoken, bis die Zeremonie abgeschlossen ist. Poll dazu mit dem `claim_token` in Schritt 3 unten. `user_code` und `claim_token` laufen beide nach `expires_in` Sekunden ab (600s / 10 Minuten); rufe erneut `POST /agent/identity` auf, um eine neue Zeremonie zu starten, falls die Zeit abläuft. ## 2. Oder: eine bestehende `anonymous`-Registrierung claimen `POST https://uptimeify.io/agent/identity/claim` | Feld | Typ | Erforderlich | Beschreibung | | --- | --- | --- | --- | | `claim_token` | string | ja | Das `clm_…` aus einem früheren Aufruf von `POST /agent/identity {"type":"anonymous"}`. | | `email` | string | ja | E-Mail des Nutzers, der den Claim autorisieren wird. Muss ein `@` enthalten. | ```bash curl -X POST https://uptimeify.io/agent/identity/claim \ -H 'Content-Type: application/json' \ -d '{"claim_token":"clm_…","email":"user@deinkunde.com"}' ``` ```json { "verification_uri": "https://uptimeify.io/claim?claim_attempt=cat_…", "claim_attempt_token": "cat_…", "expires_in": 600, "interval": 5 } ``` Beachte, was **fehlt**: `user_code`. Auf diesem Weg erfährt der Agent den Code nie, nur der angemeldete, an die E-Mail gebundene Nutzer sieht ihn, auf der `/claim`-Seite. Die Registrierung selbst bleibt während der ganzen Zeremonie `active` und funktioniert durchgehend mit ihrem `tools.public`-Scope weiter: das Claimen fügt nur `api.read` hinzu, es entzieht dem anonymen Zugriff während des laufenden Vorgangs nichts. Ein erneuter Aufruf dieses Endpunkts vor Ablauf überschreibt Code/Attempt-Token und setzt das 10-Minuten-Fenster zurück. Eine Registrierung kann nur einmal geclaimt werden: Ein zweiter Aufruf von `POST /agent/identity/claim` (oder ein `service_auth`-Claim, der immer schon vorab gebunden ist) nach erfolgter Bestätigung liefert `409 claimed_or_in_flight`. ## 3. Menschliche Zustimmung unter `/claim` Der gebundene Nutzer muss unter genau dem oben verwendeten `login_hint`/`email` bei Uptimeify angemeldet sein und entweder den vom Agenten angezeigten `user_code` eintippen oder den `verification_uri`-Link öffnen (der beim anonymen Weg `?claim_attempt=…` trägt). Die Uptimeify-Web-App…
### Identity Assertion (ID-JAG)
URL: https://docs.uptimeify.io/de/api/agent-auth/identity-assertion
Description: Wie sich ein Agent, der bei einem vertrauenswürdigen Identity-Provider angemeldet ist, mit einem ID-JAG registriert, sich von einem Nutzer Lesezugriff und ausgewählte Änderungsrechte freigeben lässt und wie der Provider ihn wieder sperrt.
Summary: # Identity Assertion (ID-JAG) Ein Agent, der schon eine Identität bei einem **vertrauenswürdigen Identity-Provider** hat, kann sich statt mit `anonymous` oder `service_auth` mit einem **Identity Assertion JWT Authorization Grant** (ID-JAG) registrieren. Gehört die bestätigte E-Mail darin zu einem Uptimeify-Konto, gibt die Kontoinhaberin oder der Kontoinhaber den Agenten einmal auf der Seite `/claim` frei und legt dabei fest, was er ändern darf. Danach registriert sich der Agent einfach mit einem frischen ID-JAG neu und bekommt sein Token ohne erneute Freigabe. Dieser Registrierungstyp ist **aus, solange Uptimeify keinem Identity-Provider vertraut**. Schau in die Metadaten des Autorisierungsservers: Nur wenn `agent_auth.identity_types_supported` `"identity_assertion"` enthält, sind die Endpunkte auf dieser Seite aktiv. Sonst antwortet `POST /agent/identity {"type":"identity_assertion"}` mit `400 issuer_not_enabled` und `POST /agent/event/notify` mit `404`. ## 1. Mit einem ID-JAG registrieren `POST https://uptimeify.io/agent/identity` | Feld | Typ | Erforderlich | Beschreibung | | --- | --- | --- | --- | | `type` | string | ja | `"identity_assertion"` | | `assertion_type` | string | ja | `"urn:ietf:params:oauth:token-type:id-jag"` | | `assertion` | string | ja | Das ID-JAG, das dein Identity-Provider ausgestellt hat. | | `scope` | string | nein | Die gewünschten Scopes, durch Leerzeichen getrennt, zum Beispiel `"api.read api.write.monitors"`. Unbekannte Werte fallen weg; ist gar kein bekannter Scope dabei, gilt die Anfrage als `"api.read"`. | Das ID-JAG muss: - mit einem Schlüssel aus dem JWKS eines Ausstellers von Uptimeifys Vertrauensliste signiert sein (`iss`), - `aud` = `https://uptimeify.io/api/`, ein nicht abgelaufenes `exp` und eine noch nie benutzte `jti` tragen (jede `jti` wird genau einmal angenommen), - `email` mit `email_verified: true` tragen, - eine `auth_time` tragen, die höchstens 3600 Sekunden zurückliegt; sonst lautet die Antwort `401 login_required` mit `max_age: 3600`, und du brauchst eine frische Anmeldung beim Provider. ```bash curl -X POST https://uptimeify.io/agent/identity \ -H 'Content-Type: application/json' \ -d '{"type":"identity_assertion","assertion_type":"urn:ietf:params:oauth:token-type:id-jag","assertion":"","scope":"api.read api.write.monitors"}' ``` Die Antwort ist einer von drei Ausgängen, alle mit `Cache-Control: no-store`. ### Freigabe nötig: `401 interaction_required` Die E-Mail gehört zu einem Uptimeify-Konto, und dieser Agent ist noch nicht freigegeben. ```json { "error": "interaction_required", "registration_id": "reg_…", "claim": { "user_code": "WDJB-MJHT", "verification_uri": "https://uptimeify.io/claim", "verification_uri_complete": "https://uptimeify.io/claim?claim_attempt=cat_…", "expires_in": 600, "interval": 5 }, "claim_token": "clm_…", "requested_scope": "api.read api.write.monitors" } ``` Schick deine Nutzerin oder deinen Nutzer zu `verification_uri_complete`. Angemeldet mit dem Konto zu dieser E-Mail sieht sie oder er, was du angefragt hast: Lesezugriff und jeden angefragten Schreibbereich als eigenes Kästchen. **Vorausgewählt ist kein Schreibbereich**; angehakt wird nur, was der Agent wirklich braucht. Danach pollst du `POST /oauth2/token` mit dem Claim-Grant und dem `claim_token`, genau wie in [Claim-Flow, Schritt 4](/de/api/agent-auth/claim-flow#4-auf-abschluss-pollen). Die Erfolgsantwort trägt den freigegebenen `scope` und eine `identity_assertion` für spätere Tauschvorgänge. Eine passende E-Mail verknüpft nie von selbst ein Konto: Freigegeben ist erst etwas, wenn die angemeldete Person auf `/claim` bestätigt. ### Schon freigegeben: `200` mit Konto-Assertion Die Registrierung zu deiner Provider-Identität (`iss`, `sub`) wurde bereits freigegeben. ```json { "registration_id": "reg_…", "identity_assertion": "", "scope": "api.read api.write.monitors", "token_endpoint": "https://uptimeify.io/oauth2/token" } ``` `scope` ist das Angefragte, wenn die Freigabe es abdec…
### API-Tokens
URL: https://docs.uptimeify.io/de/api/api-tokens
Description: API-Tokens ermöglichen den programmatischen Zugriff auf die Uptimeify-API. Tokens haben das Präfix wsm_ und können auf einen bestimmten Kunden oder organisationsweit beschränkt werden.
Summary: Es gibt zwei Endpunkt-Gültigkeitsbereiche: - **Organisations-Tokens** (`/api/organization/tokens`): nur für Admins, voller Organisationszugriff - **Kunden-Tokens** (`/api/customer/tokens`): beschränkt auf zugängliche Kunden ## Authentifizierung Alle Beispiele setzen ein Session-Cookie voraus (keine API-Tokens, API-Tokens können keine anderen API-Tokens verwalten): ```bash BASE_URL="https://uptimeify.io" ``` ## Endpunkte - [Organisations-Tokens auflisten](/de/api/api-tokens/list-organization-tokens) - [Organisations-Token erstellen](/de/api/api-tokens/create-organization-token) - [Organisations-Token löschen](/de/api/api-tokens/delete-organization-token) - [Kunden-Tokens auflisten](/de/api/api-tokens/list-customer-tokens) - [Kunden-Token erstellen](/de/api/api-tokens/create-customer-token) - [Kunden-Token löschen](/de/api/api-tokens/delete-customer-token)
### Kunden-Token erstellen
URL: https://docs.uptimeify.io/de/api/api-tokens/create-customer-token
Description: Erstellt einen neuen API-Token mit Gültigkeitsbereich für einen Kunden. Eingeschränkte Nutzer müssen customerId angeben. Der vollständige Token wird nur einmal zurückgegeben. Bewahre ihn sicher auf.
Summary: `POST /api/customer/tokens` ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Standard | Beschreibung | |-------|------|----------|---------|-------------| | `name` | string | Ja | - | Anzeigename des Tokens (1-255 Zeichen) | | `expiresInDays` | number | Nein | null | Tage bis zum Ablauf (1-365). Null = kein Ablauf. | | `customerId` | number | Nein* | null | Token auf einen bestimmten Kunden beschränken. Erforderlich für eingeschränkte Nutzer. | | `scopes` | string[] | Nein | null | Beschränkt den Token auf diese Scopes, z. B. `["api.read.monitors"]`. Weglassen = Vollzugriff. Siehe [Token-Scopes](/de/api/introduction/token-scopes-organization-vs-customer). Nach dem Anlegen nicht mehr änderbar. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/customer/tokens" \ -H "Cookie: $SESSION_COOKIE" \ -H "Content-Type: application/json" \ -d '{ "name": "Acme Corp API Token", "customerId": 5, "expiresInDays": 180 }' ``` ## Antwort (Response) ```json { "id": 2, "name": "Acme Corp API Token", "token": "wsm_f7e6d5c4b3a2...", "lastUsedAt": null, "expiresAt": "2026-10-15T08:00:00.000Z", "createdAt": "2026-04-15T08:00:00.000Z", "scopes": null } ``` ## Häufige Fehler - `400 invalidRequestBody`, wenn `scopes` leer ist, einen Scope doppelt oder einen unbekannten enthält - `400 Invalid customer ID` wenn die customerId nicht zu deiner Organisation gehört - `400 customerId is required` wenn ein eingeschränkter Nutzer keine customerId angibt - `403 Forbidden` wenn der Kunde außerhalb des Gültigkeitsbereichs des Nutzers liegt ## Berechtigungen Offen für Organisations-Admins und für die Rolle `readonly`; `editor` und `responder` werden mit `insufficientPermissions` abgewiesen. Ein Nur-Lese-Zugang ist immer kundengebunden, `customerId` ist für ihn deshalb Pflicht und muss einen seiner eigenen Kunden benennen. Ein organisationsweiter Token (ohne `customerId`) ist für diese Rolle nicht erreichbar. Der ausgestellte Token erbt die Rolle seines Erstellers. Ein von einem Nur-Lese-Zugang erzeugter Token kann damit nicht mehr als dieser Zugang: Er löscht keine Monitore und ändert keine Besitzklasse.
### Organisations-Token erstellen
URL: https://docs.uptimeify.io/de/api/api-tokens/create-organization-token
Description: Erstellt einen neuen API-Token. Der vollständige Token wird nur einmal zurückgegeben. Bewahre ihn sicher auf. Erfordert die Admin-Rolle.
Summary: `POST /api/organization/tokens` ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Standard | Beschreibung | |-------|------|----------|---------|-------------| | `name` | string | Ja | - | Anzeigename des Tokens (1-255 Zeichen) | | `expiresInDays` | number | Nein | null | Tage bis zum Ablauf (1-365). Null = kein Ablauf. | | `customerId` | number | Nein | null | Token auf einen bestimmten Kunden beschränken (muss zu deiner Organisation gehören) | | `scopes` | string[] | Nein | null | Beschränkt den Token auf diese Scopes, z. B. `["api.read.monitors"]`. Weglassen = Vollzugriff. Siehe [Token-Scopes](/de/api/introduction/token-scopes-organization-vs-customer). Nach dem Anlegen nicht mehr änderbar. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/organization/tokens" \ -H "Cookie: $SESSION_COOKIE" \ -H "Content-Type: application/json" \ -d '{ "name": "Production API", "expiresInDays": 90 }' ``` ## Antwort (Response) ```json { "id": 1, "name": "Production API", "token": "wsm_a1b2c3d4e5f6...", "lastUsedAt": null, "expiresAt": "2026-07-15T10:00:00.000Z", "createdAt": "2026-04-15T10:00:00.000Z", "scopes": null } ``` ## Häufige Fehler - `400 invalidRequestBody`, wenn `scopes` leer ist, einen Scope doppelt oder einen unbekannten enthält - `400 Invalid customer ID` wenn die customerId nicht zu deiner Organisation gehört - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du kein Admin bist
### Kunden-Token löschen
URL: https://docs.uptimeify.io/de/api/api-tokens/delete-customer-token
Description: Widerruft einen kundenbezogenen API-Token dauerhaft. Nutzer können nur Tokens innerhalb ihres Kunden-Gültigkeitsbereichs löschen.
Summary: `DELETE /api/customer/tokens/:id` ## Beispiel (cURL) ```bash curl -X DELETE "$BASE_URL/api/customer/tokens/2" \ -H "Cookie: $SESSION_COOKIE" ``` ## Antwort (Response) ```json { "success": true } ``` ## Häufige Fehler - `403 Forbidden` wenn der Token außerhalb deines Kunden-Gültigkeitsbereichs liegt oder wenn der Token organisationsweit ist (kein `customerId`) - `404 Token not found` wenn der Token nicht existiert oder zu einer anderen Organisation gehört ## Berechtigungen Offen für Organisations-Admins und für die Rolle `readonly`; `editor` und `responder` werden mit `insufficientPermissions` abgewiesen. Ein kundengebundener Aufrufer widerruft nur Token seiner eigenen Kunden; ein organisationsweiter Token (ohne `customerId`) wird grundsätzlich abgelehnt. Für Token, die vor dem 04.09.2026 entstanden sind, hält `api_token` keinen Ersteller fest. Ein Nur-Lese-Zugang kann deshalb auch einen kundengebundenen Token widerrufen, den ein Admin für denselben Kunden ausgestellt hat.
### Organisations-Token löschen
URL: https://docs.uptimeify.io/de/api/api-tokens/delete-organization-token
Description: Widerruft einen API-Token dauerhaft. Erfordert die Admin-Rolle.
Summary: `DELETE /api/organization/tokens/:id` ## Beispiel (cURL) ```bash curl -X DELETE "$BASE_URL/api/organization/tokens/1" \ -H "Cookie: $SESSION_COOKIE" ``` ## Antwort (Response) ```json { "success": true } ``` ## Häufige Fehler - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du kein Admin bist - `404 Token not found` wenn der Token nicht existiert oder zu einer anderen Organisation gehört
### Kunden-Tokens auflisten
URL: https://docs.uptimeify.io/de/api/api-tokens/list-customer-tokens
Description: Gibt die für den aktuellen Nutzer sichtbaren API-Tokens zurück. Eingeschränkte Nutzer sehen nur ihre kundenbezogenen Tokens; Admins sehen alle Tokens. Tokens sind maskiert: nur die ersten 8 Zeichen werden angezeigt.
Summary: `GET /api/customer/tokens` ## Query-Parameter | Parameter | Typ | Standard | Beschreibung | |---|---|---|---| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/customer/tokens?envelope=items" \ -H "Cookie: $SESSION_COOKIE" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "items": [ { "id": 2, "organizationId": 1, "name": "Customer Scoped Token", "customerId": 5, "customerName": "Acme Corp", "lastUsedAt": null, "expiresAt": null, "createdAt": "2026-02-01T08:00:00.000Z", "tokenHint": "wsm_f7e6d5..." } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Einträge); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. ## Häufige Fehler - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn der Nutzer keinen Lesezugriff hat
### Organisations-Tokens auflisten
URL: https://docs.uptimeify.io/de/api/api-tokens/list-organization-tokens
Description: Gibt alle API-Tokens der Organisation zurück. Tokens sind maskiert: nur die ersten 8 Zeichen werden angezeigt. Erfordert die Admin-Rolle.
Summary: `GET /api/organization/tokens` ## Query-Parameter | Parameter | Typ | Standard | Beschreibung | |---|---|---|---| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/organization/tokens?envelope=items" \ -H "Cookie: $SESSION_COOKIE" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "items": [ { "id": 1, "organizationId": 1, "name": "Production API", "customerId": null, "customerName": null, "lastUsedAt": "2026-04-01T12:00:00.000Z", "expiresAt": null, "createdAt": "2026-01-15T10:00:00.000Z", "tokenHint": "wsm_a1b2c..." } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Einträge); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. ## Häufige Fehler - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du kein Admin bist
### Benutzer & Sitzung
URL: https://docs.uptimeify.io/de/api/auth
Description: Verwalte deine aktuelle Benutzersitzung und rufe Profilinformationen ab.
Summary: ## Endpunkte - [Aktuellen Benutzer abrufen](/de/api/auth/get-current-user)
### Aktuellen Benutzer abrufen
URL: https://docs.uptimeify.io/de/api/auth/get-current-user
Description: Gibt eine reduzierte Sicht auf den aktuell authentifizierten Benutzer und seine Sitzung zurück.
Summary: `GET /api/auth/get-session` ## Anfrage (Request) ```http GET /api/auth/get-session HTTP/1.1 ``` Dieser Endpoint liefert ein öffentlich unkritisches Session-Payload. Für Integrationen nutze API-Tokens (`Authorization: Bearer wsm_...`) mit den REST-Endpunkten unter `/api/**`. Interne Felder wie `email`, `role`, `language`, `isGlobalAdmin`, `isGlobalSupporter`, `emailVerified`, `image` und der Platform-Admin-Customer-Context werden absichtlich nicht zurückgegeben. ## Antwort (Response) ```json { "user": { "id": "user_12345", "name": "Max Mustermann", "firstName": "Max", "lastName": "Mustermann", "organizationId": 1, "organizationStatus": "active", "isActive": true, "createdAt": "2026-03-31T15:50:49.030Z", "updatedAt": "2026-03-31T15:50:49.030Z" }, "session": { "userId": "user_12345", "expiresAt": "2027-03-31T15:58:26.618Z", "token": "session-token-value" } } ```
### Change Requests
URL: https://docs.uptimeify.io/de/api/change-requests
Description: Wie Kunden Änderungen an Managed-Monitoren anfragen und Organisationen sie bearbeiten.
Summary: Monitore mit `managementType: managed` sind für kunden-gescopte Nutzer schreibgeschützt (siehe [Managed vs. Self-Service Monitore](/de/monitoring/managed-vs-self-service)). Statt direkt zu bearbeiten, eröffnet ein Kunde einen **Change Request** gegen den Monitor; die Organisation prüft ihn im Posteingang und nimmt ihn an oder lehnt ab. Ein Change Request hat einen `kind`: | Kind | Bedeutung | Effekt bei Annahme | |---|---|---| | `change` | Freitext-Änderungswunsch für einen Managed-Monitor | Keiner automatisch: die Org setzt die Änderung manuell um | | `request_managed` | Der Kunde bittet die Org, die Verantwortung für einen Monitor oder eine Statusseite zu übernehmen | Monitor oder Statusseite wird automatisch auf `managed` umgestellt | Endpunkte: - [Change Request anlegen](/de/api/change-requests/create-change-request): `POST /api/monitors/:monitorType/:monitorId/change-requests` (Kunde oder Org) - [Änderungsanfrage zu einer Statusseite anlegen](/de/api/change-requests/create-status-page-change-request): `POST /api/status-pages/:id/change-requests` (Kunde oder Org, seit 30. Oktober 2026) - [Change Requests auflisten](/de/api/change-requests/list-change-requests): `GET /api/change-requests` (Org-Admins) - [Change Request auflösen](/de/api/change-requests/resolve-change-request): `PATCH /api/change-requests/:id` (Org-Admins) Statusseiten mit `managementType: managed` funktionieren genauso (siehe [Wer eine Statusseite ändern darf](/de/api/status-pages)); ihre Anfragen tragen `monitorType: status_page`. Offene Anfragen sind auf **10 pro Kunde** über alle Monitor-Typen und Statusseiten begrenzt; weitere Creates liefern `429` (`tooManyOpenRequests`).
### Change Request anlegen
URL: https://docs.uptimeify.io/de/api/change-requests/create-change-request
Description: Eröffnet einen Change Request gegen einen beliebigen Monitor (alle Monitor-Typen).
Summary: `POST /api/monitors/:monitorType/:monitorId/change-requests` Lesezugriff auf den Monitor genügt. Der typische Aufrufer ist ein Kundenportal-Nutzer, der auf einem `managed`-Monitor *keinen* Schreibzugriff hat. ## Pfad-Parameter | Parameter | Beschreibung | |---|---| | `monitorType` | Einer von `website`, `dns`, `icmp`, `smtp`, `ssh`, `ftp`, `imap_pop`, `domain`, `dnsbl` | | `monitorId` | Numerische ID des Monitors | ## Request Body | Feld | Typ | Pflicht | Standard | Beschreibung | |------|-----|---------|----------|--------------| | `kind` | string | Nein | `change` | `change` (Freitext-Wunsch) oder `request_managed` (die Org bitten, den Monitor zu übernehmen) | | `message` | string | Ja | - | Der Anfragetext (1-2000 Zeichen) | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/monitors/website/103/change-requests" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "kind": "change", "message": "Bitte das Check-Intervall auf 1 Minute senken." }' ``` ## Response ```json { "id": 12, "status": "open" } ``` ## Häufige Fehler - `400 Invalid monitor type` (`invalidMonitorType`), wenn `monitorType` keiner der unterstützten Typen ist - `400 Invalid monitor identifier`, wenn `monitorId` keine positive Ganzzahl ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` / `404 Not found`, wenn der Monitor außerhalb deines Scopes liegt - `403 Forbidden` mit `data.code` `authorizingUserUnresolved`, wenn der Aufruf über eine Agenten-Sitzung kommt, deren autorisierender Mensch nicht mehr auflösbar ist. `requested_by` ist `NOT NULL` und zeigt auf einen echten Nutzer, es gibt also keinen Rückfallwert, und die Anfrage entsteht nicht. Autorisiere die Verbindung neu oder stelle die Anfrage aus einer Sitzung, die zu einer Person gehört. - `429 Too many open requests` (`tooManyOpenRequests`), wenn der Kunde bereits 10 offene Anfragen hat
### Änderungsanfrage zu einer Statusseite anlegen
URL: https://docs.uptimeify.io/de/api/change-requests/create-status-page-change-request
Description: Bittet die Organisation um eine Änderung an einer Statusseite oder darum, eine self_service-Seite zu übernehmen. Lesezugriff genügt.
Summary: `POST /api/status-pages/:id/change-requests` Lesezugriff auf die Statusseite genügt: Organisationsrollen `admin`, `editor` und `readonly`, Kundennutzer (auch mit der Rolle `readonly`) und API-Tokens, jeweils in ihrem Kundenbereich. Der typische Aufrufer ist ein Kundennutzer, der eine `managed`-Seite nicht ändern darf (siehe [Wer eine Statusseite ändern darf](/de/api/status-pages)) und die Organisation stattdessen um eine Änderung bittet. Mit `kind: request_managed` bittet ein Kunde die Organisation, eine `self_service`-Seite zu übernehmen. Die Anfrage landet im selben Posteingang wie die Änderungsanfragen zu Monitoren: [Change Requests auflisten](/de/api/change-requests/list-change-requests) liefert sie mit `monitorType: "status_page"`, `monitorId` = ID der Statusseite und `monitorName` = Name der Seite, und [Change Request auflösen](/de/api/change-requests/resolve-change-request) nimmt sie an oder lehnt sie ab. Wird eine Anfrage `request_managed` angenommen, steht die Seite danach auf `managementType: managed`. ## Pfad-Parameter | Parameter | Beschreibung | |---|---| | `id` | ID oder `publicId` (UUID) der Statusseite | ## Request-Body | Feld | Typ | Pflicht | Standard | Beschreibung | |------|-----|---------|----------|--------------| | `kind` | string | Nein | `change` | `change` (Freitext-Wunsch) oder `request_managed` (die Organisation bitten, die Seite zu übernehmen) | | `message` | string | Ja | - | Der Anfragetext (1 bis 2000 Zeichen) | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/status-pages/db58058e-4b58-4d97-a314-3bb8e279a182/change-requests" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "kind": "change", "message": "Bitte die neue Checkout-API als Komponente aufnehmen." }' ``` ## Antwort `201 Created` ```json { "id": 14, "status": "open" } ``` Offene Anfragen sind auf **10 je Kunde** begrenzt, über alle Arten hinweg (Monitore und Statusseiten). ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`), wenn `kind` weder `change` noch `request_managed` ist oder `message` leer oder länger als 2000 Zeichen ist - `400 Bad Request` (`statusPageHasNoCustomer`), wenn die Seite keinen Kunden hat (`customerId: null`): Es gibt keinen Kunden, der fragen könnte, deshalb nimmt eine solche Seite keine Änderungsanfragen an - `400 Invalid Status page identifier`, wenn `id` weder eine numerische ID noch eine UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle keine Statusseiten lesen darf, die Seite zu einem Kunden außerhalb deines Bereichs gehört oder ein kundengebundener Aufrufer eine Seite ohne Kunde nennt - `403 Forbidden` (`authorizingUserUnresolved`), wenn der Aufruf über eine Agenten-Sitzung kommt, deren autorisierender Mensch nicht mehr auflösbar ist. Jede Anfrage hält die Person fest, die gefragt hat, deshalb entsteht keine Anfrage. Autorisiere die Verbindung neu oder stelle die Anfrage aus einer Sitzung, die zu einer Person gehört. - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul für deine Organisation nicht aktiv ist - `404 Status page not found`, wenn es keine Statusseite mit dieser ID gibt (ohne `data.code`), oder (`statusPageNotFound`), wenn sie zu einer anderen Organisation gehört - `429 Too many open requests` (`tooManyOpenRequests`), wenn der Kunde schon 10 offene Anfragen hat
### Change Requests auflisten
URL: https://docs.uptimeify.io/de/api/change-requests/list-change-requests
Description: Listet den Change-Request-Posteingang der Organisation.
Summary: `GET /api/change-requests` Erfordert Org-Schreibzugriff (Organisations-Admin oder Global-Admin). Ergebnisse sind strikt auf die Organisation des Aufrufers begrenzt. ## Query-Parameter | Parameter | Typ | Pflicht | Standard | Beschreibung | |---|---|---|---|---| | `status` | string | Nein | `open` | `open`, `accepted` oder `rejected` | | `envelope` | string | Nein | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl "$BASE_URL/api/change-requests?status=open&envelope=items" \ -H "Authorization: Bearer $TOKEN" ``` ## Response Neueste zuerst. `monitorName` wird pro Monitor-Typ aufgelöst; `websiteId` ist ein Legacy-Feld, das nur bei Website-Monitoren befüllt ist. `monitorType` kann auch `status_page` sein (seit 30. Oktober 2026, aus [Änderungsanfrage zu einer Statusseite anlegen](/de/api/change-requests/create-status-page-change-request)): `monitorId` ist dann die ID der Statusseite, `monitorName` der Name der Seite und `websiteId` `null`. ```json { "items": [ { "id": 12, "monitorType": "website", "monitorId": 103, "websiteId": 103, "customerId": 101, "customerName": "Customer A GmbH", "monitorName": "New Landing Page", "requestedBy": "usr_123", "kind": "change", "message": "Bitte das Check-Intervall auf 1 Minute senken.", "status": "open", "resolvedBy": null, "resolvedAt": null, "createdAt": "2026-07-09T10:00:00.000Z" } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Einträge); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. ## Häufige Fehler - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden`, wenn du kein Organisations-Admin bist
### Change Request auflösen
URL: https://docs.uptimeify.io/de/api/change-requests/resolve-change-request
Description: Nimmt einen offenen Change Request an oder lehnt ihn ab.
Summary: `PATCH /api/change-requests/:id` Erfordert Org-Schreibzugriff. Der Status-Übergang ist atomar: bei parallelen Auflösungen gewinnt nur ein Aufrufer; der Verlierer erhält `409`. Das Annehmen einer Anfrage mit `kind: request_managed` stellt den Ziel-Monitor zusätzlich auf `managementType: managed` um (dispatcht in die korrekte Tabelle des Monitor-Typs). Bei `monitorType: status_page` (seit 30. Oktober 2026) stellt es die Statusseite auf `managementType: managed`. ## Request Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `status` | string | Ja | `accepted` oder `rejected` | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X PATCH "$BASE_URL/api/change-requests/12" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "status": "accepted" }' ``` ## Response ```json { "id": 12, "status": "accepted" } ``` ## Häufige Fehler - `400 Invalid change-request identifier` - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden`, wenn du kein Organisations-Admin bist - `404 Change request not found` (`changeRequestNotFound`), wenn es die Anfrage nicht gibt oder sie zu einer anderen Organisation gehört. Bis zum 20.10.2026 antwortete eine fremde Anfrage mit `403`. - `409 Change request already resolved`, wenn die Anfrage nicht mehr `open` ist
### Benutzerdefinierte Felder
URL: https://docs.uptimeify.io/de/api/custom-fields
Description: Definiere benutzerdefinierte Metadatenfelder, die an Kunden und Websites angehängt werden können. Benutzerdefinierte Felder unterstützen die Typen Text, Select und Multi-Select.
Summary: ## Authentifizierung Alle Beispiele setzen ein Bearer-Token voraus: ```bash BASE_URL="https://uptimeify.io" TOKEN="" ``` ## Endpunkte - [Benutzerdefinierte Felder auflisten](/de/api/custom-fields/list-custom-fields) - [Benutzerdefiniertes Feld abfragen](/de/api/custom-fields/get-custom-field) - [Benutzerdefiniertes Feld erstellen](/de/api/custom-fields/create-custom-field) - [Benutzerdefiniertes Feld aktualisieren](/de/api/custom-fields/update-custom-field) - [Benutzerdefiniertes Feld löschen](/de/api/custom-fields/delete-custom-field)
### Benutzerdefiniertes Feld erstellen
URL: https://docs.uptimeify.io/de/api/custom-fields/create-custom-field
Description: Erstellt eine neue Definition für ein benutzerdefiniertes Feld.
Summary: `POST /api/custom-fields` Erfordert die Rolle `admin` (oder einen globalen Admin). Editoren und Nur-Lese-Benutzer erhalten `403`. ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Standard | Beschreibung | |-------|------|----------|---------|-------------| | `organizationId` | number | Nein | aus der Session | Muss, falls angegeben, deine eigene Organisation sein | | `name` | string | Ja | - | Anzeigename, 1 bis 100 Zeichen | | `fieldKey` | string | Nein | auto aus name | Eindeutiger Schlüssel, max. 100 Zeichen (automatisch normalisiert: Kleinbuchstaben, nicht-alphanumerisch → `_`) | | `fieldType` | string | Nein | `text` | Einer von `text`, `number`, `email`, `url`, `select` | | `isRequired` | boolean | Nein | false | Ob das Feld erforderlich ist | | `displayOrder` | number | Nein | 0 | Sortierreihenfolge, Ganzzahl 0 bis 10000 | | `options` | string[] | Nein | `[]` | Optionen für den Typ `select`, max. 50 Einträge mit je max. 100 Zeichen | | `placeholder` | string\|null | Nein | null | Platzhaltertext, max. 200 Zeichen | | `helpText` | string\|null | Nein | null | Hilfetext unterhalb des Feldes, max. 500 Zeichen | | `showInTable` | boolean | Nein | true | In Tabellenansichten anzeigen | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/custom-fields" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "organizationId": 1, "name": "Environment", "fieldType": "select", "options": ["production", "staging", "development"], "isRequired": true, "showInTable": true }' ``` ## Häufige Fehler - `400 Bad Request` wenn der Body die Validierung nicht besteht (unbekannter `fieldType`, `name` fehlt oder hat mehr als 100 Zeichen, mehr als 50 `options`) - `403 Forbidden` wenn deine Rolle nicht `admin` ist oder `organizationId` eine fremde Organisation nennt - `409 Conflict` (`customFieldAlreadyExists`), wenn für die Organisation bereits ein aktives Feld mit diesem `fieldKey` existiert. Ein gelöschtes (deaktiviertes) Feld mit demselben Schlüssel wird stattdessen mit den Angaben aus dem Body reaktiviert; bereits an Kunden gespeicherte Werte unter dem Schlüssel bleiben unverändert. ## Antwort (Response) Gibt das erstellte benutzerdefinierte Feld-Objekt zurück. Siehe [Fehlercodes](/de/api/error-codes-and-known-pitfalls) für Fehlerantworten.
### Benutzerdefiniertes Feld löschen
URL: https://docs.uptimeify.io/de/api/custom-fields/delete-custom-field
Description: Löscht ein benutzerdefiniertes Feld per Soft-Delete (setzt isActive: false).
Summary: `DELETE /api/custom-fields/:id` Erfordert die Rolle `admin` (oder einen globalen Admin). Editoren und Nur-Lese-Benutzer erhalten `403`. ## Beispiel (cURL) ```bash curl -X DELETE "$BASE_URL/api/custom-fields/1" \ -H "Authorization: Bearer $TOKEN" ``` ## Häufige Fehler - `403 Forbidden` wenn deine Rolle nicht `admin` ist - `404 Not Found` wenn das Feld in deiner Organisation nicht existiert ## Antwort (Response) ```json { "success": true, "message": "Custom field deleted successfully" } ```
### Benutzerdefiniertes Feld abfragen
URL: https://docs.uptimeify.io/de/api/custom-fields/get-custom-field
Description: Gibt eine aktive Felddefinition deiner Organisation zurück, in derselben Form wie ein Eintrag der Feldliste.
Summary: `GET /api/custom-fields/{id}` ## Zugriff Jedes Mitglied der Organisation. Zurück kommen nur aktive Definitionen der eigenen Organisation; ein gelöschtes (inaktives) Feld antwortet `404`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/custom-fields/7" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) `200 OK` ```json { "id": 7, "organizationId": 10, "name": "Contract number", "fieldKey": "contract_number", "fieldType": "text", "isRequired": false, "displayOrder": 1, "options": null, "placeholder": "e.g. C-2026-001", "helpText": null, "showInTable": true, "isActive": true, "createdAt": "2026-06-01T08:00:00.000Z", "updatedAt": "2026-06-01T08:00:00.000Z" } ``` ## Häufige Fehler - `400 Bad Request` (`fieldIdRequired`), wenn die ID keine positive Zahl ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `404 Not Found` (`customFieldNotFound`), wenn das Feld nicht existiert, inaktiv ist oder zu einer anderen Organisation gehört
### Benutzerdefinierte Felder auflisten
URL: https://docs.uptimeify.io/de/api/custom-fields/list-custom-fields
Description: Gibt alle aktiven Definitionen für benutzerdefinierte Felder der Organisation zurück.
Summary: `GET /api/custom-fields` ## Query Parameter | Parameter | Typ | Standard | Beschreibung | |-----------|------|---------|-------------| | `organizationId` | number | Session-Org | Überschreibt den Organisations-Scope | | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/custom-fields?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "items": [ { "id": 1, "organizationId": 1, "name": "Data Center", "fieldKey": "data_center", "fieldType": "text", "isRequired": false, "displayOrder": 0, "options": [], "placeholder": "e.g. fsn1", "helpText": "Primary data center location", "showInTable": true, "isActive": true, "createdAt": "2026-01-01T00:00:00.000Z", "updatedAt": "2026-01-01T00:00:00.000Z" } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Einträge); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Es werden nur aktive Felder (`isActive: true`) zurückgegeben, sortiert nach `displayOrder`.
### Benutzerdefiniertes Feld aktualisieren
URL: https://docs.uptimeify.io/de/api/custom-fields/update-custom-field
Description: Aktualisiert die Definition eines benutzerdefinierten Feldes. Alle Felder sind optional.
Summary: `PATCH /api/custom-fields/:id` Erfordert die Rolle `admin` (oder einen globalen Admin). Editoren und Nur-Lese-Benutzer erhalten `403`. ## Anfrage (Request Body) (alle optional) | Feld | Typ | Beschreibung | |-------|------|-------------| | `name` | string | Anzeigename, 1 bis 100 Zeichen | | `fieldType` | string | Einer von `text`, `number`, `email`, `url`, `select` | | `isRequired` | boolean | Ob das Feld erforderlich ist | | `displayOrder` | number | Sortierreihenfolge, Ganzzahl 0 bis 10000 | | `options` | string[] | Optionen für den Typ `select`, max. 50 Einträge mit je max. 100 Zeichen | | `placeholder` | string\|null | Platzhaltertext, max. 200 Zeichen | | `helpText` | string\|null | Hilfetext, max. 500 Zeichen | | `showInTable` | boolean | In Tabellenansichten anzeigen | | `isActive` | boolean | Soft-Delete (auf false setzen) | ## Beispiel (cURL) ```bash curl -X PATCH "$BASE_URL/api/custom-fields/1" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "Environment", "options": ["production", "staging", "development", "qa"] }' ``` ## Häufige Fehler - `400 Bad Request` wenn der Body die Validierung nicht besteht (unbekannter `fieldType`, `name` mit mehr als 100 Zeichen, mehr als 50 `options`) - `403 Forbidden` wenn deine Rolle nicht `admin` ist - `404 Not Found` wenn das Feld in deiner Organisation nicht existiert ## Antwort (Response) Gibt das aktualisierte benutzerdefinierte Feld-Objekt zurück. Siehe [Fehlercodes](/de/api/error-codes-and-known-pitfalls) für Fehlerantworten.
### Kunden-Verwaltung
URL: https://docs.uptimeify.io/de/api/customers
Description: Pfadbasierte Kunden-Endpunkte verwenden customerPublicId-UUIDs.
Summary: ## Endpunkte - [Kunden auflisten](/de/api/customers/list-customers) - [Kunden erstellen](/de/api/customers/create-customer) - [Kunden-Details abrufen](/de/api/customers/get-customer-details) - [Kunden aktualisieren](/de/api/customers/update-customer) - [Paket wechseln](/de/api/customers/change-package) - [SMS-Nutzung](/de/api/customers/sms-usage)
### Sammelaktionen
URL: https://docs.uptimeify.io/de/api/customers/bulk-actions
Description: Wendet eine Aktion auf mehrere Kunden gleichzeitig an, für Mehrfachauswahl-Workflows.
Summary: `POST /api/customers/bulk` Wendet eine einzelne Aktion auf eine Liste von Kunden-IDs an. Jede ID wird unabhängig verarbeitet: Ein einzelner Konflikt oder ein fehlender Kunde bricht die restlichen nicht ab. Die Antwort ist immer **`200 OK`**, auch wenn einzelne IDs fehlgeschlagen sind. Prüfe daher `failed` statt dich allein auf den HTTP-Status zu verlassen. ## Authentifizierung ```bash BASE_URL="https://uptimeify.io" TOKEN="" ``` ## Anfrage (Request Body) ```json { "ids": [101, 102, 103], "action": "reports", "payload": { "enabled": true } } ``` | Feld | Typ | Erforderlich | Beschreibung | |------|-----|---------------|--------------| | `ids` | number[] | ja | Kunden-IDs (die numerische `id`, nicht `publicId`). Nicht leer, maximal **200** Einträge, positive Ganzzahlen, keine Duplikate. | | `action` | string | ja | Eine von `reports`, `activate`, `deactivate`, `delete`, `package`. | | `payload` | object | abhängig von `action` | Erforderlich für `reports` und `package` (siehe unten). Optional bei `delete` (`userAction`). Wird bei `activate`, `deactivate` ignoriert. | ### Aktionen | Aktion | Wirkung | `payload` | |--------|---------|-----------| | `reports` | Setzt `monthlyReportsEnabled` bei jedem Kunden. | `{ "enabled": boolean }` (erforderlich) | | `activate` | Setzt den Kundenstatus auf `active` (kein Effekt, falls bereits aktiv) und kaskadiert die Monitor-Status entsprechend. | keins | | `deactivate` | Setzt den Kundenstatus auf `inactive` (kein Effekt, falls bereits inaktiv) und kaskadiert die Monitor-Status entsprechend. | keins | | `delete` | Löscht den Kunden endgültig (Hard Delete). Monitore und Check-Historie werden per Kaskade mitgelöscht. Nutzer, die **nur** diesem Kunden zugeordnet sind, werden deaktiviert oder gelöscht, siehe [Kunden löschen](/de/api/customers/delete-customer). **Nicht rückgängig zu machen.** | `{ "userAction": "deactivate" \| "delete" }` (optional, Standard `deactivate`) | | `package` | Weist dem Kunden ein anderes Paket per ID zu. | `{ "packageId": number }` (erforderlich) | `package` akzeptiert ausschließlich eine numerische `packageId`, die zur **Organisation des jeweiligen Kunden** gehört. Für alle Aufrufenden außer globalen Admins ist das dasselbe wie die eigene Organisation, denn nur deren Kunden sind überhaupt adressierbar. Ein globaler Admin, der Kunden mehrerer Organisationen bearbeitet, braucht je Kunde eine `packageId` aus dessen eigener Organisation; eine fremde wird mit `invalidPackageType` abgelehnt. Anders als bei [Kunden aktualisieren](/de/api/customers/update-customer) wird kein legacy `packageType`-String oder Display-Name aufgelöst, denn das Erraten des gemeinten Pakets über bis zu 200 Zeilen hinweg ist genau das, was der Sammelaktions-Endpunkt nicht tut. Die ID lässt sich zuvor über [Paket-Konfigurationen auflisten](/de/api/organization/list-package-configs) ermitteln. `payload.enabled`, `payload.packageId` und `payload.userAction` werden **einmalig im Voraus** validiert, bevor irgendein Kunde angefasst wird. Ein fehlerhaftes Payload lässt die gesamte Anfrage mit `400 invalidRequestBody` fehlschlagen; es wird niemals zu 200 identischen Einzel-Fehlern pro ID. ## Beispiel-Request ```bash curl -X POST "$BASE_URL/api/customers/bulk" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "ids": [101, 102, 103], "action": "reports", "payload": { "enabled": true } }' ``` ## Beispiel-Response (Teilergebnis) ```json { "ok": [101, 103], "failed": [ { "id": 102, "reason": "customerNotFound" } ] } ``` `ok` listet die aktualisierten IDs. `failed` listet die nicht aktualisierten IDs, jeweils mit einem `reason`-String. Zeige das Teilergebnis an (zum Beispiel „2 von 3 aktualisiert"), niemals einen pauschalen Erfolg allein aufgrund des `200`-Status der Anfrage. ## Häufige Fehler Diese lassen die **gesamte Anfrage** fehlschlagen, bevor überhaupt ein Kunde angefasst wird: - `401 unauthorized` du bist nicht eingeloggt - `403 forbidden` deine Rolle ist `re…
### Paket wechseln
URL: https://docs.uptimeify.io/de/api/customers/change-package
Description: Ändert die Paketzuordnung des Kunden.
Summary: `PATCH /api/customers/:customerPublicId` Technisch ist das derselbe Endpoint wie [Kunden aktualisieren](/de/api/customers/update-customer). Normalerweise sendest du hier `packageId`. Legacy-`packageType`-Werte werden aus Kompatibilitätsgründen weiterhin akzeptiert, müssen sich aber auf ein Paket auflösen lassen, das die Organisation tatsächlich hat: ein Paketschlüssel oder ein Paket-Anzeigename. Ein unbekannter Wert wird mit `400` und `data.code` `invalidPackageType` abgewiesen. ## Authentifizierung ```bash BASE_URL="https://uptimeify.io" TOKEN="" ``` ## Anfrage (Request Body) ```json { "packageId": 12 } ``` ## Beispiel-Request ```bash curl -X PATCH "$BASE_URL/api/customers/6bfec6f6-245a-47ce-843b-157d97d56f88" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "packageId": 12 }' ``` ## Beispiel-Response ```json { "id": 101, "publicId": "6bfec6f6-245a-47ce-843b-157d97d56f88", "organizationId": 1, "name": "Customer A GmbH", "email": "contact@customer-a.de", "notificationPhoneNumber": null, "notificationEmail": null, "packageId": 12, "status": "active", "monthlyReportsEnabled": true, "customFields": {}, "notificationChannels": null, "notificationTargets": null, "updatedAt": "2026-02-26T19:37:00.000Z" } ``` ## Häufige Fehler - `400` Invalid Customer identifier - `400` Ungültige `packageId` / ungültiger `packageType` für diese Organisation (`data.code`: `invalidPackageType`) - `401` Unauthorized - `403` Forbidden / Organization ID not found - `404` Customer not found - `500` Failed to update customer
### Kunden erstellen
URL: https://docs.uptimeify.io/de/api/customers/create-customer
Description: Erstellt einen neuen Kunden und weist über packageType ein organisationsdefiniertes Paket zu.
Summary: `POST /api/customers` ## Authentifizierung Dieser Endpoint erfordert Authentifizierung. ```bash BASE_URL="https://uptimeify.io" TOKEN="wsm_" ``` ## Anfrage (Request Body) ```json { "name": "Kundenname", "email": "kunde@deinkunde.com", "packageType": "business", // konfigurierter packageType oder Display-Name aus der Paket-Konfiguration der Organisation "organizationId": 1, // optional (nur für Global Admins erforderlich) "status": "active", // optional, Standard: active "monthlyReportsEnabled": true, // optional, Standard ist monthlyReportsDefault des Pakets "companyName": "Nordwind ApS", "emailLanguage": "en", // optional: de, en oder da; Standard: wie die Organisation "customFields": { ... } // optional } ``` Hinweise: - `packageType` kann den konfigurierten Paket-Key oder den Display-Namen des Pakets enthalten. Bekannte Alias-Schreibweisen wie `aquisition_test` werden automatisch normalisiert. - `monthlyReportsEnabled` ist optional. Ohne Angabe übernimmt der neue Kunde den Wert `monthlyReportsDefault` des zugewiesenen Pakets (siehe [Paket-Konfiguration erstellen/aktualisieren](/de/api/organization/upsert-package-config)); existiert für dieses Paket keine Konfiguration in der Organisation, gilt `true`. Ein ausdrücklich gesendeter Wert gewinnt immer, allein das Kundenfeld entscheidet, ob ein Bericht versendet wird. - `companyName` ist optional: der Firmenname des Kunden, auf der Kundenseite als „Firma“ angezeigt. Leer oder `null` leert ihn. - `emailLanguage` ist optional: `de`, `en` oder `da`, die Sprache der E-Mails und SMS an diesen Kunden (Alarme, Berichte, Statusseiten). Ohne Angabe oder mit `null` gilt die Sprache der Organisation. Jeder andere Wert wird mit `400` abgelehnt. Später änderbar über [Kunde aktualisieren](/de/api/customers/update-customer). - Wenn kein konfiguriertes Paket dazu passt, wird der Request mit `400 Bad Request` abgelehnt. - `notificationPhoneNumber` ist optional: die Nummer, an die Alarm-SMS für diesen Kunden gehen. Sie muss im internationalen Format stehen (`+` und Ländervorwahl) und aus EU/EWR, Schweiz oder Vereinigtem Königreich stammen, sonst wird der Request mit `400 Bad Request` abgelehnt (`data.code`: `smsCountryNotAllowed`). - Für normale Benutzer wird `organizationId` aus der Session/dem Token abgeleitet und darf nicht überschrieben werden. - Für Global Admins muss `organizationId` explizit angegeben werden. - Das Anlegen eines Kunden ist ein organisationsweiter Vorgang: Er erfordert einen **uneingeschränkten Kunden-Scope**, nicht nur eine Rolle. `readonly`-Benutzer, `editor`-Benutzer mit Zuweisung zu bestimmten Kunden und Customer-Scoped Tokens erhalten `403` mit `data.code: customerScopedTokenForbidden` (siehe [Rollen und der Kunden-Scope](/de/api/introduction/token-scopes-organization-vs-customer)). Organisationsweite Editoren und Admins dürfen Kunden anlegen. ## Ownership- & Berechtigungs-Overrides (optional) Diese Felder steuern die [Managed-vs.-Self-Service](/de/monitoring/managed-vs-self-service)-Berechtigungen des Kunden und die Kanal-Typ-Policy. Sie sind **org-write-gated**: Nur Organisations-Admins (oder Global-Admins) können sie setzen. Werte eines Nicht-Admin-Aufrufers werden ignoriert, es gelten die Schema-Standards. `null` (oder das Weglassen des Felds) bedeutet *von der Paket-Konfiguration des Kunden erben*. | Feld | Typ | Standard | Beschreibung | |------|-----|----------|--------------| | `allowSelfService` | boolean\|null | null (erben) | Ob der Kunde `self_service`-Monitore anlegen und verwalten darf | | `maxSelfServiceUrls` | number\|null | null (erben) | Obergrenze für die **Gesamtzahl** der `self_service`-Monitore des Kunden über alle Monitor-Typen | | `canEditManaged` | boolean | false | Ausnahme: erlaubt diesem Kunden, `managed`-Monitore zu bearbeiten (Klassen-Wechsel bleiben org-only). Vergaben werden ins Audit-Log geschrieben. | | `enableEmailAlerts` | boolean\|null | null (erben) | Ob die E-Mail-Kanäle deiner Organisation zu diesem Kunden alarmie…
### Kunden löschen
URL: https://docs.uptimeify.io/de/api/customers/delete-customer
Description: Löscht einen Kunden endgültig und deaktiviert oder löscht die Nutzer, die nur ihm zugeordnet sind.
Summary: `DELETE /api/customers/:customerPublicId` Löscht einen Kunden endgültig. Seine Monitore, die Check-Historie, Vorfälle, Reports und Screenshots werden mitgelöscht. **Das lässt sich nicht rückgängig machen.** Kunden löschen dürfen Organisations-Admins, Editoren und Global Admins. Nur-Lesen-Nutzer, Global Supporter, Responder und kundengebundene API-Tokens erhalten `403`. Ein Editor, der bestimmten Kunden zugeordnet ist, löscht nur diese Kunden (jede andere ID antwortet mit `404`); ein Editor ohne Kundenzuordnung löscht alle Kunden der Organisation. Zwei Dinge bleiben beim Admin. Nur ein Admin darf `userAction=delete` senden; ein Editor erhält `403` mit `customerUserDeleteAdminOnly` und nutzt die Voreinstellung `deactivate`. Ein Editor mit Kundenzuordnung kann seinen letzten Kunden nicht löschen: er stünde danach ohne Kunden da und würde sein eigenes Konto deaktivieren, deshalb antwortet die Anfrage mit `409` und `cannotDeleteOwnLastCustomer`. Beide Prüfungen laufen, bevor etwas gelöscht wird. ## Nutzer des Kunden Nutzer, die **nur** diesem Kunden zugeordnet sind, können ihr Konto ohne Kunden nicht behalten. Mit ihnen passiert immer eines von beiden, gewählt über den Query-Parameter `userAction`: | `userAction` | Wirkung | |--------------|---------| | `deactivate` (Standard) | Die Nutzer werden deaktiviert. Sie können Dashboard und API nicht mehr nutzen und lassen sich später mit [Benutzer aktualisieren](/de/api/users/update-user) wieder aktivieren. | | `delete` | Die Nutzer werden endgültig gelöscht. | Nutzer, die zusätzlich anderen Kunden zugeordnet sind, behalten ihr Konto und verlieren nur den Zugriff auf den gelöschten Kunden. Nutzer ohne Kunden zu behalten, ist nicht vorgesehen. ## Authentifizierung ```bash BASE_URL="https://uptimeify.io" TOKEN="wsm_" ``` ## Beispiel-Anfrage ```bash curl -X DELETE "$BASE_URL/api/customers/6bfec6f6-245a-47ce-843b-157d97d56f88?userAction=delete" \ -H "Authorization: Bearer $TOKEN" ``` ## Beispiel-Antwort ```json { "success": true, "message": "Customer deleted successfully", "userAction": "delete", "affectedUsers": 1 } ``` `affectedUsers` ist die Zahl der Nutzer, die deaktiviert oder gelöscht wurden. ## Häufige Fehler - `400 Bad Request` mit `data.code: "invalidUserAction"`, wenn `userAction` weder `deactivate` noch `delete` ist. Es wird nichts gelöscht. - `403 Forbidden` mit `data.code: "forbidden"`, wenn der Aufrufer weder Organisations-Admin noch Editor ist (Nur-Lesen, Global Supporter, Responder) oder ein kundengebundenes Token nutzt - `403 Forbidden` mit `data.code: "customerUserDeleteAdminOnly"`, wenn ein Editor `userAction=delete` sendet. Es wird nichts gelöscht. - `409 Conflict` mit `data.code: "cannotDeleteOwnLastCustomer"`, wenn ein Editor mit Kundenzuordnung damit seinen letzten Kunden löschen würde. Es wird nichts gelöscht. - `404 Not Found` mit `data.code: "customerNotFound"`, wenn der Kunde in deiner Organisation nicht existiert
### Kunden-Details abrufen
URL: https://docs.uptimeify.io/de/api/customers/get-customer-details
Description: Gibt Details eines bestimmten Kunden zurück.
Summary: `GET /api/customers/:customerPublicId` `packageDisplayName` ist das konfigurierte Anzeigename-Label des zugewiesenen Organisations-Pakets. Es ist kein global normalisierter Enum und kann deshalb organisationsspezifische Namen wie `aquisition_test` enthalten. ## Antwort (Response) ```json { "id": 101, "publicId": "6bfec6f6-245a-47ce-843b-157d97d56f88", "organizationId": 1, "name": "Kunde A GmbH", "email": "kontakt@kunde-a.de", "notificationPhoneNumber": "+491701234567", "notificationEmail": "alerts@kunde-a.de", "packageId": 3, "packageType": "growth", "packageDisplayName": "Growth", "status": "active", "customFields": { "interneReferenz": "KD-999" }, "monthlyReportsEnabled": true, "companyName": "Nordwind ApS", "emailLanguage": "en", "notificationChannels": null, "notificationTargets": null, "notificationRules": null, "smsUsageCurrentMonth": 0, "allowSelfService": null, "maxSelfServiceUrls": null, "canEditManaged": false, "enableEmailAlerts": null, "enableSmsAlerts": null, "enableWebhookAlerts": null, "enableIntegrationAlerts": null, "enablePostRequestEscalation": null, "updatedAt": "2023-05-15T10:00:00Z", "createdAt": "2023-05-15T10:00:00Z" } ``` **`packageType` und Berechtigungs-Overrides:** `packageType` ist der rohe Paket-Key des Kunden (der Wert, auf den `packageType` im Request-Body aufgelöst wird). Die Berechtigungs-Overrides (`allowSelfService`, `maxSelfServiceUrls`, `canEditManaged`, `enableEmailAlerts`, `enableSmsAlerts`, `enableWebhookAlerts`, `enableIntegrationAlerts`, `enablePostRequestEscalation`; `null` = vom Paket erben) stehen nur für Aufrufer in der Antwort, die sie auch schreiben dürfen: ein Organisations-Admin mit unbeschränktem Kundenbereich. Für einen kundengebundenen Token, jeden Nutzer ohne Admin-Rolle (`editor`, `readonly`) oder einen Global Supporter fehlen die Felder. ## Häufige Fehler - `400` Invalid Customer identifier - `401` Unauthorized - `404` Customer not found (`customerNotFound`): Den Kunden gibt es nicht, er gehört zu einer anderen Organisation oder liegt außerhalb deines Kunden-Scopes. Bis zum 20.10.2026 antwortete der letzte Fall mit `403`.
### Kunden auflisten
URL: https://docs.uptimeify.io/de/api/customers/list-customers
Description: Listet alle Kunden der Organisation auf.
Summary: `GET /api/customers` ## Query-Parameter - `organizationId` (erforderlich): Die ID der Organisation. - `fields` (optional): Auf `minimal` setzen, um eine schlanke Struktur mit ausschließlich `id`, `publicId`, `name`, `status` und `customFields` zu erhalten. Monitor-Zähler und Paketdetails entfallen, und die Antwort ist deutlich kleiner. Nützlich zum Befüllen von Auswahllisten/Dropdowns. ## Antwort (Response) Mit `fields=minimal`: ```json [ { "id": 101, "publicId": "cus_9f3a…", "name": "Kunde A GmbH", "status": "active", "customFields": { "region": "EU" } } ] ``` Standard-Antwort: ```json [ { "id": 101, "organizationId": 1, "name": "Kunde A GmbH", "email": "kontakt@kunde-a.de", "packageId": 4, "packageDisplayName": "Business", "status": "active", "cancellationDate": null, "notificationEmail": "alerts@kunde-a.de", "createdAt": "2023-05-15T10:00:00Z", "statusPageCount": 2 }, { "id": 102, "organizationId": 1, "name": "StartUp XY", "email": "info@startup-xy.com", "packageId": 1, "packageDisplayName": "Essential", "status": "marked_for_cancellation", "cancellationDate": "2024-12-31T23:59:59Z", "createdAt": "2023-06-20T14:30:00Z", "statusPageCount": 0 } ] ``` **Statusseiten:** Jeder Kunde trägt `statusPageCount`, die Zahl seiner Statusseiten, veröffentlicht oder nicht (dieselbe Zahl, gegen die das Statusseitenlimit des Pakets geprüft wird). In der geblätterten Form ist sie mit `sortBy=statusPageCount` sortierbar, und mit `summary=1` ergänzt das `summary` jeder Zeile `packageMaxStatusPages`, die Statusseiten je Kunde, die sein Paket erlaubt (`null` = unbegrenzt). **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` und wird immer geblättert: `page` ist standardmäßig 1, `perPage` 10 (höchstens 100), mit denselben Filtern und derselben Sortierung wie mit `page` (`search`, `status`, `packageTypes`, `sortBy`, `sortOrder`, `summary`); `packageOptions` entfällt. Mit `fields=minimal` kommen alle Kunden in der Kurzform als eine einzige Seite. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Hinweis: Die Listen-Response liefert absichtlich keinen rohen `packageType` mehr. Verwende `packageDisplayName` für Anzeigezwecke und `packageId` für technische Zuordnung. `packageDisplayName` stammt aus der zugewiesenen Organisations-Paketkonfiguration und kann deshalb organisationsspezifisch sein.
### SMS-Nutzung
URL: https://docs.uptimeify.io/de/api/customers/sms-usage
Description: Liefert die SMS-Nutzung des laufenden Kalendermonats über alle Kunden der Organisation hinweg, absteigend nach Nutzung sortiert.
Summary: `GET /api/customers/sms-usage` ## Query-Parameter - `organizationId` (erforderlich): Die ID der Organisation. - `envelope` (optional): `items` liefert die unten beschriebene Listenform. ## Antwort ```json { "total": 47, "smsTotalCurrentMonth": 47, "customers": [ { "publicId": "6bfec6f6-245a-47ce-843b-157d97d56f88", "name": "Kunde A GmbH", "status": "active", "smsUsageCurrentMonth": 32 }, { "publicId": "9a1c3d2e-8f4b-42a1-b7c9-3e5f12d84a90", "name": "StartUp XY", "status": "active", "smsUsageCurrentMonth": 15 }, { "publicId": "2d7e5f1a-6c3b-4d9e-a2f8-1b4c7e9d3a56", "name": "Inactive Corp", "status": "inactive", "smsUsageCurrentMonth": 0 } ] } ``` ### Felder | Feld | Typ | Beschreibung | |---|---|---| | `total` | `number` | Veraltet, entfällt am 18.01.2027: nimm `smsTotalCurrentMonth`. Gleicher Wert. | | `smsTotalCurrentMonth` | `number` | Summe von `smsUsageCurrentMonth` über alle zurückgegebenen Kunden. | | `customers[].publicId` | `string` | Kunden-UUID. | | `customers[].name` | `string` | Anzeigename des Kunden. | | `customers[].status` | `string` | Kundenstatus: `active`, `inactive`, `marked_for_cancellation` oder `cancelled`. | | `customers[].smsUsageCurrentMonth` | `number` | Anzahl der für diesen Kunden im laufenden Monat versendeten SMS. Wird zu Beginn jedes Kalendermonats zurückgesetzt. | ## Listenform (`?envelope=items`) Mit `?envelope=items` antwortet der Endpunkt in der Standard-Listenform. Ab dem 18.01.2027 ist sie der Standard; die Form oben ist veraltet. ```json { "items": [ { "publicId": "6bfec6f6-245a-47ce-843b-157d97d56f88", "name": "Customer A GmbH", "status": "active", "smsUsageCurrentMonth": 32 } ], "total": 1, "page": 1, "perPage": 1, "smsTotalCurrentMonth": 32 } ``` Hier ist `total` die Zahl der Kunden, nicht die SMS-Summe; die Summe steht in `smsTotalCurrentMonth`. Alle Kunden kommen auf einer Seite. ## Hinweise - Der Nutzungszähler `smsUsageCurrentMonth` wird zu Beginn jedes Kalendermonats zurückgesetzt. - Kunden ohne Nutzung sind in der Antwort enthalten. - Die Sortierung erfolgt absteigend nach `smsUsageCurrentMonth` (höchste Nutzung zuerst). - Das vollständige SMS-Kontingent und die Überschreitungen der gesamten Organisation stehen in der Abrechnungsübersicht. ## Häufige Fehler - `400` Organization ID required - `401` Unauthorized - `403` Forbidden
### Kunden aktualisieren
URL: https://docs.uptimeify.io/de/api/customers/update-customer
Description: Aktualisiert Kundendetails.
Summary: `PATCH /api/customers/:customerPublicId` ## Authentifizierung ```bash BASE_URL="https://uptimeify.io" TOKEN="" ``` ## Anfrage (Request Body) Alle Felder sind optional. Nicht gesendete Felder behalten ihren aktuellen Wert. ```json { "name": "Neuer Name", "email": "neu@deinkunde.com", "status": "active", "packageType": "business", // konfigurierter packageType oder Display-Name der Organisation "notificationEmail": "alerts@customer-a.de", "notificationPhoneNumber": "+491701234567", "monthlyReportsEnabled": true, "companyName": "Nordwind ApS", "emailLanguage": "en", "customFields": { "internalReference": "KD-999" } } ``` Hinweise: - `packageType` kann den konfigurierten Paket-Key oder den Display-Namen des Pakets enthalten. Bekannte Alias-Schreibweisen wie `aquisition_test` werden automatisch normalisiert. Ein Wert, der auf kein Paket dieser Organisation passt, wird mit `400` und `data.code` `invalidPackageType` abgewiesen; er wird nicht mehr unverändert gespeichert. - `companyName` ist optional: der Firmenname des Kunden, auf der Kundenseite als „Firma“ angezeigt. Leer oder `null` leert ihn. - `emailLanguage` legt die Sprache der E-Mails fest, die dieser Kunde bekommt (Alarme, Berichte, Statusseiten): `de`, `en` oder `da`. `null` setzt sie auf die Sprache der Organisation zurück. Dieselbe Sprache gilt für SMS an diesen Kunden. Jeder andere Wert wird mit `400` abgelehnt. ## Ownership- & Berechtigungs-Overrides (optional) Diese Felder steuern die [Managed-vs.-Self-Service](/de/monitoring/managed-vs-self-service)-Berechtigungen des Kunden und die Kanal-Typ-Policy. Sie sind **org-write-gated**: Schreibzugriffe eines kunden-gescopten Aufrufers auf diese Felder werden serverseitig stillschweigend ignoriert. `null` bedeutet *von der Paket-Konfiguration des Kunden erben*. | Feld | Typ | Standard | Beschreibung | |------|-----|----------|--------------| | `allowSelfService` | boolean\|null | null (erben) | Ob der Kunde `self_service`-Monitore anlegen und verwalten darf | | `maxSelfServiceUrls` | number\|null | null (erben) | Obergrenze für die **Gesamtzahl** der `self_service`-Monitore des Kunden über alle Monitor-Typen | | `canEditManaged` | boolean | false | Ausnahme: erlaubt diesem Kunden, `managed`-Monitore zu bearbeiten (Klassen-Wechsel bleiben org-only). Änderungen werden ins Audit-Log geschrieben. | | `enableEmailAlerts` | boolean\|null | null (erben) | Ob die E-Mail-Kanäle deiner Organisation zu diesem Kunden alarmieren (null = wie das Paket). Kanäle, die der Kunde selbst anlegt, bleiben immer unberührt | | `enableSmsAlerts` | boolean\|null | null (erben) | Ob die SMS-Kanäle deiner Organisation zu diesem Kunden alarmieren (null = wie das Paket). Kanäle, die der Kunde selbst anlegt, bleiben immer unberührt | | `enableWebhookAlerts` | boolean\|null | null (erben) | Ob die Webhooks-Kanäle deiner Organisation zu diesem Kunden alarmieren (null = wie das Paket). Kanäle, die der Kunde selbst anlegt, bleiben immer unberührt | | `enableIntegrationAlerts` | boolean\|null | null (erben) | Ob die Integrationen-Kanäle deiner Organisation zu diesem Kunden alarmieren (null = wie das Paket). Kanäle, die der Kunde selbst anlegt, bleiben immer unberührt | | `enablePostRequestEscalation` | boolean\|null | null (erben) | Kanal-Typ-Policy-Override: POST-Request-Eskalation | Der Legacy-`notificationChannels`-JSONB-Override ist deprecated: Die Kanal-Typ-Policy liegt in den `enable*`-Feldern oben. ## Beispiel-Request ```bash curl -X PATCH "$BASE_URL/api/customers/6bfec6f6-245a-47ce-843b-157d97d56f88" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "Customer A GmbH (Updated)", "monthlyReportsEnabled": true }' ``` ## Beispiel-Response ```json { "id": 101, "publicId": "6bfec6f6-245a-47ce-843b-157d97d56f88", "organizationId": 1, "name": "Customer A GmbH (Updated)", "email": "contact@customer-a.de", "notificationPhoneNumber": "+491701234567", "notificationEmail": "alerts@customer-a.de", "packageId": 3…
### Dependency-Anbieter abfragen
URL: https://docs.uptimeify.io/de/api/dependencies/get-dependency
Description: Öffentliche Detailansicht ohne Anmeldung zu einem verfolgten Drittanbieter: aktueller Status, Komponenten mit 90-Tage-Verlauf und erfasste Vorfälle.
Summary: `GET /api/public/dependencies/:slug` Keine Authentifizierung nötig. `:slug` ist der `slug` aus [Dependency-Anbieter auflisten](/de/api/dependencies/list-dependencies). Enthält keine Kundendaten. ## Query-Parameter | Parameter | Typ | Standard | Beschreibung | | --- | --- | --- | --- | | `incidentPage` | Ganzzahl, 1 bis 100000 | `1` | Seite von `incidents`, 10 je Seite | ## Beispiel (cURL) ```bash curl -X GET "https://uptimeify.io/api/public/dependencies/bunny?incidentPage=1" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "provider": { "slug": "bunny", "name": "bunny.net", "vendor": "BunnyWay d.o.o.", "homepageUrl": "https://bunny.net", "statusPageUrl": "https://status.bunny.net", "logoUrl": "/img/dependency/bunny.png", "category": "CDN", "status": "operational", "staleness": "fresh", "since": "2026-10-06T09:14:02.000Z", "monitoringSince": "2026-08-20T12:00:00.000Z", "lastCheckedAt": "2026-10-08T15:02:11.000Z", "incidentCount": 14, "statusDerived": false, "noOverallStatus": false }, "components": [ { "id": 812, "name": "CDN", "status": "operational", "statusAsOf": "2026-10-08T15:02:11.000Z", "history": [ { "date": "2026-10-07", "status": "operational", "hasData": true }, { "date": "2026-10-08", "status": "degraded", "hasData": true } ] } ], "incidents": [ { "id": 3051, "title": "Elevated latency in Frankfurt", "titleDe": "Erhöhte Latenz in Frankfurt", "status": "resolved", "impact": "minor", "startedAt": "2026-10-08T07:40:00.000Z", "resolvedAt": "2026-10-08T08:15:00.000Z", "resolutionInferred": false, "scheduledFor": null, "scheduledUntil": null, "affectedComponentCount": 1, "affectedComponentNames": ["CDN"], "shortlink": "https://stspg.io/abc123", "updates": [ { "status": "investigating", "at": "2026-10-08T07:41:00.000Z" }, { "status": "resolved", "at": "2026-10-08T08:15:00.000Z" } ] } ], "incidentsPagination": { "page": 1, "limit": 10, "total": 14, "totalPages": 2 }, "historyIncidents": [ { "startedAt": "2026-10-08T07:40:00.000Z", "resolvedAt": "2026-10-08T08:15:00.000Z", "affectedComponentNames": ["CDN"] } ], "relatedProviders": [ { "slug": "cloudflare", "name": "Cloudflare", "category": "CDN", "logoUrl": "/img/dependency/cloudflare.png", "status": "operational", "sameCategory": true } ], "reportCount": 0, "reportToken": "…" } ``` Hinweise: - `provider.status`, `staleness`, `statusDerived` und `noOverallStatus` bedeuten dasselbe wie in der Liste. - `components[].history` umfasst die letzten 90 Tage in UTC, ein Eintrag pro Tag; `hasData: false` (mit `status: null`) markiert einen Tag ohne Messwert. `components[].status` ist `unknown` mit `statusAsOf: null`, wenn unser letzter Messwert älter als zwei Stunden ist. - `incidents` ist eine Seite der Vorfälle, neueste zuerst; `incidentsPagination` nennt die Zahl der Seiten. `historyIncidents` enthält bis zu 50 jüngere Vorfälle für die 90-Tage-Balken und ist nicht seitenweise. - `resolutionInferred: true` heißt: Der Anbieter hat keine Entwarnung veröffentlicht, wir haben den Vorfall geschlossen, als sich seine Komponenten erholt hatten. - `relatedProviders` listet bis zu 6 weitere aktive Anbieter; `sameCategory` kennzeichnet die aus derselben Kategorie. - `reportCount` ist die Zahl jüngerer Nutzermeldungen, `0` unterhalb der Veröffentlichungsschwelle. `reportToken` gehört zum Meldeformular der Webseite und ist nicht für die API gedacht. - Antworten zu aktiven Anbietern tragen `Cache-Control: public, max-age=30`. ## Häufige Fehler - `404 Provider not found` (`data.code: providerNotFound`), wenn der Slug nicht existiert oder der Anbieter nicht aktiv ist - `400` (`data.code: invalidIncidentPage`), wenn `incidentPage` keine Ganzzahl von 1 bis 100000 ist - `500 Unexpected server error` bei einem internen Fehler
### Dependency-Anbieter auflisten
URL: https://docs.uptimeify.io/de/api/dependencies/list-dependencies
Description: Öffentliche Liste ohne Anmeldung: alle Drittanbieter, deren Status Uptimeify verfolgt, jeweils mit dem aktuellen Gesamtstatus.
Summary: `GET /api/public/dependencies` Keine Authentifizierung nötig. Liefert alle aktiven Anbieter auf der Seite [Dependency Monitoring](https://uptimeify.io/de/dependency), alphabetisch nach Name. Enthält keine Kundendaten, nur das, was wir auf der öffentlichen Statusseite des jeweiligen Anbieters beobachten. ## Query-Parameter | Parameter | Typ | Standard | Beschreibung | |---|---|---|---| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash curl -X GET "https://uptimeify.io/api/public/dependencies?envelope=items" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "items": [ { "slug": "bunny", "name": "bunny.net", "vendor": "BunnyWay d.o.o.", "category": "CDN", "logoUrl": "/img/dependency/bunny.png", "status": "operational", "staleness": "fresh", "since": "2026-10-06T09:14:02.000Z", "statusDerived": false, "noOverallStatus": false } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Einträge); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Hinweise: - `status` ist einer von `operational`, `maintenance`, `degraded`, `partial_outage`, `major_outage`, `unknown`. Ein Anbieter, den wir noch nie geprüft haben oder nicht mehr lesen können, erscheint als `unknown` und fällt nicht weg. - `staleness` ist `fresh`, `stale` oder `unknown`: ob der aktuelle `status` auf einem frischen, erfolgreichen Abruf der Statusseite beruht. - `since` ist der Beginn des aktuellen `status` (ISO 8601), `null`, solange er nicht bekannt ist. - `statusDerived` ist `true`, wenn der Anbieter keinen Gesamtstatus veröffentlicht und wir ihn aus den Komponenten ableiten; `noOverallStatus` ist `true`, wenn beides nicht geht und nur Komponenten angezeigt werden. - `logoUrl` ist ein Pfad auf `uptimeify.io` oder unserem CDN, oder `null`. - Ein leeres Array ist eine gültige Antwort: Die Liste enthält nur aktive Anbieter. ## Häufige Fehler - `500 Unexpected server error` bei einem internen Fehler
### Fehlerliste und bekannte API-Fallen
URL: https://docs.uptimeify.io/de/api/error-codes-and-known-pitfalls
Description: Diese Seite dokumentiert reale Fehlerbilder, die bei Integrationen aufgetreten sind.
Summary: ## Schema | Error Code | Grund | Lösung / Bug | | --- | --- | --- | | `404 Website not found` | Einige Website-Unterendpunkte haben früher nur die alte numerische Website-ID akzeptiert, obwohl die Docs `websitePublicId` gezeigt haben. | Behoben. `GET /api/websites/:websitePublicId/check-history` und `GET /api/websites/:websitePublicId/uptime-stats` akzeptieren jetzt Public IDs und weiterhin Legacy-IDs. | | `403 Forbidden` auf `GET /api/organizations/:organizationPublicId` | Die Route hat die Pfad-ID früher direkt als Zahl interpretiert. Eine UUID wurde dadurch schon in der Berechtigungsprüfung verworfen. | Behoben. Die Organisations-Detail- und Billing-Routen lösen jetzt `publicId` korrekt auf. | | `400 Bad Request` mit `ZodError` bei `customer-ips` oder `customer-domains` | Query-Parameter wie `organizationId=`, `page=` oder `perPage=` wurden als leere Strings gesendet. Zod coerct leere Strings zu `0`, was dann an den Mindestwerten scheitert. | Behoben für `organizationId`, `page` und `perPage`. Optional bedeutet trotzdem: ungenutzte Parameter komplett weglassen statt leere Strings zu senden. | ## Betroffene Fälle ### Website not found bei Website-Monitoring-Endpunkten Betroffene Endpunkte: - `GET /api/websites/:websitePublicId/check-history` - `GET /api/websites/:websitePublicId/uptime-stats` Früherer Effekt: ```json { "error": true, "statusCode": 404, "statusMessage": "Website not found", "message": "Website not found" } ``` Grund: - Die Route hat nur die alte numerische `id` direkt geparsed. - Eine UUID wurde nicht in die interne numerische ID aufgelöst. Aktueller Stand: - Public IDs funktionieren jetzt wie in der Doku beschrieben. - Legacy-Integer-IDs bleiben aus Kompatibilitätsgründen gültig. ### Forbidden bei Organisations-Details mit Public ID Betroffener Endpoint: - `GET /api/organizations/:organizationPublicId` Grund: - Die Berechtigungsprüfung lief früher gegen `Number(id)`. - Bei einer UUID wurde daraus `NaN`, was zu `403 Forbidden` führte. Aktueller Stand: - Die Route und die Billing-Routen lösen `organizationPublicId` jetzt korrekt in die interne ID auf. ### ZodError bei optionalen Listen-Parametern Betroffene Endpunkte: - `GET /api/customer-ips` - `GET /api/customer-domains` Typisches Muster: ```json { "error": true, "statusCode": 400, "statusMessage": "Bad Request" } ``` Grund: - Nicht das Weglassen der Parameter war das Problem. - Das Problem waren leere Query-Werte wie `?page=&perPage=`. Lösung: - Unbenutzte optionale Parameter weglassen. - Die API ignoriert für diese Felder jetzt leere Strings robuster. ## Monitor-Ownership-Fehlercodes Seit dem [Managed-vs.-Self-Service](/de/monitoring/managed-vs-self-service)-Modell können Monitor-Schreib-Endpunkte **aller** Typen (Website, DNS, ICMP, SMTP, SSH, FTP, IMAP/POP, Domain, DNSBL) diese `403`-Codes in `data.code` liefern: | Code | Bedeutung | | --- | --- | | `managed_by_organization` | Ein kunden-gescopter Aufrufer wollte einen `managed`-Monitor ohne die `canEditManaged`-Ausnahme bearbeiten/löschen. Stattdessen einen [Change Request](/de/api/change-requests) eröffnen. Gilt auch für eine `managed`-Statusseite und was an ihr hängt (Einstellungen, Komponenten, Gruppen, Domain, Abonnenten, Vorfälle und Wartungen auf der Seite), für kundengebundene Nutzer mit jeder Rolle (auch `readonly` und `editor`) und kundengebundene Tokens; stattdessen mit [Änderungsanfrage zu einer Statusseite anlegen](/de/api/change-requests/create-status-page-change-request) fragen. | | `selfServiceNotAllowed` | Ein kunden-gescopter Aufrufer wollte einen Monitor anlegen, aber das aufgelöste `allowSelfService` des Kunden ist false. | | `selfServiceQuotaReached` | Das Anlegen (oder Umstellen auf) eines `self_service`-Monitors würde `maxSelfServiceUrls` des Kunden überschreiten: das Kontingent zählt **alle** Monitor-Typen zusammen. | | `managementTypeOrgOnly` | Ein Nicht-Org-Admin wollte den `managementType` eines Monitors ändern. Klassen-Wechsel sind Organisations-Admins vorbehalten, und seit de…
### Eskalations-Konfiguration
URL: https://docs.uptimeify.io/de/api/escalation
Description: Verwalte die Webhook-Eskalationseinstellungen auf Organisationsebene sowie die Standard-Benachrichtigungskanäle.
Summary: Die Eskalations-Konfiguration wird beim ersten Zugriff automatisch mit sinnvollen Standardwerten angelegt. ## Authentifizierung Alle Endpunkte akzeptieren entweder Session-Cookies oder API-Bearer-Tokens: ```bash BASE_URL="https://uptimeify.io" TOKEN="" ``` ## Variablen für die Standard-Webhook-Body-Vorlage | Variable | Beschreibung | |----------|-------------| | `{{websiteName}}` | Name der betroffenen Website | | `{{websiteUrl}}` | URL der betroffenen Website | | `{{status}}` | Aktueller Status (z. B. `down`, `up`) | | `{{startedAt}}` | Zeitstempel des Vorfallbeginns | | `{{incident}}` | Objekt mit den Vorfalldetails | | `{{errorMessage}}` | Fehlermeldung, falls verfügbar | ## Endpunkte - [Eskalations-Konfiguration abrufen](/de/api/escalation/get-escalation-config) - [Eskalations-Konfiguration aktualisieren](/de/api/escalation/update-escalation-config) - [Eskalations-Konfiguration testen](/de/api/escalation/test-escalation-config)
### Eskalations-Konfiguration abrufen
URL: https://docs.uptimeify.io/de/api/escalation/get-escalation-config
Description: Gibt die Eskalations-Konfiguration einer Organisation zurück. Der Parameter :id ist die Organisations-ID. Ist noch keine Konfiguration gespeichert, kommen die inaktiven Standardwerte zurück (`id`, `createdAt` und `updatedAt` sind `null`), angelegt wird nichts; der erste PATCH speichert sie.
Summary: `GET /api/escalation-config/:id` Gibt außerdem die Standard-Benachrichtigungseinstellungen der Organisation sowie alle Benachrichtigungskanäle zurück. Header-Werte kommen nie zurück: `webhookHeaders` enthält die Header-Namen mit `null` als Wert, und `hasWebhookHeaders` sagt, ob Header gespeichert sind. Dasselbe gilt für `config.headers` der Kanäle in `notificationChannels` (Namen mit `null`, dazu `hasHeaders`). Gespeichert werden Header-Werte verschlüsselt. ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/escalation-config/1" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "id": 1, "organizationId": 1, "webhookUrl": "https://deinkunde.com/webhook", "webhookMethod": "POST", "webhookHeaders": { "Content-Type": null }, "hasWebhookHeaders": true, "webhookBodyTemplate": "{\"websiteName\":\"{{websiteName}}\",...}", "webhookTimeout": 30, "webhookRetryAttempts": 3, "webhookRetryDelay": 60, "expectedStatusCodes": "200,201,202,204", "isActive": false, "lastTestedAt": null, "lastTestStatus": null, "lastTestError": null, "organization": { "defaultEmail": "ops@deinkunde.com", "defaultPhoneNumber": "+1234567890", "defaultNotificationChannels": null, "defaultNotificationTargets": null, "defaultNotificationRules": null }, "notificationChannels": [] } ``` ## Häufige Fehler - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden`, wenn du nicht Organisations-Admin mit unbeschränktem Umfang bist (`forbidden`, bzw. `customerScopedTokenForbidden` für ein kundengebundenes Token oder einen Kunden-Login). Die Antwort enthält Webhook-URL, -Header und -Vorlage, deshalb reicht Leserecht nicht.
### Eskalations-Konfiguration testen
URL: https://docs.uptimeify.io/de/api/escalation/test-escalation-config
Description: Testet die Eskalations-Konfiguration, indem ein Test-Webhook, ein PagerDuty-Event oder eine Pushover-Benachrichtigung gesendet wird. Alle Body-Felder sind optional und überschreiben für den Test die in der DB gespeicherten Werte.
Summary: `POST /api/escalation-config/:id/test` ## Anfrage (Request Body) (alle optional) | Feld | Typ | Beschreibung | |-------|------|-------------| | `type` | string | `pagerduty` oder `pushover` für dedizierte Handler | | `config` | object | PagerDuty-Konfiguration `{routingKey}` oder Pushover-Konfiguration `{userKey, apiToken}` | | `webhookUrl` | string | Überschreibt die Webhook-URL für den Test | | `webhookMethod` | string | Überschreibt die Webhook-Methode | | `webhookHeaders` | object | Überschreibt die Webhook-Header. Dieselbe Sperrliste wie beim PATCH: `Host` antwortet `400` `webhookHostHeaderForbidden`; `Authorization`, `Cookie`, `X-Forwarded-*` und `Proxy-*` antworten `400` `invalidRequestBody`. | | `webhookBodyTemplate` | string | Überschreibt die Webhook-Body-Vorlage | | `webhookTimeout` | number | Überschreibt das Webhook-Timeout | | `expectedStatusCodes` | string | Überschreibt die erwarteten Statuscodes | ## Beispiel (cURL): Webhook-Test ```bash curl -X POST "$BASE_URL/api/escalation-config/1/test" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "webhookUrl": "https://httpbin.org/post", "webhookMethod": "POST", "webhookTimeout": 15 }' ``` ## Beispiel (cURL): PagerDuty-Test ```bash curl -X POST "$BASE_URL/api/escalation-config/1/test" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "type": "pagerduty", "config": { "routingKey": "your-routing-key-here" } }' ``` ## Antwort (Response) (Webhook) ```json { "success": true, "statusCode": 200, "message": "Webhook delivered successfully" } ``` ## Antwort (Response) (PagerDuty) ```json { "success": true, "message": "PagerDuty event enqueued successfully" } ``` ## Häufige Fehler - `401 Unauthorized` wenn du nicht angemeldet bist - `400` (`organizationIdRequired`), wenn die Organisations-ID fehlt oder keine positive Ganzzahl ist. Seit dem 20.10.2026 erst nach der Anmeldung geprüft; vorher kam `400` auch ohne Sitzung. - `403 Forbidden` (`forbidden`), wenn du nicht Organisations-Admin bist, oder (`customerScopedTokenForbidden`), wenn dein Umfang auf Kunden beschränkt ist. Der zweite Fall ist seit dem 20.10.2026 neu, wie bei `GET` und `PATCH`.
### Eskalations-Konfiguration aktualisieren
URL: https://docs.uptimeify.io/de/api/escalation/update-escalation-config
Description: Aktualisiert die Eskalations-Konfiguration. Der Parameter :id ist die Organisations-ID. Falls noch keine Konfiguration existiert, wird per Upsert eine angelegt.
Summary: `PATCH /api/escalation-config/:id` ## Anfrage (Request Body) (alle optional) | Feld | Typ | Beschreibung | |-------|------|-------------| | `webhookUrl` | string\|null | Webhook-URL. Auf `null` setzen, um den Webhook-Kanal zu deaktivieren. | | `webhookMethod` | string | HTTP-Methode: `POST`, `PUT` oder `PATCH` | | `webhookHeaders` | object\|string | JSON-Header-Objekt. Ersetzt die gespeicherten Header; ein Header mit dem Wert `null` oder `""` behält seinen gespeicherten Wert. Die Antwort enthält wie der GET nur die Namen. | | `webhookBodyTemplate` | string | JSON-Body-Vorlage mit `{{variables}}` | | `webhookTimeout` | integer | Timeout in Sekunden | | `webhookRetryAttempts` | integer | Anzahl der Wiederholungsversuche | | `webhookRetryDelay` | integer | Sekunden zwischen den Wiederholungsversuchen | | `expectedStatusCodes` | string | Kommagetrennte erwartete Statuscodes | | `isActive` | boolean | Aktiviert oder deaktiviert den Webhook. `false` deaktiviert nur den Webhook-Kanal der Organisation (ohne `websiteId`, ohne Kunde); kundengebundene Webhook-Kanäle bleiben aktiv. | | `defaultEmail` | string | **Nebeneffekt:** legt einen E-Mail-Benachrichtigungskanal auf Organisationsebene an oder aktualisiert ihn | | `defaultPhoneNumber` | string | **Nebeneffekt:** legt einen SMS-Benachrichtigungskanal auf Organisationsebene an oder aktualisiert ihn | ## Beispiel (cURL) ```bash curl -X PATCH "$BASE_URL/api/escalation-config/1" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "webhookUrl": "https://deinkunde.com/webhook", "webhookMethod": "POST", "webhookHeaders": { "Content-Type": "application/json" }, "webhookTimeout": 30, "webhookRetryAttempts": 3, "isActive": true, "defaultEmail": "alerts@deinkunde.com" }' ``` ## Häufige Fehler - `400 Bad Request` mit `data.code` `smsCountryNotAllowed`, wenn `defaultPhoneNumber` nicht im internationalen Format steht (`+` und Ländervorwahl) oder nicht aus EU/EWR, Schweiz oder Vereinigtem Königreich stammt - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keine ausreichenden Berechtigungen hast ## Antwort (Response) Gibt das aktualisierte Objekt der Eskalations-Konfiguration zurück. Siehe [Error Codes](/de/api/error-codes-and-known-pitfalls) für Fehler-Antworten.
### Beispiele
URL: https://docs.uptimeify.io/de/api/examples
Description: Hier findest du Schritt-für-Schritt Beispiele für häufige API-Workflows.
Summary: - [Kunde + Website erstellen](/de/api/examples/create-customer-and-website) - [Kunde inkl. aller Websites löschen](/de/api/examples/delete-customer-and-all-websites) - [Kunde + alle Monitore anlegen](/de/api/examples/create-customer-and-all-monitors) - [Kunde + mehrere Monitore anlegen](/de/api/examples/create-customer-and-multiple-monitors)
### Kunde + alle Monitore anlegen
URL: https://docs.uptimeify.io/de/api/examples/create-customer-and-all-monitors
Description: Dieses Beispiel ist praktisch, wenn du einen Kunden mit einem kompletten Monitoring-Baseline-Setup initialisieren möchtest.
Summary: High-level Flow: 1. Kunde erstellen 2. Website erstellen 3. Monitore anlegen (je Monitor-Typ einen) ## 1) Kunde + Website erstellen Nutze dafür: - [Kunde + Website erstellen](/de/api/examples/create-customer-and-website) ## 2) Monitore anlegen (je Typ einen) Die Monitor-APIs sind nach Typ organisiert. API-Referenz-Übersicht: - [Monitore API](/de/api/monitors) Typische Monitor-Typen: - DNS Monitor - ICMP Monitor - SMTP Monitor - SSH Monitor - TCP-Port-Monitor - FTP Monitor - IMAP/POP Monitor Die genauen Pflichtfelder findest du in der jeweiligen API-Doku pro Typ. ### Beispiel: DNS Monitor erstellen ```bash curl -X POST "$API_BASE_URL/api/dns-monitors" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "customerId": 123, "name": "DNS: deinkunde.com", "hostname": "deinkunde.com", "dnsConfig": { "rrtypes": ["A", "AAAA"], "matchMode": "exact", "expectedValues": { "A": ["93.184.216.34"], "AAAA": ["2606:2800:220:1:248:1893:25c8:1946"] } } }' ``` ### Beispiel: ICMP Monitor erstellen ```bash curl -X POST "$API_BASE_URL/api/icmp-monitors" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "customerId": 123, "name": "Ping: gateway", "hostname": "gateway.deinkunde.com" }' ``` ### Beispiel: TCP-Port-Monitor erstellen ```bash curl -X POST "$API_BASE_URL/api/tcp-monitors" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "customerId": 123, "name": "Redis Primary", "hostname": "redis.deinkunde.com", "port": 6379, "config": { "expectBanner": "+PONG" } }' ``` ## Hinweise - Nicht jede Installation bietet jeden Monitor-Typ an, und Pflichtfelder können je nach Plan/Paket variieren. - Für Website/HTTP Checks startest du meist in den Website-spezifischen Einstellungen: [Website-Konfiguration API](/de/api/website-configuration)
### Kunde + mehrere Monitore anlegen
URL: https://docs.uptimeify.io/de/api/examples/create-customer-and-multiple-monitors
Description: Dieses Beispiel zeigt, wie du für einen Kunden mehrere Monitore einrichtest, z.B.:
Summary: - Zwei unterschiedliche Hostnamen für DNS Monitoring - Mehrere Server für ICMP - Eine Mischung aus DNS + ICMP + SMTP ## 1) Kunde + Website erstellen - [Kunde + Website erstellen](/de/api/examples/create-customer-and-website) ## 2) Mehrere Monitore anlegen ### Option A: Mehrere Monitore vom selben Typ (DNS) ```bash # DNS Monitor 1 curl -X POST "$API_BASE_URL/api/dns-monitors" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "customerId": 123, "name": "DNS: app.deinkunde.com", "hostname": "app.deinkunde.com", "dnsConfig": { "rrtypes": ["A"], "matchMode": "exact", "expectedValues": { "A": ["93.184.216.34"] } } }' # DNS Monitor 2 curl -X POST "$API_BASE_URL/api/dns-monitors" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "customerId": 123, "name": "DNS: mail.deinkunde.com", "hostname": "mail.deinkunde.com", "dnsConfig": { "rrtypes": ["MX", "TXT"], "matchMode": "contains", "expectedValues": { "MX": ["10 mail.deinkunde.com"], "TXT": ["v=spf1 include:_spf.deinkunde.com ~all"] } } }' ``` ### Option B: Gemischte Monitor-Typen ```bash # ICMP curl -X POST "$API_BASE_URL/api/icmp-monitors" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "customerId": 123, "name": "Ping: edge-1", "hostname": "edge-1.deinkunde.com" }' # SMTP curl -X POST "$API_BASE_URL/api/smtp-monitors" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "customerId": 123, "name": "SMTP: outbound", "hostname": "smtp.deinkunde.com", "port": 587 }' ``` ## Tipps - Nutze konsistente Namen (Prefix nach Typ: `DNS:`, `Ping:`, `SMTP:`). - Starte mit konservativen Intervallen und verschärfe später. ## Referenz - [Monitoring-Typen](/monitoring/monitoring-types/uptime) - [Monitore API](/de/api/monitors)
### Kunde + Website erstellen
URL: https://docs.uptimeify.io/de/api/examples/create-customer-and-website
Description: Dieses Beispiel zeigt einen typischen Onboarding-Flow:
Summary: 1. **Kunde** anlegen 2. Eine **Website** für diesen Kunden anlegen 3. (Optional) Monitoring-Konfiguration ergänzen > Wenn du lieber das UI nutzt: Kunden und Websites kannst du im Admin-Bereich anlegen. Die API ist ideal für Automatisierung und Bulk-Setups. ## Voräussetzungen - API Token mit den benötigten Scopes - Deine API Base URL (z.B. `https://your-instance.tld`) Siehe zuerst die API-Einführung: - [API Einführung](/de/api/introduction) ## 1) Kunde erstellen API Referenz: - [Kunden API](/de/api/customers) Beispiel (Pseudo-Request): ```bash curl -X POST "$API_BASE_URL/api/customers" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "Acme GmbH", "email": "ops@deinkunde.com" }' ``` Speichere die zurückgegebene `customerId`. ## 2) Website für den Kunden erstellen API Referenz: - [Websites API](/de/api/websites) ```bash curl -X POST "$API_BASE_URL/api/websites" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "customerId": 123, "name": "Acme Marketing Website", "url": "https://deinkunde.com" }' ``` Wichtig: - `url` muss das Protokoll enthalten (`https://...`). ## 3) Website prüfen API Referenz: - [Website abfragen](/de/api/websites/get-website) ```bash curl -X GET "$API_BASE_URL/api/websites/456" \ -H "Authorization: Bearer $TOKEN" ``` ## Nächste Schritte - Website-spezifische Monitoring-/Alert-Einstellungen: [Website-Konfiguration API](/de/api/website-configuration) - Überblick über alle Monitor-Arten: [Monitoring-Typen](/monitoring/monitoring-types/uptime)
### Kunde inkl. aller Websites löschen
URL: https://docs.uptimeify.io/de/api/examples/delete-customer-and-all-websites
Description: Dieses Beispiel beschreibt einen sicheren, expliziten Lösch-Flow.
Summary: Je nach Konfiguration kann das Löschen eines Kunden Websites automatisch mitlöschen, oder auch nicht. Um Überraschungen zu vermeiden, empfehlen wir, Websites zuerst explizit zu löschen. ## Voräussetzungen - API Token mit den benötigten Scopes ## 1) Websites des Kunden auflisten API Referenz: - [Websites auflisten](/de/api/websites/list-websites) Pseudo-Request: ```bash curl -X GET "$API_BASE_URL/api/websites?customerId=123" \ -H "Authorization: Bearer $TOKEN" ``` Sammle alle Website-IDs. ## 2) Jede Website löschen API Referenz: - [Website löschen](/de/api/websites/delete-website) ```bash curl -X DELETE "$API_BASE_URL/api/websites/456" \ -H "Authorization: Bearer $TOKEN" ``` Wiederhole das für alle Websites dieses Kunden. ## 3) Kunden löschen API Referenz: - [Kunden API](/de/api/customers) ```bash curl -X DELETE "$API_BASE_URL/api/customers/123" \ -H "Authorization: Bearer $TOKEN" ``` ## Hinweise - Falls euer Backend Cascade Deletes unterstützt, ist Schritt 2 evtl. optional. Explizit bleibt Automatisierung aber vorhersehbar.
### Incident Management
URL: https://docs.uptimeify.io/de/api/incident-management
Description: Öffentliche REST-API für Uptimeify Incident Management (IM): Alerts aus eigenen Monitoring-Systemen einspeisen und Incidents programmatisch verwalten.
Summary: Incident Management (IM) ist eine von Monitoring getrennte Domäne: ein zweistufiges Alert-/Incident-Modell mit Teams, On-Call-Zeitplänen und Eskalations-Tiers. Dieser Abschnitt beschreibt die öffentlichen REST-Endpunkte zum Einspeisen von Alerts und zum programmatischen Verwalten von Incidents. ## Authentifizierung Fast jeder der folgenden Endpunkte akzeptiert einen **organisationsweiten** API-Token. Drei Ausnahmen: [Mein Bereitschaftsstatus](/de/api/incident-management/my-on-call), die [persönlichen Benachrichtigungseinstellungen](/de/api/incident-management/notification-settings) und der [Test-Alarm](/de/api/incident-management/setup) der Einrichtung beschreiben eine Person und brauchen eine Benutzersitzung; der [Ingest-Webhook](/de/api/incident-management/ingest-webhook) authentifiziert sich stattdessen über den Token in seiner URL. Mit einem API-Token: ```bash BASE_URL="https://uptimeify.io" TOKEN="wsm_" ``` Erstelle einen über [Organisations-Token erstellen](/de/api/api-tokens/create-organization-token) und lasse `customerId` dabei weg. Ein Token, der **mit** einer `customerId` erstellt wurde (ein kunden-gescopter Token), wird auf jedem IM-Pfad mit `403 Forbidden` (`customerScopedTokenForbidden`) abgelehnt; Incident Management hat bewusst keine kundenseitige Oberfläche. Incident Management muss außerdem für deine Organisation **aktiviert** sein, sonst liefert jeder der folgenden Endpunkte `403 Forbidden` (`imNotEnabled`). Ein organisationsweiter Token handelt mit der **aktuellen Rolle der Person, die ihn erstellt hat**, gelesen bei jeder Anfrage. Organisations-Token können nur Organisations-Admins erstellen, ein Token handelt also normalerweise als `admin` und besteht jede Team-Prüfung in diesem Abschnitt (etwa „Mitglied im Team des Incidents"). Wird die Person später zu `editor` oder `responder` herabgestuft, behält der Token deren Zugriff und verliert die Admin-Schreibrechte. Wird sie `readonly`, deaktiviert oder gelöscht, verliert der Token den Zugang zu Incident Management ganz (`403` `imAccessDenied`). Ein Token ist keine Person. Änderungen über ihn werden ohne Person vermerkt: `createdBy`, `acknowledgedBy` und `resolvedBy` am Incident sowie `actorUserId` an seinen Timeline-Events bleiben `null`, wie bei einem Systemereignis. ## Endpunkte ### Einstieg - [Incident Management aktivieren](/de/api/incident-management/activate): `POST /api/im/activate` - [Einrichtungsstand und Test-Alarm](/de/api/incident-management/setup): `GET/PATCH /api/im/setup/state`, `POST /api/im/setup/test-page` ### Alerts und Bereitschaft - [Events Ingest](/de/api/incident-management/events-ingest): `POST /api/im/events` - [Ingest-Webhook](/de/api/incident-management/ingest-webhook): `POST /api/im/ingest/:token` - [Wer hat Bereitschaft](/de/api/incident-management/on-call): `GET /api/im/on-call` - [Mein Bereitschaftsstatus](/de/api/incident-management/my-on-call): `GET /api/im/me/on-call`, `GET /api/im/me/on-call-stats` - [Persönliche Benachrichtigungseinstellungen](/de/api/incident-management/notification-settings): `/api/im/notification-settings/**` - [Benachrichtigungen einer Person](/de/api/incident-management/user-notification-settings): `/api/im/users/:userId/notification-settings` (Admin) - [Standard-Benachrichtigung](/de/api/incident-management/notification-template): `/api/im/notification-template` (Admin) ### Incidents - [Incidents auflisten](/de/api/incident-management/list-incidents): `GET /api/im/incidents` - [Offene Incidents zählen](/de/api/incident-management/incident-count): `GET /api/im/incidents/count` - [Incident abrufen](/de/api/incident-management/get-incident): `GET /api/im/incidents/:id` - [Incident zu einem Monitoring-Incident finden](/de/api/incident-management/incident-by-monitor): `GET /api/im/incidents/by-monitor/:id` - [Incident erstellen](/de/api/incident-management/create-incident): `POST /api/im/incidents` - [Incident bestätigen / Status ändern](/de/api/incident-management/ackno…
### Incident bestätigen / Status ändern
URL: https://docs.uptimeify.io/de/api/incident-management/acknowledge-incident
Description: Bestätigt einen Incident-Management-Incident oder bewegt ihn zwischen den offenen Status (acknowledged, investigating, identified, monitoring).
Summary: Zwei Endpunkte ändern den Status eines offenen Incidents: - [Bestätigen](#bestätigen) ist der idempotente „Ich kümmere mich"-Aufruf. Er wirkt auf jeden offenen Incident, der noch nicht bestätigt wurde, und steht allen mit IM-Zugriff offen, denn eine Bestätigung stoppt immer nur Alarmierungen. - [Status ändern](#status-ändern) bewegt einen Incident zwischen den offenen Status, einschließlich `acknowledged`. Das ist dem Team des Incidents vorbehalten. Keiner der beiden Endpunkte kann `resolved` erreichen (dafür [Incident lösen](/de/api/incident-management/resolve-incident)) oder `merged` (dafür [Incidents zusammenführen](/de/api/incident-management/merge-incidents)). **Was eine Bestätigung stoppt**, hängt vom aktuellen Eskalations-Tier des Incidents ab. Standardmäßig stoppt sie die ganze Eskalationskette. Ist dieser Tier so eingestellt, dass die Eskalation erst beim Lösen endet, verstummt mit der Bestätigung die aktuelle Alarmierung, weitere Tiers eskalieren aber weiter, bis der Incident gelöst ist. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. ## Bestätigen `POST /api/im/incidents/:id/ack` Bestätigt einen offenen Incident, der noch keine Bestätigung trägt (`acknowledgedAt` ist `null`). Ein `triggered`-Incident wechselt zu `acknowledged`. Ein Incident, der ohne Bestätigung auf `investigating`, `identified` oder `monitoring` gesetzt wurde, behält seinen Status, die Bestätigung wird aber vermerkt (`acknowledgedBy`, `acknowledgedAt`) und die Eskalation stoppt genau wie bei einem `triggered`-Incident; `status` in der Antwort ist dann dieser unveränderte Status. Ein zweiter Aufruf, oder ein Aufruf auf einen `resolved`- oder `merged`-Incident, ist kein Fehler: die Antwort enthält `alreadyAcknowledged: true` und den aktuellen Status. Die Timeline vermerkt die Bestätigung mit `source: "api"` für einen API-Token und `source: "ui"` für eine Browser-Session. Kein Request-Body. ### Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents/42/ack" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort (Response) `200 OK`, erste Bestätigung: ```json { "acknowledged": true, "alreadyAcknowledged": false, "status": "acknowledged", "acknowledgedBy": "MFcTjWmYq2LpzR8vK1sXo", "acknowledgedAt": "2026-07-17T09:20:00.000Z" } ``` Beide Antworten enthalten `acknowledgedAt` (ISO-Zeitstempel, oder `null` bei einem `resolved`/`merged`-Incident, der nie bestätigt wurde). Ein Incident gilt als bestätigt, wenn `acknowledgedAt` gesetzt ist oder `status` `resolved` bzw. `merged` lautet; leite das nicht aus `acknowledgedBy` ab, das bei einer Bestätigung per API-Token `null` ist. `200 OK`, der Incident war bereits bestätigt: ```json { "acknowledged": true, "alreadyAcknowledged": true, "status": "investigating", "acknowledgedBy": "MFcTjWmYq2LpzR8vK1sXo", "acknowledgedAt": "2026-07-17T09:20:00.000Z" } ``` ### Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `400 Bad Request` (`invalidRequestBody`) wenn `:id` keine positive Ganzzahl ist - `404 Not Found` (`imIncidentNotFound`) wenn der Incident nicht existiert oder zu einer anderen Organisation gehört ## Status ändern `POST /api/im/incidents/:id/status` Bewegt einen Incident zwischen den offenen Status `triggered`, `acknowledged`, `investigating`, `identified` und `monitoring`. Jeder der vier Nicht-`triggered`-Status ist von jedem offenen Status aus ein gültiges Ziel, nicht nur der „nächste"; `triggered` selbst ist nie ein Ziel. `acknowledged` bestätigt den Incident und stoppt die Eskalation wie…
### Incident Management aktivieren
URL: https://docs.uptimeify.io/de/api/incident-management/activate
Description: Schaltet Incident Management für deine Organisation ein. Idempotent: ein weiterer Aufruf bei aktivierter Organisation ändert nichts.
Summary: `POST /api/im/activate` Schaltet Incident Management für deine Organisation ein. Solange das nicht geschehen ist, antwortet jeder andere Endpunkt dieser API mit `403` und `imNotEnabled`; dieser hier (und der [Einrichtungsstand](/de/api/incident-management/setup)) ist absichtlich schon vor der Aktivierung erreichbar. Die Aktivierung ist idempotent. Bei einer bereits aktivierten Organisation liefert sie `alreadyEnabled: true` und ändert nichts. Bei der ersten Aktivierung führt Uptimeify zusätzlich seine Aktivierungs-Hooks aus, zum Beispiel die Übernahme offener Monitoring-Incidents in Incident Management, wenn die Monitoring-Brücke eingeschaltet ist. Schlägt ein Hook fehl, bleibt die Aktivierung trotzdem bestehen; sein Name steht dann in `hookErrors`. ## Authentifizierung Erfordert eine IM-berechtigte Rolle und **Schreibrechte an der Organisation**: die Rolle `admin` dieser Organisation oder einen organisationsweiten API-Token, den ein Organisations-Admin erstellt hat. `editor` und `responder` erhalten `403` (`forbidden`). ## Query-Parameter | Parameter | Typ | Pflicht | Beschreibung | |-----------|-----|---------|--------------| | `organizationId` | number | Nein | Die zu aktivierende Organisation. Standard ist deine eigene. Eine andere Organisation zu nennen, gelingt nur Plattform-Administratoren. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/activate" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) Erste Aktivierung: ```json { "organizationId": 42, "enabled": true, "monitoringBridge": true, "alreadyEnabled": false, "hookErrors": [] } ``` Bereits aktiviert: ```json { "organizationId": 42, "enabled": true, "monitoringBridge": true, "alreadyEnabled": true } ``` | Feld | Beschreibung | |------|--------------| | `monitoringBridge` | Ob Incidents aus Uptimeifys eigenem Monitoring in Incident Management übernommen werden. Änderbar in den [Organisationseinstellungen](/de/api/incident-management/org-settings). | | `hookErrors` | Namen der fehlgeschlagenen Aktivierungs-Hooks. Leer bei Erfolg. Nur bei der ersten Aktivierung vorhanden. | ## Häufige Fehler - `400 Bad Request` (`organizationIdRequired`) wenn sich keine Organisation bestimmen lässt - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn keine IM-berechtigte Rolle vorliegt - `403 Forbidden` (`forbidden`) wenn du kein Admin der Organisation bist
### Alert-Source-Einrichtungsanleitungen
URL: https://docs.uptimeify.io/de/api/incident-management/alert-sources
Description: Schritt-für-Schritt-Anleitungen, um Zabbix, Datadog, Grafana Alerting, Prometheus Alertmanager, Sentry, Beszel oder einen beliebigen eigenen Webhook mit Uptimeify Incident Management zu verbinden.
Summary: Jede der folgenden Anleitungen zeigt, wie du ein Monitoring- oder Alerting-Tool so konfigurierst, dass es seine Alarme an eine Uptimeify **Alert Source** sendet, an einen Tool-spezifischen Ingest-Endpunkt mit fertigem Feld-Mapping. Dadurch landen Alarme bereits normalisiert (Titel, Schweregrad, Status, Host) in Incident Management, ohne dass du eine eigene Integration schreiben musst. ## Anleitungen - [Zabbix](/de/api/incident-management/alert-sources/zabbix) - [Datadog](/de/api/incident-management/alert-sources/datadog) - [Grafana Alerting](/de/api/incident-management/alert-sources/grafana-alerting) - [Prometheus Alertmanager](/de/api/incident-management/alert-sources/prometheus-alertmanager) - [Sentry](/de/api/incident-management/alert-sources/sentry) - [Beszel](/de/api/incident-management/alert-sources/beszel) - [Benutzerdefinierter Webhook](/de/api/incident-management/alert-sources/custom-webhook) - [E-Mail](/de/api/incident-management/alert-sources/email) - [Meldeformular](/de/api/incident-management/alert-sources/report-form) Die Anleitung **E-Mail** funktioniert anders als die übrigen: eine E-Mail-Source hat keine JSON-Webhook-Payload, daher gelten die Abschnitte „So funktioniert das Einspeisen“ und „Schweregrad-Mapping“ unten (beide Webhook-spezifisch) nicht für sie; sieh dir direkt diese Anleitung an. ## So funktioniert das Einspeisen 1. Gehe im Uptimeify-Dashboard zu **Incident Management → Alert Sources → Neu** und wähle das Preset, das zu deinem Tool passt. Vergib einen Namen und weise die Source einem Team zu. 2. Uptimeify erzeugt eine eindeutige Ingest-URL: ``` https:///api/im/ingest/ ``` Der `` wird **einmalig** direkt nach dem Anlegen der Source angezeigt. Kopiere ihn sofort. Danach wird er nie wieder im Klartext angezeigt. Solltest du ihn verlieren, öffne den Tab **Einstellungen** der Source und rotiere den Token, um eine neue URL zu erhalten (ebenfalls nur einmalig sichtbar). 3. Konfiguriere dein Tool (siehe die jeweilige Anleitung) so, dass es bei jedem ausgelösten oder aufgelösten Alarm eine HTTP-`POST`-Anfrage mit JSON-Body an diese URL sendet. 4. Uptimeify parst das Payload anhand des Feld-Mappings des Presets (oder deines eigenen, angepassten Mappings im Tab **Payload Mapping** der Source) und reiht es zur asynchronen Verarbeitung in Incident Management ein. Das ist ein anderer Mechanismus als der [Events-Ingest](/de/api/incident-management/events-ingest)-Endpunkt (`POST /api/im/events`): Dieser wird mit einem organisationsweiten API-Token authentifiziert und hat kein voreingestelltes Feld-Mapping (jede Anfrage läuft über eine einzige, automatisch angelegte Source vom Typ `api`). Die Tool-spezifische Ingest-URL oben braucht keinen API-Token (der in der URL enthaltene Token **ist** das Credential, behandle die vollständige URL also wie ein Passwort), bringt dafür aber ein fertiges Mapping für das gewählte Tool mit. Kann dein Tool Anfragen signieren oder einen Header mitschicken, kannst du je Source zusätzlich eine HMAC-Signatur (`X-Uptimeify-Signature` + `X-Uptimeify-Timestamp`) oder einen `Authorization: Bearer`-Token verlangen. Sources lassen sich auch per API anlegen, rotieren und testen. Beides beschreibt die [Alert-Sources-API](/de/api/incident-management/alert-sources-api). ## Anfragelimits Für jede Ingest-URL gelten unabhängig vom Preset dieselben Limits: | Limit | Wert | Fehler | |-------|-------|---------| | Body-Größe | 256 KB | `413 Payload Too Large` (`payload_too_large`) | | JSON-Verschachtelungstiefe | 20 Ebenen | `422 Unprocessable Entity` (`payload_too_deep`) | | Gültiges JSON | Pflicht | `422 Unprocessable Entity` (`invalid_json`) | | Anfragen je Alert-Quelle | 300 pro Minute | `429 Too Many Requests` (`imIngestRateLimited`, `data.retryAfter`) | | Ingest-Bytes je Organisation | 50 MiB pro Stunde | `429 Too Many Requests` (`imIngestByteBudgetExceeded`, `data.retryAfter`) | Ein leerer Request-Body wird als `{}` behandelt. ## Antwort Eine erfolgreiche Anfrage lief…
### Alert-Sources-API
URL: https://docs.uptimeify.io/de/api/incident-management/alert-sources-api
Description: Alert-Sources im Incident Management anlegen, konfigurieren und testen: Ingest-Tokens, optionale HMAC- oder Bearer-Authentifizierung, Payload-Mapping, Wartungsfenster und Statistiken je Source.
Summary: Eine **Alert-Source** ist eine eingehende Integration. Jede Webhook-Source hat ihre eigene Ingest-URL (`https://uptimeify.io/api/im/ingest/`) und ein Payload-Mapping, das das JSON des Anbieters in einen Alert übersetzt. Wie du Zabbix, Datadog, Grafana und andere auf diese URL zeigen lässt, steht in den [Einrichtungsanleitungen](/de/api/incident-management/alert-sources). Diese Seite beschreibt die Endpunkte, mit denen du die Sources selbst verwaltest. ## Authentifizierung Jeder Endpunkt braucht IM-Zugriff: eine IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder einen organisationsweiten API-Token. Incident Management muss für die Organisation aktiviert sein. Ein kunden-gescopter Token wird mit `403 Forbidden` (`customerScopedTokenForbidden`) abgewiesen. - **Lese-Endpunkte** (Liste, Detail, Presets, Payloads, Statistik, test-mapping) stehen jedem IM-berechtigten Aufrufer offen. - **Schreib-Endpunkte** (Anlegen, Ändern, Löschen, Token- und Secret-Rotation, disable-auth, test-alert) verlangen zusätzlich die Rolle `admin` oder eine Team-Admin-Mitgliedschaft im Team der Source. Ein API-Token trägt die Rolle der Person, die ihn erstellt hat. Nimm also einen Token, den ein Organisations-Admin erstellt hat. Sources sind auf deine Organisation beschränkt. Eine Source einer anderen Organisation antwortet mit `404 Not Found` (`imSourceNotFound`), nie mit `403`. ## Das Source-Objekt Liste, Detail, Ändern und disable-auth liefern diese Form. Zugangsdaten tauchen darin nie auf: Ingest-Token, Bearer-Token und HMAC-Secret gibt es nur einmal, vom Endpunkt, der sie erzeugt. | Feld | Typ | Beschreibung | |-------|------|-------------| | `id` | number | ID der Source. | | `organizationId` | number | Besitzende Organisation. | | `teamId` | number | Team, dessen Eskalation die Source speist. | | `name` | string | Anzeigename, bis zu 120 Zeichen. | | `type` | string | `zabbix`, `datadog`, `grafana`, `alertmanager`, `sentry`, `beszel`, `custom`, `api`, `email`, `form` (das öffentliche [Meldeformular](/de/api/incident-management/alert-sources/report-form)) oder `uptimeify_monitoring` (die eingebaute Brücke aus dem klassischen Monitoring, von der Plattform angelegt). | | `authMode` | object | `{ urlToken?, hmac?: { enabled }, bearer?: { enabled } }`. Siehe [Optionale Absender-Authentifizierung](#optionale-absender-authentifizierung). | | `payloadMapping` | object | Feld-Mapping, das auf jede eingehende Payload angewendet wird. | | `autoResolve` | boolean | Ob ein Resolve-Event den Incident automatisch schließt. Wird auf jeden neuen Incident übertragen. | | `groupingWindowMinutes` | number oder null | Gruppierungsfenster. `null` gruppiert nur nach Dedup-Key. | | `maintenance` | object oder null | Wiederkehrende Wartungsfenster, `{ windows: [...] }`. | | `snoozeUntil` | ISO 8601 oder null | Stummgeschaltet bis zu diesem Zeitpunkt. | | `secondaryExpiresAt` | ISO 8601 oder null | Bis wann der vorige Ingest-Token nach einer Rotation noch gilt. | | `createdAt`, `updatedAt` | ISO 8601 | Zeitstempel. | ```json { "id": 7, "organizationId": 1, "teamId": 3, "name": "Zabbix production", "type": "zabbix", "secondaryExpiresAt": null, "payloadMapping": { "title": "trigger_name", "severity": "event_severity", "status": "trigger_status", "host": "host_name", "dedupKey": "event_id", "severityMap": { "Disaster": "sev1", "High": "sev2", "Average": "sev3", "Warning": "sev4", "Information": "sev4", "Not classified": "sev4" }, "resolveValues": ["RESOLVED", "OK"] }, "autoResolve": true, "groupingWindowMinutes": null, "maintenance": null, "snoozeUntil": null, "createdAt": "2026-10-01T08:00:00.000Z", "updatedAt": "2026-10-01T08:00:00.000Z", "authMode": {} } ``` **Abgelöste Felder:** Bis zum 18.01.2027 liefern Antworten `authMode.url_token` weiter neben `authMode.urlToken`, und Request-Bodys nehmen es noch an; ein fehlgeschlagener [Mapping-Test](#mapping-testen) liefert `error` weiter neben `errorMessage`. Nutze die Nachfolger; `url_token` und `urlToken` mit versc…
### Beszel
URL: https://docs.uptimeify.io/de/api/incident-management/alert-sources/beszel
Description: Beszel-Serveralarme über einen generischen Shoutrrr-Webhook an Uptimeify Incident Management senden, mit Host, Link, Schweregrad und automatischer Entwarnung für jeden Beszel-Alarmtyp.
Summary: [Beszel](https://beszel.dev) benachrichtigt über [Shoutrrr](https://beszel.dev/guide/notifications/)-URLs. Sein generischer Webhook schickt nur einen Titel und eine Nachricht, ohne Statusfeld und ohne Alarm-ID. Das Beszel-Preset liest alles Nötige aus dem Titel: ob der Alarm auslöst oder sich erholt, um welches System es geht und welchen früheren Alarm eine Entwarnung schließt. Geprüft gegen die Alarmtexte von Beszel 0.21. ## 1. Alarmquelle in Uptimeify anlegen Gehe zu **Incident Management → Alarmquellen → Neu**, wähle das **Beszel**-Preset, vergib einen Namen und lege die Quelle an. Die Erfolgsseite zeigt eine fertige **Benachrichtigungs-URL für Beszel**: ``` generic:///api/im/ingest/?template=json ``` Sie wird einmal angezeigt und danach nie wieder im Klartext. Wenn du sie verlierst, rotiere das Token im Tab **Einstellungen** der Quelle und baue die URL aus der neuen Ingest-URL neu: `https://` durch `generic://` ersetzen und `?template=json` anhängen. `template=json` ist Pflicht. Ohne diesen Parameter schickt Beszel reinen Text statt `{ "title", "message" }`, und das Preset hat nichts zu lesen. ## 2. URL in Beszel eintragen 1. Öffne in Beszel **Einstellungen → Benachrichtigungen**. 2. Trage unter **Webhook / Push-Benachrichtigungen** die URL aus Schritt 1 ein und speichere. **Test URL** schickt eine Testbenachrichtigung. Sie kommt als offener Alarm mit dem Titel `Test Alert` an; schließe ihn von Hand. 3. Öffne in der Systemtabelle das Glockensymbol jedes Systems und aktiviere die gewünschten Alarme (Status, CPU, Speicher, Datenträger und so weiter). Beszel schickt eine Benachrichtigung, wenn ein Alarm auslöst, und eine, wenn er sich erholt. Beide landen beim selben Uptimeify-Alarm, die Entwarnung schließt ihn also. ## Unterstützte Alarmtypen | Beszel-Alarm | Titel beim Auslösen | Titel bei der Entwarnung | |---|---|---| | CPU, Speicher, Datenträger, Bandbreite, Temperatur, Last, GPU | `web-01 CPU above threshold` | `web-01 CPU below threshold` | | Akku (löst bei niedrigem Stand aus) | `web-01 battery below threshold` | `web-01 battery above threshold` | | Status (Verbindung) | `Connection to web-01 is down 🔴` | `Connection to web-01 is up ✅` | | Container-Zustand | `Unhealthy container db on web-01 🔴` oder `3 unhealthy containers on web-01 🔴` | `web-01 containers are healthy ✅` | | systemd-Dienste | `Failed services on web-01 🔴` | `Services recovered on web-01 ✅` | | Netzwerk-Monitor (Paketverlust) | `Network monitor loss on web-01: 1.1.1.1:53` | `Network monitor recovered on web-01: 1.1.1.1:53` | | SMART | `SMART failure on web-01: /dev/sda 🔴` | keine | | ZFS-Pool | `Storage pool DEGRADED on web-01: tank` | keine | Für SMART und ZFS schickt Beszel keine Entwarnung. Diese Alarme bleiben offen, bis du sie in Uptimeify schließt. Mehrere ungesunde Container auf einem System teilen sich einen Alarm, weil auch Beszels Entwarnung das ganze System betrifft. ## Standard-Feldzuordnung | Beszel-Feld | Normalisiertes Feld | |---|---| | `title` | Titel, unverändert | | `title` | Status: `below threshold` (Akku: `above threshold`), `is up`, `recovered` und `containers are healthy` schließen den Alarm, alles andere lässt ihn offen | | `title` | Host: der Systemname in Beszel, auch wenn er Leerzeichen enthält | | `title` | Dedup-Key: System plus Alarmtyp, für Auslösung und Entwarnung gleich | | `message` | Link zurück zum System in Beszel (die URL, die Beszel an jede Nachricht hängt) | | `message` | Eigenes Feld `details`, die Nachricht ohne den Link (zum Beispiel `CPU averaged 91.20% for the previous 10 minutes.`) | ### Schweregrad-Zuordnung | Beszel-Alarm | Uptimeify-Schweregrad | |---|---| | SMART failure, ZFS-Pool `FAULTED`, `OFFLINE`, `UNAVAIL`, `REMOVED` oder `SUSPENDED` | `sev1` | | Verbindung down, ausgefallene Dienste, ZFS-Pool `DEGRADED` | `sev2` | | SMART warning | `sev3` | | Alles andere | Der Standard-Schweregrad der Quelle | ## Beispiel-Payload ```json { "title": "backend1 CPU above threshold", "mes…
### Benutzerdefinierter Webhook
URL: https://docs.uptimeify.io/de/api/incident-management/alert-sources/custom-webhook
Description: Alarme aus jedem Tool, das JSON per POST senden kann, an Uptimeify Incident Management schicken, mit eigenem Feld-Mapping im Dashboard.
Summary: Das Preset **Benutzerdefinierter Webhook** ist der Ausgangspunkt für jedes Monitoring- oder Alerting-Tool, für das es kein eigenes Preset gibt: eine Firewall-Appliance, ein internes Skript, ein Nischen-SaaS-Produkt, alles, was eine HTTP-`POST`-Anfrage mit JSON-Body senden kann. Anders als die übrigen Presets kommt es nur mit einem minimalen Standard-Mapping. Den Rest legst du selbst fest, sobald du die tatsächliche Payload-Form deines Tools siehst. ## 1. Alert Source in Uptimeify anlegen Gehe zu **Incident Management → Alert Sources → Neu**, wähle das Preset **Benutzerdefinierter Webhook**, vergib einen Namen und lege die Source an. Kopiere auf dem Erfolgsbildschirm die Ingest-URL (`https://deine-domain/api/im/ingest/`). Sie wird nur einmal angezeigt und danach nie wieder im Klartext eingeblendet. Solltest du sie verlieren, rotiere den Token im Tab **Einstellungen** der Source. ## 2. Dein Tool auf die Ingest-URL zeigen lassen Konfiguriere das Webhook-/Benachrichtigungsziel deines Tools so, dass es bei jedem ausgelösten oder aufgelösten Alarm eine HTTP-`POST`-Anfrage mit JSON-Body an die Ingest-URL sendet. Es gibt kein festes Request-Schema auf der Empfängerseite. Sende, was dein Tool liefert. ```bash curl -X POST "https://deine-domain/api/im/ingest/" \ -H "Content-Type: application/json" \ -d '{ "title": "Disk usage above 90% on db-primary", "status": "open" }' ``` ## 3. Feld-Mapping an deine Payload anpassen Das Standard-Mapping extrahiert nur einen Titel und einen Status: sinnvolle Vorgaben für eine generische Payload, aber fast sicher nicht alles, was du möchtest: 1. Sende einmal eine echte (oder repräsentative Test-)Payload aus deinem Tool, damit du die genauen Feldnamen siehst. Die Ansicht **Live-Aktivität** auf der Detailseite der Alert Source zeigt die zuletzt empfangenen Rohdaten. 2. Öffne den Tab **Payload Mapping** der Source und bearbeite die Selektoren: Füge `severity`-, `host`- und `dedupKey`-Selektoren hinzu, die auf die tatsächlichen Feldnamen deiner Payload zeigen (Dot-/Bracket-Pfade wie `data.host.name` oder `alerts[0].id` werden unterstützt, ebenso `a || b`-Fallback-Ketten für Felder, die nicht immer vorhanden sind). Füge bei Bedarf ein `severityMap` hinzu, falls dein Tool ein eigenes Schweregrad-Vokabular sendet, damit es auf Uptimeifys Skala `sev1` bis `sev4` abgebildet wird. 3. Speichern, und prüfe anschließend über das Testpanel im Tab **Payload Mapping**, ob eine Beispiel-Payload durch dein angepasstes Mapping die erwarteten Werte für Titel/Schweregrad/Status/Host liefert, bevor du dich bei echten Alarmen darauf verlässt. ## Payloads ohne Statusfeld (Regex) Manche Tools schicken nur Freitext: Beszel, der generische Webhook von Uptime Kuma, Healthchecks.io, Gatus. Es gibt kein Statusfeld und keine stabile Alarm-ID, und Alarm- und Entwarnungstitel unterscheiden sich. Jeder Selektor kann mit `feld =~ /muster/` einen Wert aus Text schneiden, in derselben Schreibweise wie die [E-Mail-Quelle](/api/incident-management/alert-sources/email). Der Wert ist die erste Klammergruppe, ohne Klammergruppe der ganze Treffer. Kein Treffer gilt als „nicht vorhanden“, dann greift der nächste Kandidat einer `a || b`-Kette. Erlaubt sind die Flags `i`, `m`, `s` und `u`; durchsucht werden die ersten 4.096 Zeichen eines Felds, und ein Muster, das eine selbst wiederholte Gruppe wiederholt (`(a+)+`), trifft nie. Beispiel für [Beszel](https://beszel.dev) (generischer Webhook, `template=json`), das `{"title": "backend1 CPU above threshold", "message": "..."}` schickt und bei der Entwarnung `"backend1 CPU below threshold"`: | Selektor | Wert | |---|---| | `title` | `title` | | `status` | `title =~ /(below threshold\|is up)/` mit `resolveValues`: `below threshold`, `is up` | | `dedupKey` | `title =~ /^(.+) (?:above\|below) threshold$/ \|\| title =~ /^Connection to (.+) is/` | Alarm und Entwarnung teilen sich damit einen Dedup-Schlüssel (`backend1 CPU`, bei Verbindungsalarmen `backend1`), und die Entwarnung löst den Vorfal…
### Datadog
URL: https://docs.uptimeify.io/de/api/incident-management/alert-sources/datadog
Description: Datadog-Monitor-Alarme über eine Datadog-Webhook-Integration an Uptimeify Incident Management senden, bereits auf Titel, Alarmtyp und Übergangsstatus abgebildet.
Summary: Uptimeify bildet mit dem Datadog-Preset die Webhook-Benachrichtigungs-Payload eines Datadog-Monitors direkt ab: Alarmtitel, Alarmtyp, Übergangsstatus und Hostname sind bereits vorab gemappt. ## 1. Alert Source in Uptimeify anlegen Gehe zu **Incident Management → Alert Sources → Neu**, wähle das **Datadog**-Preset, vergib einen Namen und lege die Source an. Kopiere auf dem Erfolgsbildschirm die Ingest-URL (`https://deine-domain/api/im/ingest/`). Sie wird nur einmal angezeigt und danach nie wieder im Klartext eingeblendet. Solltest du sie verlieren, rotiere den Token im Tab **Einstellungen** der Source. ## 2. Webhooks-Integration in Datadog anlegen 1. Gehe in Datadog zu **Integrations → Webhooks** und klicke auf **New**. 2. Vergib einen Namen für den Webhook (z. B. `uptimeify`) und setze die **URL** auf die in Schritt 1 kopierte Ingest-URL. 3. Belasse den **Payload** bei Datadogs Standard-Monitor-Benachrichtigungs-Payload, unverändert, denn das Uptimeify-Preset erwartet die Standardfelder (`alert_id`, `alert_title`, `alert_type`, `alert_transition`, `hostname`, …). Falls du die Payload-Vorlage dieses Webhooks bereits angepasst hast, setze sie auf Datadogs Standard zurück, oder passe stattdessen den Tab **Payload Mapping** deiner Uptimeify-Source an deine eigenen Felder an. 4. Speichere den Webhook. ## 3. Monitore über den Webhook benachrichtigen Datadog ruft eine Webhook-Integration nur auf, wenn die Benachrichtigungsnachricht eines Monitors sie explizit referenziert: 1. Öffne (oder erstelle) einen Datadog-**Monitor**. 2. Füge im Abschnitt **Notify your team** der Monitor-Nachricht `@webhook-uptimeify` hinzu (ersetze `uptimeify` durch den Namen, den du dem Webhook in Schritt 2 gegeben hast). 3. Speichere den Monitor. Datadog ruft den Webhook nun bei jedem Statuswechsel auf (Triggered, Warn, Recovered, …), den die Benachrichtigungsregeln des Monitors abdecken. Wiederhole Schritt 2 und 3 für jeden Monitor, den du in Uptimeify sehen möchtest, oder füge `@webhook-uptimeify` zu einer Benachrichtigungs-Voreinstellung hinzu, die deine Monitore ohnehin teilen. ## Standard-Feld-Mapping | Datadog-Feld | Normalisiertes Feld | |---|---| | `alert_title` | Titel | | `alert_type` | Schweregrad (über die Zuordnung unten) | | `alert_transition` | Status: `Recovered` löst den Alarm auf, alles andere hält ihn offen | | `hostname` | Host | | `url` | Link zurück zum Event in Datadog | | `alert_metric`, `tags` | Custom-Felder `metric`, `event_tags`, am Incident als Details angezeigt | | `alert_id` | Dedup-Key: gruppiert Benachrichtigungen für dasselbe Monitor-Event | ### Schweregrad-Zuordnung | Datadog `alert_type` | Uptimeify-Schweregrad | |---|---| | `error` | `sev1` | | `warning` | `sev3` | | `success` | `sev4` | | `info` | `sev4` | ## Beispiel-Payload So sieht die Payload aus, die das Datadog-Preset von Uptimeify erwartet: ```json { "id": "4707056510925961466", "alert_id": "1234567", "alert_title": "[Triggered] High CPU usage on host web-01", "alert_type": "error", "alert_transition": "Triggered", "alert_status": "Alert", "alert_metric": "system.cpu.user", "date": "1752739200000", "event_type": "metric_alert_monitor", "hostname": "web-01.prod.example.com", "org": { "id": "123456", "name": "Example Org" }, "priority": "normal", "tags": "env:prod,service:web", "title": "[Triggered] High CPU usage on host web-01", "url": "https://app.datadoghq.com/event/event?id=4707056510925961466" } ``` Du kannst genau diese Payload über den Tab **Payload Mapping** im Dashboard gegen das Mapping deiner Source senden, um den Aufbau zu prüfen, bevor du einen echten Monitor verbindest.
### E-Mail
URL: https://docs.uptimeify.io/de/api/incident-management/alert-sources/email
Description: Leite Alarm-E-Mails aus jedem Monitoring-Tool, Ticketing-System oder Postfach an eine eigene Empfangsadresse weiter oder route sie dorthin. Uptimeify wandelt sie automatisch in Vorfälle um.
Summary: Die Alert Source **E-Mail** wandelt E-Mails, die du an eine eigene Empfangsadresse weiterleitest oder routest, automatisch in Vorfälle um. Nutze sie für jedes Monitoring- oder Alerting-Tool, das nur per E-Mail benachrichtigen kann (keine Webhook-Option), oder überall dort, wo Alarme ohnehin in einem Postfach landen: ein gemeinsames Ops-Postfach, ein Legacy-Paging-System, ein Anbieter, der nur E-Mail-Benachrichtigungen anbietet. Anders als die Webhook-Presets auf den anderen Seiten dieses Abschnitts hat eine E-Mail-Source keine JSON-Payload. Sie liest Betreff und Klartext-Body der E-Mail mit einer eigenen Selektor-Sprache aus (siehe unten), nicht mit den Dot-/Bracket-`Selector`-Pfaden dieser anderen Anleitungen. ## 1. Alert Source in Uptimeify anlegen Gehe zu **Incident Management → Alert Sources → Neu** und wähle die Option **E-Mail** (neben den Webhook-Presets), vergib einen Namen und lege die Source an. Kopiere auf dem Erfolgsbildschirm die Empfangsadresse. Sie hat die Form `@alerts.uptimeify.io` und wird nur einmal angezeigt, danach nie wieder im Klartext. Solltest du sie verlieren, rotiere den Token im Tab **Einstellungen** der Source, um eine neue Adresse zu erhalten. ## 2. Deine Alarme an die Adresse schicken Es gibt keinen festen Absender oder Anbieter. Alles, was eine Klartext-E-Mail zustellen kann, funktioniert: - Trage die Adresse als Benachrichtigungs-/Kontaktziel in einem Monitoring-Tool ein, das nur E-Mail-Alerting unterstützt. - Richte in deinem Postfach (Gmail, Outlook, ein gemeinsamer Ops-Alias, …) eine Weiterleitungsregel ein, die passende Alarm-E-Mails dorthin weiterleitet. - Zeige eine bereits bestehende Mail-Routing-Regel oder ein Relay darauf, falls Alarme schon durch eines laufen. Gelesen wird nur der **Klartext-Body**. Eine reine HTML-E-Mail ohne Klartext-Teil ergibt für die Selektoren einen leeren Body. Der Betreff steht weiterhin zur Verfügung. ## Standard-Feld-Mapping (ohne Konfiguration) Eine frisch angelegte E-Mail-Source funktioniert ohne weitere Einrichtung mit diesen Vorgaben: | Feld | Standardquelle | Hinweise | |---|---|---| | Titel | Betreff-Header, unverändert | | | Status | `open`, außer der Betreff enthält als ganzes Wort `resolved`, `recovered` oder `cleared` (Groß-/Kleinschreibung egal) | Durchsucht wird dafür nur der **Betreff**, nie der Body, damit der Fließtext eines noch aktiven Alarms (z. B. „checks are not ok“) niemals als Auflösung missverstanden wird | | Schweregrad | Der in der Source konfigurierte Standard-Schweregrad | Jede E-Mail nutzt ihn, bis du einen `severity`-Selektor + `severityMap` hinzufügst | | Host | Leer | Bis du einen `host`-Selektor hinzufügst | | Dedup-Key | Ein deterministischer Hash aus Titel + Absenderadresse | Bis du einen `dedupKey`-Selektor hinzufügst | ## Die E-Mail-Selektor-Sprache E-Mail-Selektoren sind eine kleine, eigene Syntax, getrennt von den JSON-`Selector`-Pfaden der Webhook-Sources, denn eine E-Mail hat keine JSON-Struktur zum Durchlaufen: | Selektor | Löst auf zu | |---|---| | `subject` | Der Betreff-Header der E-Mail, unverändert | | `body` | Der Klartext-Body, unverändert | | `body.line(N)` | Die N-te Zeile des Klartext-Bodys, 1-indiziert (`body.line(1)` ist die erste Zeile) | | `subject =~ /muster/` | Regex-Match gegen den Betreff: die erste Capture-Gruppe `(...)`, falls das Muster eine hat, sonst der gesamte Match | | `body =~ /muster/` | Dasselbe, gegen den Klartext-Body | Ein Selektor kann per `||` Fallback-Ketten bilden, dieselbe Konvention wie bei den Webhook-`Selector`-Pfaden: Der erste Kandidat, der zu einem nicht-leeren Wert auflöst, gewinnt: ``` subject =~ /Status: (\w+)/ || body.line(1) ``` Ein fehlendes Feld, eine Zeilennummer außerhalb des gültigen Bereichs oder ein ungültiges bzw. nicht passendes Regex lösen alle zu „nichts“ auf, statt einen Fehler zu werfen. Eine fehlerhafte oder unerwartete E-Mail ist normaler, erreichbarer Input, kein Bug. ## Mapping anpassen Im Dashboard gibt es aktuell keinen eigenen Mapping-Editor fü…
### Grafana Alerting
URL: https://docs.uptimeify.io/de/api/incident-management/alert-sources/grafana-alerting
Description: Grafana-Alerting-Benachrichtigungen über einen Webhook-Contact-Point an Uptimeify Incident Management senden, abgebildet aus dem ersten Alarm der Gruppe.
Summary: Uptimeify bildet mit dem Grafana-Preset die Payload eines Grafana-Alerting-Webhook-Contact-Points direkt ab: Alarmname, Schweregrad-Label, Status und Instanz werden aus dem ersten Alarm der Benachrichtigungsgruppe vorab gemappt. ## 1. Alert Source in Uptimeify anlegen Gehe zu **Incident Management → Alert Sources → Neu**, wähle das **Grafana**-Preset, vergib einen Namen und lege die Source an. Kopiere auf dem Erfolgsbildschirm die Ingest-URL (`https://deine-domain/api/im/ingest/`). Sie wird nur einmal angezeigt und danach nie wieder im Klartext eingeblendet. Solltest du sie verlieren, rotiere den Token im Tab **Einstellungen** der Source. ## 2. Webhook-Contact-Point in Grafana anlegen 1. Gehe in Grafana zu **Alerting → Contact points** und klicke auf **Add contact point**. 2. Vergib einen Namen (z. B. `uptimeify`) und setze **Integration** auf **Webhook**. 3. Setze die **URL** auf die in Schritt 1 kopierte Ingest-URL und belasse die **HTTP-Methode** bei `POST`. 4. Belasse die Payload bei Grafanas Standard-Webhook-Body. Das Uptimeify-Preset liest die Standardfelder (`alerts[]`, `status`, `commonLabels`, …), die Grafana ohnehin sendet. Speichere den Contact Point. ## 3. Alarme zum Contact Point routen Ein Contact Point erhält erst dann Benachrichtigungen, wenn eine **Notification Policy** dorthin routet: 1. Gehe zu **Alerting → Notification policies**. 2. Richte entweder die **Default Policy** auf deinen neuen Contact Point aus (jeder Alarm wird dorthin geroutet), oder füge eine verschachtelte Policy mit einem Label-Matcher hinzu (z. B. `severity =~ ".+"`), die passende Alarme dorthin routet. 3. Speichern. Grafana ruft den Webhook jetzt auf, sobald eine Alarmregel, die dieser Policy entspricht, auslöst oder sich auflöst. ## Standard-Feld-Mapping Grafana gruppiert Alarme in eine Benachrichtigung; das Preset liest alle folgenden Werte aus dem **ersten Alarm** (`alerts[0]`) dieser Gruppe, für den Titel mit Fallback auf das übergeordnete `title`-Feld: | Grafana-Feld | Normalisiertes Feld | |---|---| | `alerts[0].labels.alertname` (Fallback auf das übergeordnete `title`) | Titel | | `alerts[0].labels.severity` | Schweregrad (über die Zuordnung unten) | | `alerts[0].status` | Status: `resolved` löst den Alarm auf, alles andere (typischerweise `firing`) hält ihn offen | | `alerts[0].labels.instance` | Host | | `alerts[0].panelURL` (Fallback auf `dashboardURL`, `generatorURL`, oberstes `externalURL`) | Link zurück zu Grafana | | `alerts[0].annotations.summary` (Fallback auf `message`), `alerts[0].annotations.description`, `alerts[0].valueString` | Custom-Felder `summary`, `description`, `item_value`, am Incident als Details angezeigt | | `alerts[0].fingerprint` | Dedup-Key: Grafanas eigene stabile Identität pro Alarm | ### Schweregrad-Zuordnung Grafana hat kein eingebautes `severity`-Label. Das funktioniert nur, wenn deine Alarmregeln selbst eines setzen (z. B. über ein `severity`-Label an der Regel): | Grafana-Label `severity` | Uptimeify-Schweregrad | |---|---| | `critical` | `sev1` | | `high` | `sev2` | | `warning` | `sev3` | | `info` | `sev4` | Setzen deine Alarmregeln kein `severity`-Label, fällt jeder Alarm auf den in der Source konfigurierten Standard-Schweregrad zurück. ## Beispiel-Payload So sieht die Payload aus, die das Grafana-Preset von Uptimeify erwartet: ```json { "receiver": "uptimeify-webhook", "status": "firing", "orgId": 1, "alerts": [ { "status": "firing", "labels": { "alertname": "HighCPU", "severity": "critical", "instance": "server1:9090" }, "annotations": { "summary": "CPU usage above 90% on server1" }, "startsAt": "2026-07-17T12:00:00Z", "endsAt": "0001-01-01T00:00:00Z", "generatorURL": "https://grafana.example.com/alerting/grafana/abc123/view", "fingerprint": "8f3b1c9a2d4e5f60", "silenceURL": "https://grafana.example.com/alerting/silence/new", "dashboardURL": "https://grafana.example.com/d/abc123", "panelURL": "https://grafana.example.com/d/abc123?viewPanel=2" } ], "groupLabels": { "alertname": "HighCPU"…
### Prometheus Alertmanager
URL: https://docs.uptimeify.io/de/api/incident-management/alert-sources/prometheus-alertmanager
Description: Prometheus-Alertmanager-Benachrichtigungen über einen Webhook-Receiver an Uptimeify Incident Management senden, abgebildet aus commonLabels und dem ersten Alarm.
Summary: Uptimeify bildet mit dem Alertmanager-Preset die `webhook_config`-Benachrichtigungs-Payload des Alertmanagers direkt ab: Zusammenfassung/Alarmname, Schweregrad-Label, Status und Instanz sind bereits vorab gemappt. ## 1. Alert Source in Uptimeify anlegen Gehe zu **Incident Management → Alert Sources → Neu**, wähle das **Prometheus Alertmanager**-Preset, vergib einen Namen und lege die Source an. Kopiere auf dem Erfolgsbildschirm die Ingest-URL (`https://deine-domain/api/im/ingest/`). Sie wird nur einmal angezeigt und danach nie wieder im Klartext eingeblendet. Solltest du sie verlieren, rotiere den Token im Tab **Einstellungen** der Source. ## 2. Webhook-Receiver im Alertmanager anlegen Füge deiner `alertmanager.yml` einen Receiver hinzu, der auf die Ingest-URL zeigt: ```yaml receivers: - name: uptimeify webhook_configs: - url: "https://deine-domain/api/im/ingest/" send_resolved: true ``` `send_resolved: true` ist erforderlich. Ohne diese Option ruft der Alertmanager den Webhook nie auf, wenn sich ein Alarm auflöst. Incidents in Uptimeify blieben dann dauerhaft offen, selbst nachdem das zugrunde liegende Problem behoben ist. ## 3. Alarme zum Receiver routen Referenziere den Receiver über eine Route in derselben Datei (entweder als Standard-Route oder als verschachtelte Route mit Label-Matcher): ```yaml route: receiver: uptimeify # ...bestehender Routing-Baum, oder eine verschachtelte `routes:`-Regel statt der Default-Route ``` Lade den Alertmanager neu oder starte ihn neu, damit die Konfigurationsänderung greift (ein vorheriges `amtool check-config` ist eine sinnvolle Kontrolle). ## Standard-Feld-Mapping Der Alertmanager gruppiert mehrere aktive Alarme in eine Benachrichtigung; das Preset liest Titel und Instanz aus dem **ersten Alarm** (`alerts[0]`) dieser Gruppe, den Schweregrad aus den gruppenweiten `commonLabels`: | Alertmanager-Feld | Normalisiertes Feld | |---|---| | `alerts[0].annotations.summary` (Fallback auf `commonLabels.alertname`) | Titel | | `commonLabels.severity` | Schweregrad (über die Zuordnung unten) | | `status` (oberste Ebene) | Status: `resolved` löst den Alarm auf, alles andere (typischerweise `firing`) hält ihn offen | | `alerts[0].labels.instance` | Host | | `alerts[0].generatorURL` (Fallback auf oberstes `externalURL`) | Link zurück zum Prometheus-Ausdruck | | `alerts[0].annotations.summary` (Fallback auf `commonAnnotations.summary`), `alerts[0].annotations.description` | Custom-Felder `summary`, `description`, am Incident als Details angezeigt | | `alerts[0].fingerprint` | Dedup-Key: der Alertmanager-eigene stabile Fingerabdruck pro Alarm | ### Schweregrad-Zuordnung Das funktioniert nur, wenn deine Alarmregeln ein `severity`-Label setzen: | Alertmanager-Label `severity` | Uptimeify-Schweregrad | |---|---| | `critical` | `sev1` | | `warning` | `sev3` | | `info` | `sev4` | Jeder andere Wert oder ein fehlendes `severity`-Label fällt auf den in der Source konfigurierten Standard-Schweregrad zurück. Es gibt keine `sev2`-Zuordnung für den Alertmanager, da dessen eigene Schweregrad-Konvention meist nur `critical`/`warning`/`info` kennt. ## Beispiel-Payload So sieht die Payload aus, die das Alertmanager-Preset von Uptimeify erwartet: ```json { "version": "4", "groupKey": "{}:{alertname=\"InstanceDown\"}", "truncatedAlerts": 0, "status": "firing", "receiver": "uptimeify-webhook", "groupLabels": { "alertname": "InstanceDown" }, "commonLabels": { "alertname": "InstanceDown", "severity": "critical", "job": "node" }, "commonAnnotations": { "summary": "Instance 10.0.0.5:9100 down" }, "externalURL": "http://alertmanager.example.com:9093", "alerts": [ { "status": "firing", "labels": { "alertname": "InstanceDown", "severity": "critical", "instance": "10.0.0.5:9100", "job": "node" }, "annotations": { "summary": "Instance 10.0.0.5:9100 down", "description": "10.0.0.5:9100 has been down for more than 5 minutes." }, "startsAt": "2026-07-17T12:00:00.000Z", "endsAt": "0001-01-01T00:00:00Z", "generatorURL": "ht…
### Meldeformular
URL: https://docs.uptimeify.io/de/api/incident-management/alert-sources/report-form
Description: Ein Link, über den Mitarbeitende, Anbieter oder Kunden ohne Login einen Vorfall oder eine Sicherheitsbeobachtung melden. Jede Meldung wird ein Alarm im Incident Management.
Summary: Die Alert Source **Meldeformular** gibt dir einen Link zu einem einfachen Webformular. Wer den Link von dir bekommt, Mitarbeitende, Anbieter, Kunden, kann ohne Konto und ohne technisches Wissen melden, was ihm seltsam vorkommt. Jede Meldung öffnet einen Alarm im Team der Quelle, mit demselben Routing, derselben Gruppierung und derselben Eskalation wie jede andere Quelle. Damit deckst du die Vorgabe der NIS-2-Durchführungsverordnung (EU) 2024/2690, Anhang 3.3, ab, dass Beschäftigte und relevante Dritte Vorfälle und verdächtige Ereignisse melden können. ## 1. Quelle anlegen Öffne **Incident Management → Alert Sources → Neu**, wähle **Meldeformular**, gib einen Namen ein und wähle das Team. Auf der Erfolgsseite kopierst du den Link. Er hat die Form `https://uptimeify.io/de/report/` (englisch ohne `/de`) und wird nur einmal angezeigt. Geht er verloren, rotierst du den Token im Reiter **Einstellungen** der Quelle; der alte Link funktioniert dann noch 7 Tage. Lege den Link dort ab, wo man ihn findet: im Intranet, im Lieferantenportal, in der Sicherheitsrichtlinie, in einer E-Mail-Signatur. ## 2. Was das Formular fragt | Feld | Pflicht | Wird zu | |---|---|---| | Was ist passiert? | Ja, 10 bis 4000 Zeichen | Titel des Alarms (die ersten acht Wörter) und Feld `description` | | Seit wann? | Nein, freier Text | Feld `since` | | Wer ist betroffen? (niemand, einzelne, viele) | Nein | Vorgeschlagener Schweregrad und Feld `impact` | | Vermutest du einen Angriff? (ja, nein, weiß nicht) | Nein, Standard „weiß nicht“ | Feld `suspectedAttack` | | Name, E-Mail | Nein | Nur die Rohdaten des Alarms, unter `reporter` | Die Seite zeigt nur den Namen deiner Organisation. Suchmaschinen indexieren sie nicht, und sie sendet keinen Referrer. ## Schweregrad Der Schweregrad ist ein Vorschlag aus der Einschätzung der meldenden Person, dein Team bewertet ihn bei der Sichtung neu: | Wer ist betroffen? | Schweregrad | |---|---| | Niemand | `sev4` | | Einzelne Personen | `sev3` | | Viele Personen | `sev2` | | Keine Angabe | `sev3` | Jede Meldung öffnet einen eigenen Alarm (`dedupKey` `form:`): zwei Personen, die dasselbe melden, sind zwei Stimmen und kein Duplikat. ## Schutz vor Missbrauch Der Link ist absichtlich öffentlich, deshalb hat das Formular denselben Schutz wie andere öffentliche Formulare auf uptimeify.io: ein verstecktes Honeypot-Feld, eine Mindest-Ausfüllzeit und ein Kontingent von 3 Meldungen je Absender und Stunde sowie 30 Meldungen je Formular und Stunde. Die IP-Adresse dient nur als täglich wechselndes Pseudonym für das Kontingent und wird nicht mit der Meldung gespeichert. Eine verworfene Meldung bekommt dieselbe Bestätigung wie eine angenommene. Der Link funktioniert nur mit dem Formular. Der [Webhook-Endpunkt](/de/api/incident-management/ingest-webhook) beantwortet einen Formular-Token mit `404`, und HMAC- oder Bearer-Authentifizierung gibt es für ein Meldeformular nicht. ## Personenbezogene Daten Name und E-Mail sind freiwillig, und das Formular sagt das auch. Sie stehen nur in den Rohdaten des Alarms, die wie bei jeder Quelle nach 90 Tagen geleert werden. Die Felder `description`, `since`, `impact` und `suspectedAttack` gehören wie jedes gemappte Feld zum Alarm. Für die Meldungen ist deine Organisation verantwortlich; Uptimeify verarbeitet sie in deinem Auftrag nach dem Auftragsverarbeitungsvertrag. ## Mapping Ein Meldeformular hat immer dieses feste Mapping; ein beim Anlegen mitgeschicktes `payloadMapping` wird ignoriert. Testen kannst du es mit [test-mapping](/de/api/incident-management/alert-sources-api), indem du eine `payload` mitgibst (ein Meldeformular hat keine Beispiel-Payload): ```json { "title": "title", "severity": "severity", "severityMap": { "sev1": "sev1", "sev2": "sev2", "sev3": "sev3", "sev4": "sev4" }, "dedupKey": "dedupKey", "custom": { "description": "description", "since": "since", "impact": "impact", "suspectedAttack": "suspectedAttack" } } ```
### Sentry
URL: https://docs.uptimeify.io/de/api/incident-management/alert-sources/sentry
Description: Sentry-Issue-Alarme über den Webhook einer internen Integration an Uptimeify Incident Management senden, abgebildet aus Level, Meldung und Umgebung des Events.
Summary: Uptimeify bildet mit dem Sentry-Preset die Issue-Alert-Webhook-Payload von Sentry direkt ab: Event-Meldung/Culprit, Level, Aktion, Server, Issue-Link, Umgebung und Projekt sind bereits vorab gemappt. ## 1. Alert Source in Uptimeify anlegen Gehe zu **Incident Management → Alert Sources → Neu**, wähle das **Sentry**-Preset, vergib einen Namen und lege die Source an. Kopiere auf dem Erfolgsbildschirm die Ingest-URL (`https://deine-domain/api/im/ingest/`). Sie wird nur einmal angezeigt und danach nie wieder im Klartext eingeblendet. Solltest du sie verlieren, rotiere den Token im Tab **Einstellungen** der Source. ## 2. Interne Integration in Sentry anlegen Sentry sendet Issue-Alert-Webhooks über eine **interne Integration**, nicht über ein einfaches Webhook-URL-Feld: 1. Gehe in Sentry zu **Settings → Developer Settings → New Internal Integration**. 2. Vergib einen Namen (z. B. `Uptimeify`). 3. Aktiviere den Schalter **Alert Rule Action** und setze unter **Webhooks** die **Webhook URL** auf die in Schritt 1 kopierte Ingest-URL. 4. Speichern. Dadurch entsteht eine Alert-Rule-Action, die du an beliebige Alert-Regeln der Organisation anhängen kannst. ## 3. An eine Alert-Regel anhängen 1. Gehe zu **Alerts → Rules** und lege eine neue Regel an (oder bearbeite eine bestehende) für das/die Projekt(e), dessen Alarme weitergeleitet werden sollen. 2. Füge unter **Then perform these actions** die Option **Send a notification via an integration** hinzu und wähle die in Schritt 2 erstellte interne Integration aus. 3. Speichere die Regel. Sentry ruft den Webhook jetzt auf, sobald die Bedingungen der Regel zutreffen, sowohl bei neu ausgelösten Issues als auch, wenn die Regel eine Resolve-Bedingung enthält, bei Auflösungen. ## Standard-Feld-Mapping | Sentry-Feld | Normalisiertes Feld | |---|---| | `data.event.message` (Fallback auf `data.event.culprit`) | Titel | | `data.event.level` | Schweregrad (über die Zuordnung unten) | | `action` (oberste Ebene) | Status: `resolved` löst den Alarm auf, alles andere (`triggered`, `created`, `ignored`, `assigned`, …) hält ihn offen | | `data.event.server_name` | Host. Ohne Fallback: ein Umgebungsname wie `production` nennt kein System, ein Event ohne `server_name` hat deshalb keinen Host | | `data.event.web_url` | Link zurück zum Issue in Sentry | | `data.event.environment`, `data.event.project` | Custom-Felder `environment`, `project`, am Incident als Details angezeigt | | `data.event.issue_id` | Dedup-Key: gruppiert alle Benachrichtigungen für dasselbe Sentry-Issue | ### Schweregrad-Zuordnung | Sentry `level` | Uptimeify-Schweregrad | |---|---| | `fatal` | `sev1` | | `error` | `sev2` | | `warning` | `sev3` | | `info` | `sev4` | | `debug` | `sev4` | ## Beispiel-Payload So sieht die Payload aus, die das Sentry-Preset von Uptimeify erwartet: ```json { "action": "triggered", "data": { "event": { "event_id": "fe208ee2e2e74ae08b3d4b7cdb9b4e3d", "issue_id": "123456789", "level": "error", "culprit": "raven.scripts.runner in main", "message": "This is an example python exception", "platform": "python", "environment": "production", "server_name": "web-01.prod.example.com", "web_url": "https://sentry.io/organizations/example/issues/123456789/", "issue_url": "https://sentry.io/api/0/issues/123456789/" } }, "actor": { "type": "application", "id": "sentry", "name": "Sentry" } } ``` Du kannst genau diese Payload über den Tab **Payload Mapping** im Dashboard gegen das Mapping deiner Source senden, um den Aufbau zu prüfen, bevor du eine echte Alert-Regel verbindest.
### Zabbix
URL: https://docs.uptimeify.io/de/api/incident-management/alert-sources/zabbix
Description: Zabbix-Trigger-Alarme über einen Webhook-Medientyp an Uptimeify Incident Management senden, mit dem fertigen Medientyp, den Uptimeify für dich generiert.
Summary: Uptimeify bildet mit dem Zabbix-Preset die Payload eines Zabbix-**Webhook**-Medientyps direkt ab: Trigger-Name, Schweregrad, Status und Host sind bereits vorab gemappt. Uptimeify liefert dir außerdem einen fertigen Medientyp zum Import in Zabbix, sodass du ihn weder von Hand anlegen noch das JavaScript selbst schreiben musst. ## 1. Alert Source in Uptimeify anlegen Gehe zu **Incident Management → Alert Sources → Neu**, wähle das **Zabbix**-Preset, vergib einen Namen und lege die Source an. Auf dem Erfolgsbildschirm: - Kopiere die Ingest-URL (`https://deine-domain/api/im/ingest/`). Sie wird nur einmal angezeigt. - Lade über die Aktion **Medientyp herunterladen** die Datei `uptimeify-zabbix-media-type.yaml` herunter. ## 2. Medientyp in Zabbix importieren 1. Gehe in Zabbix zu **Alerts → Media types** (Zabbix 7.x; **Administration → Media types** bei 6.x und älter) und klicke auf **Import**. 2. Wähle die heruntergeladene `uptimeify-zabbix-media-type.yaml` und bestätige. Es erscheint ein Medientyp namens **Uptimeify**. 3. Hinterlege die Ingest-URL. Entweder definierst du unter **Administration → Macros** das globale Makro `{$UPTIMEIFY.INGEST.URL}` mit der URL aus Schritt 1, oder du öffnest den Medientyp und trägst die URL direkt in dessen Parameter `ingest_url` ein. 4. Optional, für den Link **In Zabbix öffnen** an jedem Incident: definiere unter **Administration → Macros** das globale Makro `{$ZABBIX.URL}` mit der Adresse deines Zabbix-Frontends, z. B. `https://zabbix.example.com`. Ohne das Makro tragen Incidents einfach keinen Link. 5. Aktiviere den Medientyp. Du nutzt schon einen älteren Uptimeify-Medientyp? Importiere die Datei erneut darüber. Ältere Versionen senden weder IP noch Item, letzten Wert, Tags oder den Event-Link, und der Incident zeigt dann nichts davon. Die Ingest-URL muss ein Medientyp-**Parameter** sein. Zabbix löst Makros ausschließlich in Parameter-Werten auf, niemals im Script-Body, ein `{$UPTIMEIFY.INGEST.URL}` im JavaScript würde wörtlich als Ziel-Zeichenkette verwendet, und es käme nie ein Alarm an. ### Was der Medientyp sendet Der importierte Medientyp deklariert je einen Parameter pro Feld, das im Preset gemappt ist. Die Payload passt damit ohne weitere Anpassung auf die Selektoren des Presets: | Parameter | Zabbix-Makro | Wofür | |---|---|---| | `ingest_url` | `{$UPTIMEIFY.INGEST.URL}` | Ziel des POST | | `event_id` | `{EVENT.ID}` | Dedup-Key, bleibt in der Entwarnung die ID des Problem-Events und führt beide zu einem Vorfall zusammen | | `event_severity` | `{EVENT.SEVERITY}` | Schweregrad (siehe Tabelle unten) | | `trigger_name` | `{EVENT.NAME}` | Titel | | `trigger_status` | `{EVENT.STATUS}` | `RESOLVED` löst den Alarm auf, alles andere hält ihn offen | | `host_name` | `{HOST.NAME}` | Host | | `host_ip` | `{HOST.IP}` | Detail: IP der Host-Schnittstelle | | `item_name`, `item_value` | `{ITEM.NAME1}`, `{ITEM.LASTVALUE1}` | Details: das erste Item des Triggers und sein letzter Wert | | `event_tags` | `{EVENT.TAGS}` | Detail: die Event-Tags, gesendet als `tag:wert · tag:wert` | | `trigger_id`, `zabbix_url` | `{TRIGGER.ID}`, `{$ZABBIX.URL}` | Der Link zum Event: `{$ZABBIX.URL}/tr_events.php?triggerid=…&eventid=…` | | `event_source`, `event_value`, `date`, `time` | jeweiliges Makro | Kontext | Ein Makro, das Zabbix nicht auflösen kann (`*UNKNOWN*` oder ein nicht definiertes `{$ZABBIX.URL}`), bleibt aus der Payload weg, statt angezeigt zu werden. Das Skript wertet HTTP 200/202 als Erfolg und wirft bei allem anderen einen Fehler, eine fehlgeschlagene Zustellung erscheint damit in Zabbix als fehlgeschlagener Versuch, statt still zu verschwinden. Ein `404` bedeutet dort, dass der Token in deiner Ingest-URL zu keiner Alarmquelle gehört. ### Zustellung und Wiederholungen Uptimeify antwortet innerhalb weniger Sekunden: `202`, sobald der Alarm dauerhaft gespeichert ist, `503`, wenn er nicht gespeichert werden konnte. Der Medientyp versucht es **30-mal im…
### Analytics
URL: https://docs.uptimeify.io/de/api/incident-management/analytics
Description: Incident-Volumen, MTTA und MTTR pro Tag, das Verhältnis von Alerts zu Incidents und die On-Call-Last pro Person für einen Zeitraum, in einem Aufruf.
Summary: `GET /api/im/analytics` Liefert die Daten der Analytics-Seite im Incident Management für einen Zeitraum: Incident-Volumen mit MTTA und MTTR pro lokalem Tag, das tägliche Alert-Rauschen und die On-Call-Minuten pro Person. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token. Incident Management muss für die Organisation aktiviert sein. ## Query-Parameter | Parameter | Typ | Erforderlich | Beschreibung | |-----------|------|----------|--------------| | `from` | ISO 8601 | Ja | Beginn des Zeitraums (einschließlich). | | `to` | ISO 8601 | Ja | Ende des Zeitraums (ausschließlich). Muss nach `from` liegen, höchstens 400 Tage später. | | `tz` | number | Nein | Dein UTC-Versatz in Minuten (z. B. `120` für UTC+2). Standard `0`, begrenzt auf plus/minus 1440. Schneidet `volumeTrend` in lokale Tage. Keine Ganzzahl: `400`. | ## Beispiel (cURL) ```bash curl "$BASE_URL/api/im/analytics?from=2026-09-01T00:00:00Z&to=2026-10-01T00:00:00Z&tz=120" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort (Response) ```json { "from": "2026-09-01T00:00:00.000Z", "to": "2026-10-01T00:00:00.000Z", "volumeTrend": [ { "day": "2026-09-01T22:00:00.000Z", "count": 4, "mttaMinutes": 3.5, "mttrMinutes": 47.25 }, { "day": "2026-09-02T22:00:00.000Z", "count": 1, "mttaMinutes": null, "mttrMinutes": null } ], "noiseQuote": [ { "day": "2026-09-02", "alerts": 38, "deduped": 29, "incidents": 4 } ], "onCallLoad": [ { "userId": "u_abc123", "userName": "Jana Weber", "minutes": 10080 } ] } ``` | Feld | Beschreibung | |-------|-------------| | `volumeTrend[].day` | UTC-Zeitpunkt der lokalen Mitternacht dieses Tages (um `tz` verschoben). Formatiere ihn in deiner eigenen Zeitzone. Nur Tage mit Incidents erscheinen. | | `volumeTrend[].count` | An diesem Tag ausgelöste Incidents. Test-Incidents zählen nicht mit. | | `volumeTrend[].mttaMinutes` | Durchschnittliche Minuten vom Auslösen bis zur Bestätigung, über die bestätigten Incidents. `null`, wenn keiner bestätigt wurde. | | `volumeTrend[].mttrMinutes` | Durchschnittliche Minuten vom Auslösen bis zur Lösung, über die gelösten Incidents. `null`, wenn keiner gelöst wurde. | | `noiseQuote[]` | Pro UTC-Kalendertag (`YYYY-MM-DD`, nicht um `tz` verschoben), summiert über alle Alert-Sources: eingehende `alerts`, `deduped` (in einen offenen Alert eingeflossen) und geöffnete `incidents`. Umfasst jeden Tag vom Datum von `from` bis zum Datum von `to`. | | `onCallLoad[]` | On-Call-Minuten pro Person innerhalb des Zeitraums, dieselben Daten wie im [On-Call-Bericht](/de/api/incident-management/reports#on-call-bericht). | ## Häufige Fehler - `401 Unauthorized` (`unauthorized`) wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei einem kunden-gescopten Token - `403 Forbidden` (`imAccessDenied`) wenn deine Session keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `400 Bad Request` (`imReportRangeRequired`) wenn `from` oder `to` fehlt oder kein gültiges Datum ist - `400 Bad Request` (`imReportRangeInvalid`) wenn `from` nicht vor `to` liegt - `400 Bad Request` (`imReportRangeTooLarge`) wenn der Zeitraum 400 Tage überschreitet - `400 Bad Request` (`invalidRequestBody`) wenn `tz` keine Ganzzahl ist
### Audit-Log
URL: https://docs.uptimeify.io/de/api/incident-management/audit-log
Description: Das Audit-Log des Incident Managements lesen: wer welches Team, welchen Schedule, welche Source oder Einstellung angelegt, geändert oder gelöscht hat, mit dem aufgezeichneten Diff. Cursor-paginiert.
Summary: `GET /api/im/audit-log` Liefert das Audit-Log des Incident Managements deiner Organisation, neueste Einträge zuerst: jedes Anlegen, Ändern und Löschen von Teams, Mitgliedern, Schedules, Overrides, Eskalationsstufen, Alert-Sources, Routing-Regeln, Kanälen und IM-Einstellungen, mit der handelnden Person und der aufgezeichneten Änderung. ## Authentifizierung Erfordert IM-Zugriff **und** die Organisationsrolle `admin`. Editoren und Responder werden abgewiesen. Ein organisationsweiter API-Token funktioniert, wenn ein Organisations-Admin ihn erstellt hat (ein Token trägt die Rolle der Person, die ihn erstellt hat). Incident Management muss für die Organisation aktiviert sein. ## Query-Parameter | Parameter | Typ | Beschreibung | |-----------|------|--------------| | `entityType` | string | Nur dieser Entitätstyp, z. B. `im_team`, `im_team_member`, `im_schedule`, `im_schedule_override`, `im_escalation_tier`, `im_alert_source`, `im_routing_rule`, `im_channel`, `im_incident`, `im_org_settings`. | | `actor` | string | Nur Einträge dieser User-ID. | | `from` | ISO 8601 | Nur Einträge ab diesem Zeitpunkt. Ein ungültiges Datum wird mit `400` abgewiesen. | | `to` | ISO 8601 | Nur Einträge bis zu diesem Zeitpunkt. Ein ungültiges Datum wird mit `400` abgewiesen. | | `limit` | number | Seitengröße, eine positive Ganzzahl. Standard 50, größere Werte zählen als 200. | | `before` | number | Cursor: `nextCursor` der vorigen Seite übergeben, um weiterzublättern. | | `envelope` | string | `items`: Antwort als `{ items, nextCursor, hasMore }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash curl "$BASE_URL/api/im/audit-log?entityType=im_alert_source&limit=2&envelope=items" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort (Response) ```json { "items": [ { "id": 5812, "entityType": "im_alert_source", "entityId": "7", "action": "update", "diff": { "ingestToken": { "from": "rotated", "to": "rotated" }, "secondaryExpiresAt": { "from": null, "to": "2026-10-16T09:30:00.000Z" } }, "at": "2026-10-09T09:30:00.000Z", "actorUserId": "u_abc123", "actorName": "Jana Weber" }, { "id": 5790, "entityType": "im_alert_source", "entityId": "7", "action": "create", "diff": { "name": "Zabbix production", "type": "zabbix", "teamId": 3, "autoResolve": true }, "at": "2026-10-01T08:00:00.000Z", "actorUserId": "u_abc123", "actorName": "Jana Weber" } ], "hasMore": true, "nextCursor": "5790" } ``` **Listenform:** Mit `envelope=items` kommt die Seite als `{ items, nextCursor, hasMore }`, `nextCursor` als String. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (`{ entries, hasMore, nextCursor }`, `nextCursor` als Zahl); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. | Feld | Beschreibung | |-------|-------------| | `action` | `create`, `update` oder `delete`. | | `diff` | Frei geformtes Objekt, das mit der Änderung gespeichert wurde, bei Änderungen meist `{ feld: { from, to } }`. Secrets werden nie aufgezeichnet, Rotationen erscheinen als `"rotated"` oder `"set"`. | | `actorUserId`, `actorName` | Wer die Änderung vorgenommen hat. Beide `null`, wenn das Benutzerkonto inzwischen gelöscht wurde. | | `hasMore`, `nextCursor` | Ist `hasMore` `true`, holst du die nächste Seite mit `before=`. Auf der letzten Seite ist `nextCursor` `null`. | ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `from` oder `to` kein Datum ist oder `limit` oder `before` keine positive Ganzzahl - `401 Unauthorized` (`unauthorized`) wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei einem kunden-gescopten Token - `403 Forbidden` (`imAccessDenied`) wenn deine Session keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `403 Forbidden` (`imAuditLogAccessDenied`) wenn deine Rolle nicht `admin` ist
### Incidents gesammelt ändern
URL: https://docs.uptimeify.io/de/api/incident-management/bulk-update-incidents
Description: Wendet eine Aktion (bestätigen, lösen, Schweregrad, zuweisen) auf bis zu 200 Incident-Management-Incidents gleichzeitig an, mit Ergebnis je Incident.
Summary: `POST /api/im/incidents/bulk` Wendet eine Aktion auf viele Incidents an, etwa um während eines großen Ausfalls Dutzende Incidents auf einmal zu bestätigen oder zu lösen. Jeder Incident durchläuft genau dieselbe Logik wie beim Einzel-Endpunkt, mit denselben Nebenwirkungen (Eskalation stoppen oder neu scharf schalten, Statusseiten, ausgehende Integrationen). Die Incidents werden einzeln und unabhängig voneinander verarbeitet: ein scheiternder Incident macht die anderen weder rückgängig noch blockiert er sie, die Anfrage ist also **nicht** atomar. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. Jede Aktion außer `acknowledge` ist den Teams der Incidents vorbehalten: du musst Mitglied im Team **jedes** ausgewählten Incidents oder Organisations-Admin sein. Das wird für alle IDs geprüft, bevor irgendetwas geändert wird; gehört auch nur ein Incident nicht zu dir, wird die ganze Anfrage mit `403` abgelehnt und die betroffenen IDs stehen in `data.deniedIncidentIds`. Ein organisationsweiter API-Token gilt dabei als Organisations-Admin. ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|--------------| | `ids` | number[] | Ja | 1 bis 200 Incident-IDs, eindeutige positive Ganzzahlen. | | `action` | string | Ja | Einer von `acknowledge`, `resolve`, `severity`, `assign`, `team`. | | `payload` | object | Je nach `action` | Siehe unten. | | `action` | `payload` | Entspricht | |----------|-----------|---------| | `acknowledge` | keins | [Bestätigen](/de/api/incident-management/acknowledge-incident#bestätigen). Ein bereits bestätigter Incident zählt als `ok`. | | `resolve` | `note` (string, optional, höchstens 10.000 Zeichen) | [Incident lösen](/de/api/incident-management/resolve-incident) | | `severity` | `severity` (Pflicht, `sev1` bis `sev4`) | [Schweregrad ändern](/de/api/incident-management/incident-severity) | | `assign` | `userId` (Pflicht: eine User-ID, oder `null`, um die Rolle zu leeren), `role` (optional, Standard `assignee`) | [Rolle zuweisen](/de/api/incident-management/incident-assign#rolle-zuweisen) | | `team` | `teamId` (Pflicht) | Nicht umgesetzt, antwortet immer mit `501` | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents/bulk" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "ids": [42, 43, 44], "action": "resolve", "payload": { "note": "Upstream provider outage resolved." } }' ``` ## Antwort (Response) `200 OK`, auch wenn einzelne Incidents gescheitert sind. `ok` listet die geänderten IDs, `failed` die übrigen mit einem `reason`: dem `data.code`, den der Einzel-Endpunkt geliefert hätte (z. B. `imIncidentNotFound`, `imIncidentAlreadyClosed`, `imIncidentStatusConflict`, `invalidUserId`), oder `unknown`. ```json { "ok": [42, 43], "failed": [ { "id": 44, "reason": "imIncidentAlreadyClosed" } ] } ``` ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `403 Forbidden` (`imTeamMembershipRequired`) wenn die Aktion nicht `acknowledge` ist und mindestens ein ausgewählter Incident zu einem Team gehört, in dem du nicht Mitglied bist (und du nicht Organisations-Admin bist); `data.deniedIncidentIds` listet sie, geändert wurde nichts - `400 Bad Request` (`invalidRequestBody`) wenn `ids` leer ist, mehr als 200 Einträge, Duplikate oder keine positiven Ganzzahlen enthält, `action` unbekannt ist, oder das Payload zur Aktion ungültig ist (fehlende oder unbekannte `severity`, fehlende `userId`, unbekannte `role`, `note` kein String o…
### Kanäle
URL: https://docs.uptimeify.io/de/api/incident-management/channels
Description: Paging-Kanäle im Incident Management (Webhook, Slack, E-Mail) auflisten, anlegen, ändern und löschen, inklusive der Nur-Schreiben-Behandlung von Webhook-URLs und Headern.
Summary: `GET /api/im/channels` · `POST /api/im/channels` · `GET /api/im/channels/:id` · `PATCH /api/im/channels/:id` · `DELETE /api/im/channels/:id` Ein **Kanal** ist ein gemeinsames Paging-Ziel deiner Organisation: ein generischer Webhook, ein eingehender Slack-Webhook oder eine E-Mail-Adresse. Ein Kanal gilt entweder organisationsweit (`teamId: null`) oder gehört zu einem [Team](/de/api/incident-management/teams). Ein Kanal kann in den [Organisationseinstellungen](/de/api/incident-management/org-settings) als Fallback-Kanal der Organisation gesetzt werden, als letzte Instanz, wenn einer Eskalation die Stufen ausgehen. ## Authentifizierung Erfordert den Basiszugriff auf Incident Management, den jeder Endpunkt dieser API braucht (eine IM-berechtigte Rolle `admin`, `editor` oder `responder`, oder ein organisationsweites API-Token; Incident Management muss für die Organisation aktiviert sein). Lesen darf jede IM-berechtigte Rolle. Einen organisationsweiten Kanal zu **schreiben** erfordert die Rolle `admin`. Einen Team-Kanal zu schreiben erfordert die Rolle `admin` oder eine Team-Admin-Mitgliedschaft in diesem Team. Ein organisationsweites API-Token läuft mit der Rolle der Person, die es erstellt hat; ein Token, das ein Organisations-Admin erstellt hat, darf also jeden Kanal schreiben. Eine Team-Admin-Mitgliedschaft gilt für ein Token nie. ## Kanaltypen und `config` | `type` | Pflichtfelder in `config` | Optionale Felder in `config` | |--------|--------------------------|--------------------------| | `webhook` | `webhookUrl` | `headers` (Objekt aus Header-Name und Wert) | | `slack` | `webhookUrl` | `headers` | | `email` | `email` | | - `webhookUrl` muss eine `http`- oder `https`-URL mit öffentlichem Hostnamen sein. Private, Loopback- und reservierte IP-Adressen, `localhost`, `*.local`, `*.internal`, `home.arpa` und Hostnamen ohne Punkt werden abgelehnt. - `headers` darf den `Host`-Header nicht setzen. Header-Namen müssen gültige HTTP-Headernamen sein, Werte dürfen keinen Zeilenumbruch und kein anderes Steuerzeichen enthalten, und die Header, die der Versand selbst setzt (`Content-Length`, `Transfer-Encoding`, `Connection`, `Keep-Alive`, `Upgrade`, `TE`, `Trailer`, `Expect`, `Proxy-Connection`), werden abgewiesen. `Authorization` ist erlaubt. Das gilt beim Anlegen und beim Aktualisieren. - `config` darf als JSON höchstens 8 KB groß sein. Weitere Schlüssel werden so gespeichert, wie du sie schickst. - Geheimfelder eines anderen Typs werden verworfen, nicht gespeichert: `webhookUrl` und `headers` bei einem `email`-Kanal. Ein Wechsel von `type` auf `email` entfernt auch die gespeicherte `webhookUrl` und die `headers`. **`webhookUrl` und Header-Werte sind nur schreibbar.** Sie werden verschlüsselt gespeichert und nie zurückgegeben. Jede Antwort ersetzt sie: `webhookUrl` ist `null`, und `hasWebhookUrl` sagt, ob eine URL gespeichert ist; `headers` behält die Header-Namen mit `null` als Wert, und `hasHeaders` sagt, ob überhaupt ein Header gespeichert ist. ## Kanäle auflisten `GET /api/im/channels` Liefert alle Kanäle deiner Organisation (organisationsweite und Team-Kanäle), nach Name sortiert, mit aufgelöstem Teamnamen. ### Query-Parameter | Parameter | Typ | Standard | Beschreibung | |-----------|------|---------|-------------| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/channels?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ### Antwort (Response) `200 OK` ```json { "items": [ { "id": 9, "organizationId": 1, "teamId": 3, "teamName": "Platform Team", "type": "webhook", "name": "Ops webhook", "config": { "webhookUrl": null, "headers": { "X-Api-Key": null }, "hasWebhookUrl": true, "hasHeaders": true }, "isActive": true, "createdAt": "2026-09-20T10:00:00.000Z", "updatedAt": "2026-09-20T10:00:00.000Z" }, { "id": 10, "organizationId": 1, "teamId": null, "teamName": null, "type": "em…
### Incident erstellen
URL: https://docs.uptimeify.io/de/api/incident-management/create-incident
Description: Erstellt einen Incident-Management-Incident für ein Team von Hand; die Eskalation startet kurz nach dem Anlegen, mit demselben Paging-Verhalten wie bei einem Incident aus einem Alert.
Summary: `POST /api/im/incidents` Erstellt einen Incident von Hand, außerhalb der Alert-Ingest-Pipeline, etwa für etwas, das ein Mensch vor jedem Monitoring-Tool bemerkt hat. Ein manuell erstellter Incident ist kein Incident zweiter Klasse: Tier 1 der Eskalation des Teams wird kurz nach dem Anlegen scharf geschaltet, genau wie bei einem Incident aus einem eingespeisten Alert. Das passiert erst nach dieser Antwort, die Antwort zeigt also den Incident-Datensatz so, wie er gespeichert wurde, bevor die Eskalation beginnt (siehe `currentTier` unten). ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. Zum Anlegen brauchst du zusätzlich die **Schreibberechtigung** für das Ziel-Team: Organisations-`admin` oder *Team-Admin* dieses Teams (Team-Mitglied mit `imRole: "admin"`). Ein organisationsweiter API-Token gilt dabei als Organisations-Admin. ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|--------------| | `teamId` | number | Ja | Das Team, dem der Incident gehört und dessen Eskalations-Tiers Personen alarmieren. Muss zu deiner Organisation gehören. | | `title` | string | Ja | Titel des Incidents, nicht leer, höchstens 10.000 Zeichen. | | `severity` | string | Ja | Einer von `sev1`, `sev2`, `sev3`, `sev4`. Ein manueller Incident hat keinen Alert-Strom, aus dem sich der Schweregrad ableiten ließe, er wird deshalb immer mit `severityManual: true` angelegt. | | `customerId` | number oder null | Nein | Ordnet den Incident einem Kunden zu. Muss, falls angegeben, zu deiner Organisation gehören. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "teamId": 3, "title": "Database connection pool exhausted", "severity": "sev1" }' ``` ## Antwort (Response) `200 OK`: der neu angelegte Incident-Datensatz (gleiche Form wie die `items` von [Incidents auflisten](/de/api/incident-management/list-incidents), ohne die Ergänzungsfelder). ```json { "id": 42, "organizationId": 1, "teamId": 3, "title": "Database connection pool exhausted", "customerId": null, "primarySourceId": null, "severity": "sev1", "severityManual": true, "status": "triggered", "mergedIntoId": null, "escalationPolicyId": null, "currentTier": null, "escalationEpoch": 0, "escalationCycle": 0, "acknowledgedBy": null, "acknowledgedAt": null, "snoozedUntil": null, "autoResolve": true, "resolvedBy": null, "resolveNote": null, "statuspageUpdate": null, "createdBy": null, "sourceKind": "manual", "isTest": false, "triggeredAt": "2026-07-17T09:12:00.000Z", "resolvedAt": null } ``` `sourceKind` ist `manual` und `primarySourceId` ist `null`: ein manuell erstellter Incident hat keine Alert-Source. `createdBy` ist bei einer Browser-Session die User-ID der anlegenden Person und bei einem API-Token `null`. Das Scharfschalten der ersten Eskalation und die Weitergabe an ausgehende Integrationen laufen nach dem Speichern auf Best-Effort-Basis: der Incident existiert garantiert, auch wenn Paging oder eine Integration scheitert; ein solcher Fehler wird serverseitig protokolliert und erscheint nicht in dieser Antwort. Weil die Eskalation erst nach der Antwort startet, ist `currentTier` hier immer `null`. Mit [Incident abrufen](/de/api/incident-management/get-incident) siehst du den Tier, sobald die Eskalation läuft. ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `403 Forbidden` (`imTeamWriteDenied`) wenn du weder Organisations-Admin noch Team-Admin v…
### Vorschlag zum Zusammenführen verwerfen
URL: https://docs.uptimeify.io/de/api/incident-management/dismiss-merge-suggestion
Description: Verwirft den Vorschlag, dass ein Incident-Management-Vorfall derselbe ist wie ein offener Vorfall aus einer anderen Quelle.
Summary: `POST /api/im/incidents/:id/dismiss-merge-suggestion` Beim Anlegen eines Vorfalls sucht Incident Management offene Vorfälle aus anderen Alert-Quellen Ihrer Organisation, die vermutlich derselbe sind (gleicher Dienst oder gleicher Host, höchstens 15 Minuten auseinander ausgelöst), und listet sie in `mergeSuggestions` von [Incident abrufen](/de/api/incident-management/get-incident). Zusammengeführt wird nie automatisch. Dieser Endpunkt verwirft einen Vorschlag, der nicht stimmt; zum Annehmen dient [Incidents zusammenführen](/de/api/incident-management/merge-incidents). Das Verwerfen steht in der Timeline des Vorfalls (`merge_suggestion_dismissed`, Payload `{ targetIncidentId }`) und im Audit-Protokoll der Organisation. Sonst ändert sich an keinem der beiden Vorfälle etwas, niemand wird benachrichtigt. ## Authentifizierung Jede IM-berechtigte Rolle oder ein organisationsweites API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Dieselben Rechte wie beim Zusammenführen: Sie müssen Mitglied im Team des Vorfalls `:id` oder `admin` der Organisation sein. ## Request-Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `targetIncidentId` | integer | Ja | Die `incidentId` des Vorschlags aus `mergeSuggestions`. | ```bash curl -X POST "$BASE_URL/api/im/incidents/43/dismiss-merge-suggestion" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "targetIncidentId": 41 }' ``` ## Antwort `200 OK`: ```json { "ok": true } ``` ## Häufige Fehler - `401 Unauthorized`, wenn nicht angemeldet - `403 Forbidden` (`imTeamMembershipRequired`), wenn Sie weder Mitglied im Team des Vorfalls noch `admin` der Organisation sind - `400 Bad Request` (`invalidRequestBody`), wenn `targetIncidentId` fehlt, keine positive Ganzzahl ist oder der Body weitere Felder hat - `404 Not Found` (`imIncidentNotFound`), wenn der Vorfall nicht existiert oder einer anderen Organisation gehört - `404 Not Found` (`imMergeSuggestionNotFound`), wenn der Vorfall keinen offenen Vorschlag für `targetIncidentId` hat (nie vorgeschlagen oder schon verworfen)
### Events Ingest
URL: https://docs.uptimeify.io/de/api/incident-management/events-ingest
Description: Öffentlicher Alert-Ingest-Endpunkt für Incident Management. Beliebiges JSON-Alert-Payload aus deinem eigenen Monitoring- oder Alerting-System senden; es wird asynchron zu einem Incident verarbeitet.
Summary: `POST /api/im/events` Nimmt ein beliebiges JSON-Alert-Payload aus deinem eigenen Monitoring- oder Alerting-System entgegen und stellt es zur asynchronen Verarbeitung in Incident Management in die Queue. Dies ist der primäre Integrations-Endpunkt, um Alerts aus Drittsystemen einzuspeisen. ## Authentifizierung Erfordert einen **organisationsweiten** API-Token (`Authorization: Bearer wsm_...`, erstellt ohne `customerId`, siehe [Organisations-Token erstellen](/de/api/api-tokens/create-organization-token)). Ein kunden-gescopter Token wird mit `403 Forbidden` (`customerScopedTokenForbidden`) abgelehnt. Incident Management muss außerdem für die Organisation aktiviert sein, sonst wird die Anfrage mit `403 Forbidden` (`imNotEnabled`) abgelehnt. ## Rate Limit 600 Anfragen pro Minute pro Organisation, nicht pro IP. Ein Monitoring-System, das über viele Quell-IPs verteilt sendet, teilt sich ein Kontingent mit seiner Organisation. ## Anfrage (Request Body) Ein beliebiges JSON-Objekt. Das Payload wird gegen eine `api`-Alert-Source gespeichert, die beim ersten Aufruf dieses Endpunkts automatisch für deine Organisation angelegt wird, und anhand des Feld-Mappings dieser Source in einen Alert überführt. Es gibt kein festes Request-Schema. Sende, was dein Alerting-System liefert. Die automatisch angelegte Source liest standardmäßig diese Felder, das erste vorhandene gewinnt: | Alert-Feld | Gelesen aus | |------------|-------------| | Titel | `title`, `summary`, `subject`, `message`, `alertname`, `labels.alertname` | | Schweregrad | `severity`, `level`, `priority`, `labels.severity` | | Status | `status`, `state` | | Dedup-Schlüssel | `dedup_key`, `dedupKey`, `fingerprint`, `groupKey`, `id` | | Host (welches System) | `host`, `hostname`, `instance`, `labels.instance` | | URL (Link zurück zum Ursprung) | `url`, `link`, `generatorURL` | Eine Source, deren Mapping du geändert hast, behält dein Mapping. Limits, die vor dem Einreihen in die Queue geprüft werden: | Limit | Wert | Fehler | |-------|-------|---------| | Body-Größe | 256 KB | `413 Payload Too Large` (`payloadTooLarge`) | | JSON-Verschachtelungstiefe | 20 Ebenen | `422 Payload too deep` (`payloadTooDeep`) | | Gültiges JSON-Objekt oder -Array | Pflicht | `422 Invalid JSON` (`invalidJson`) | Ein leerer Request-Body wird als `{}` behandelt. ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/events" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "title": "Database connection pool exhausted", "severity": "critical", "host": "db-primary-01" }' ``` ## Antwort (Response) `202 Accepted`: der Alert wurde eingereiht, aber noch nicht verarbeitet. Es gibt keine synchrone Incident- oder Alert-ID in der Antwort. ```json { "accepted": true } ``` ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `413 Payload Too Large` (`payloadTooLarge`) wenn der Body 256 KB überschreitet - `422 Invalid JSON` (`invalidJson`) wenn der Body kein gültiges JSON ist oder ein einzelner Wert (`5`, `"text"`, `null`) statt Objekt oder Array - `422 Payload too deep` (`payloadTooDeep`) wenn das geparste JSON mehr als 20 Ebenen verschachtelt ist - `429 Too Many Requests` wenn deine Organisation 600 Anfragen/Minute überschreitet (siehe `retryAfter` im Antwort-Body) - `503 Service Unavailable` (`unavailable`) wenn der Alert gar nicht gespeichert werden konnte, innerhalb weniger Sekunden; angenommen wurde nichts, also wiederholen. Ein `202` heißt, der Alert ist dauerhaft gespeichert, auch wenn unsere Warteschlange kurz nicht erreichbar ist
### Incident abrufen
URL: https://docs.uptimeify.io/de/api/incident-management/get-incident
Description: Liefert die vollständigen Details eines einzelnen Incident-Management-Incidents: den Incident-Datensatz sowie seine Alerts, Timeline-Events und Rollen-Zuweisungen.
Summary: `GET /api/im/incidents/:id` Liefert die vollständigen Details eines einzelnen Incidents: den Incident-Datensatz sowie seine Alerts (eine sichere, geschwärzte Sicht, siehe unten), Timeline-Events in chronologischer Reihenfolge und Rollen-Zuweisungen. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/incidents/42" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "id": 42, "organizationId": 1, "teamId": 3, "title": "Database connection pool exhausted", "customerId": null, "primarySourceId": 7, "severity": "sev1", "severityManual": false, "status": "triggered", "mergedIntoId": null, "escalationPolicyId": null, "currentTier": 1, "escalationEpoch": 0, "escalationCycle": 0, "acknowledgedBy": null, "acknowledgedAt": null, "snoozedUntil": null, "autoResolve": true, "resolvedBy": null, "resolveNote": null, "statuspageUpdate": null, "createdBy": null, "sourceKind": "alert", "isTest": false, "category": null, "isNearMiss": false, "triggeredAt": "2026-07-17T09:12:00.000Z", "resolvedAt": null, "serviceId": null, "statuspageRuleApplies": false, "customerName": null, "customerPublicId": null, "monitoringIncidentPublicId": null, "hasReportCase": false, "reportCasePublicId": null, "postmortemStatus": "none", "needsPostmortem": false, "canManagePostmortem": false, "mergeSuggestions": [ { "incidentId": 41, "title": "db-primary-01 unreachable", "reason": "host", "suggestedAt": "2026-07-17T09:12:01.000Z" } ], "alerts": [ { "id": 101, "organizationId": 1, "sourceId": 7, "dedupKey": "db-primary-01:pool-exhausted", "status": "open", "suppressedReason": null, "title": "Database connection pool exhausted", "severity": "sev1", "host": "db-primary-01", "mappedFields": {}, "duplicateCount": 0, "firstSeenAt": "2026-07-17T09:12:00.000Z", "resolvedAt": null, "incidentId": 42 } ], "events": [ { "id": 501, "incidentId": 42, "at": "2026-07-17T09:12:00.000Z", "kind": "alert_received", "actorUserId": null, "actorName": null, "payload": {} }, { "id": 502, "incidentId": 42, "at": "2026-07-17T09:15:00.000Z", "kind": "acknowledged", "actorUserId": "u_abc123", "actorName": "Jane Doe", "payload": {} } ], "assignments": [ { "id": 12, "userId": "u_abc123", "userName": "Jane Doe", "role": "commander", "createdAt": "2026-07-17T09:15:00.000Z" } ], "publicUpdates": [ { "id": 17, "publicId": "6f1d2c3b-4a5e-4f60-8a7b-9c0d1e2f3a4b", "status": "investigating", "body": "We are investigating slow logins.", "createdAt": "2026-07-17T09:20:00.000Z", "createdByUserId": "u_abc123" } ] } ``` `publicUpdates` ist die öffentliche Timeline des Incidents, älteste zuerst und append-only: ein Eintrag je Text, der über [Statusseiten-Text aktualisieren](/de/api/incident-management/incident-statuspage-update) gesetzt wurde, jeweils mit `status` (`investigating`, `identified`, `monitoring`, `resolved`), `body`, `createdAt` und `createdByUserId` (`null`, sobald die Person gelöscht ist). Öffentliche Statusseiten zeigen sie ohne die Person. `statuspageRuleApplies` ist `true`, wenn eine Statusseiten-Regel des Teams für diesen Incident eine Statusseite umschalten würde (eine Regel für sein Team, deren Mindestschwere er erreicht). `statuspageUpdate` ist der kuratierte Text, der dort erscheint (setzen mit [Statusseiten-Text aktualisieren](/de/api/incident-management/incident-statuspage-update)). `customerName` und `customerPublicId` benennen den Kunden aus `customerId`; beide sind `null`, wenn der Incident keinem Kunden zugeordnet ist. `monitoringIncidentPublicId` ist die öffentliche ID des Uptimeify-Monitoring-Vorfalls, aus dem dieser Incident über die Monitoring-Bridge entstand (Quelltyp `uptimeify_monitoring`), etwa für einen Link auf `/dashboard/system/incidents/`. Bei jeder ande…
### Incident-Rollen zuweisen
URL: https://docs.uptimeify.io/de/api/incident-management/incident-assign
Description: Setzt die Inhaberin einer Incident-Rolle (Commander, Tech Lead, Comms, Assignee) oder fügt einem Incident-Management-Incident eine weitere Responderin hinzu, auf Wunsch mit Alarmierung.
Summary: Ein Incident hat vier Rollen: `commander`, `tech_lead`, `comms` und `assignee`. Zwei Endpunkte verwalten, wer sie hält: - [Rolle zuweisen](#rolle-zuweisen) setzt die **einzige** Inhaberin einer Rolle und ersetzt, wer sie vorher hatte. - [Responder hinzufügen](#responder-hinzufügen) fügt einer Rolle eine **weitere** Person hinzu, ohne jemanden zu entfernen, und kann sie sofort alarmieren. Die aktuellen Rolleninhaber stehen in `assignments` von [Incident abrufen](/de/api/incident-management/get-incident). Jede Änderung wird in der Timeline des Incidents vermerkt. Um eine Rolle zu leeren, nutze die Aktion `assign` von [Incidents gesammelt ändern](/de/api/incident-management/bulk-update-incidents) mit `userId: null`. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. **Wer zugewiesen werden kann:** die Person in `userId` muss zu deiner Organisation gehören. Bist du nicht Organisations-Admin (ein organisationsweiter API-Token gilt als solcher), muss sie außerdem Mitglied im Team des Incidents sein. ## Rolle zuweisen `POST /api/im/incidents/:id/assign` ### Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|--------------| | `userId` | string | Ja | User-ID der neuen Rolleninhaberin. | | `role` | string | Ja | Einer von `commander`, `tech_lead`, `comms`, `assignee`. | ### Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents/42/assign" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "userId": "MFcTjWmYq2LpzR8vK1sXo", "role": "commander" }' ``` ### Antwort (Response) `200 OK`: die neue Zuweisung. ```json { "id": 12, "incidentId": 42, "userId": "MFcTjWmYq2LpzR8vK1sXo", "role": "commander", "createdAt": "2026-07-17T09:15:00.000Z", "user": { "name": "Grace Hopper", "email": "grace@example.com" } } ``` `user.email` ist nur für Organisations-Admins gefüllt (und damit für einen normalen organisationsweiten API-Token); für jede andere Rolle steht dort `null`. ### Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imTeamMembershipRequired`) wenn du kein Mitglied im Team des Incidents und kein Organisations-`admin` bist - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `400 Bad Request` (`invalidRequestBody`) wenn `:id` keine positive Ganzzahl ist, `role` fehlt oder unbekannt ist, oder `userId` fehlt oder leer ist - `404 Not Found` (`imIncidentNotFound`) wenn der Incident nicht existiert oder zu einer anderen Organisation gehört - `422 Unprocessable Entity` (`invalidUserId`) wenn `userId` nicht existiert oder nicht zu deiner Organisation gehört - `422 Unprocessable Entity` (`imIncidentAssigneeNotOnTeam`) wenn du nicht Organisations-Admin bist und `userId` nicht Mitglied im Team des Incidents ist ## Responder hinzufügen `POST /api/im/incidents/:id/add-responder` Holt eine weitere Person dazu, etwa eine Spezialistin, die die Eskalations-Tiers nie erreichen würden. Mit `notify: true` startet ihre Alarmierung sofort, beim aktuellen Tier des Incidents und mit der Dringlichkeit seines Schweregrads. Das Hinzufügen ist dem Team des Incidents vorbehalten: du musst Mitglied im Team des Incidents oder Organisations-Admin sein. Mit `notify: true` musst du **Team-Admin** des Teams oder Organisations-Admin sein. Ein organisationsweiter API-Token erfüllt beides als Organisations-Admin. ### Anfrage (Request Body) | Feld | Typ | Erforderlich | Standard | Beschreibung | |-------|------|----------|---------|-------------| | `userId` | string | Ja | | User-ID der Responderin. | | `role` | string…
### Incident zu einem Monitoring-Incident finden
URL: https://docs.uptimeify.io/de/api/incident-management/incident-by-monitor
Description: Ermittelt zu einer Monitoring-Incident-ID den Incident-Management-Incident, in den er übernommen wurde.
Summary: `GET /api/im/incidents/by-monitor/:id` Ist die Monitoring-Brücke eingeschaltet (siehe [Organisationseinstellungen](/de/api/incident-management/org-settings)), wird jeder Incident aus Uptimeifys eigenem Monitoring zu einem Alarm in Incident Management und dort einem Incident zugeordnet. Dieser Endpunkt beantwortet, in welchem Incident-Management-Incident ein bestimmter **Monitoring**-Incident gelandet ist, etwa um von einem Monitoring-Incident auf seine Alarmierung und Timeline zu verlinken. Es zählen nur Alarme der organisationseigenen Monitoring-Quelle. Ein eigener Webhook, der zufällig denselben Dedup-Schlüssel (`monitor:`) sendet, wird nie getroffen. Wurde der Monitoring-Incident mehrfach übernommen, gewinnt der neueste Alarm. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. ## Pfadparameter | Parameter | Typ | Beschreibung | |-----------|-----|--------------| | `id` | number | Die ID des Monitoring-Incidents, wie sie [Incidents auflisten](/de/api/monitoring/list-incidents) der Monitoring-API liefert. | ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/incidents/by-monitor/5123" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "incidentId": 1834 } ``` Den Incident selbst lädst du mit [Incident abrufen](/de/api/incident-management/get-incident). ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `id` keine positive Zahl ist - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn keine IM-berechtigte Rolle vorliegt - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `404 Not Found` (`imIncidentNotFound`) wenn der Monitoring-Incident (noch) nicht übernommen wurde oder zu einer anderen Organisation gehört
### Incident einstufen
URL: https://docs.uptimeify.io/de/api/incident-management/incident-classification
Description: Setzt die NIS-2-Kategorie eines Incident-Management-Incidents (Verfügbarkeit, Sicherheit, Sonstiges) und markiert ihn als Beinahevorfall.
Summary: `POST /api/im/incidents/:id/classification` Stuft einen Incident für die NIS-2-Meldung ein (Durchführungsverordnung (EU) 2024/2690, Anhang 3.1): seine `category` und ob er ein Beinahevorfall war (`isNearMiss`, ein Ereignis, das Verfügbarkeit, Integrität oder Vertraulichkeit hätte beeinträchtigen können, es aber nicht tat). Neue Incidents beginnen mit `category: null` (noch nicht eingestuft) und `isNearMiss: false`; nichts setzt die Felder automatisch. Erlaubt in jedem Status, auch nach dem Lösen. Weggelassene Felder bleiben unverändert. Die Änderung steht als Ereignis `classification_changed` in der Zeitachse des Incidents (mit `from` und `to` je geändertem Feld) und im Audit-Protokoll der Organisation. Sie alarmiert niemanden und geht weder an Statusseiten noch an ausgehende Integrationen. Eine Anfrage, die nichts ändert, schreibt nichts und gibt den Incident unverändert zurück. Ist NIS-2 eingeschaltet, braucht ein gelöster Incident mit Kategorie `security` immer ein [Postmortem](/de/api/incident-management/postmortems), unabhängig vom Schweregrad, und ein damit verknüpfter [Meldefall](/de/api/incident-management/report-cases) schlägt das Kriterium `malicious_unauthorized_access` vor. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. Sie müssen Mitglied im Team des Incidents sein oder Organisations-`admin`. ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|--------------| | `category` | string oder null | Nein* | Einer von `availability`, `security`, `other`. `null` leert sie (nicht eingestuft). | | `isNearMiss` | boolean | Nein* | `true` markiert den Incident als Beinahevorfall. | \* Mindestens eines der beiden. Jeder andere Schlüssel wird abgewiesen. ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents/42/classification" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "category": "security", "isNearMiss": false }' ``` ## Antwort (Response) `200 OK`: die aktualisierte Incident-Zeile (dieselbe Form wie die `items` von [Incidents auflisten](/de/api/incident-management/list-incidents), ohne die Anreicherungsfelder). ```json { "id": 42, "teamId": 3, "title": "Verdächtige Anmeldungen im Admin-Bereich", "severity": "sev3", "status": "resolved", "category": "security", "isNearMiss": false } ``` (Gekürzt; die vollständige Zeile wird zurückgegeben.) ## Häufige Fehler - `401 Unauthorized`, wenn nicht authentifiziert - `403 Forbidden` (`customerScopedTokenForbidden`) bei einem kundengebundenen Token - `403 Forbidden` (`imAccessDenied`), wenn der Sitzungsnutzer keine IM-berechtigte Rolle hat - `403 Forbidden` (`imTeamMembershipRequired`), wenn Sie weder Mitglied im Team des Incidents noch Organisations-`admin` sind - `403 Forbidden` (`imNotEnabled`), wenn Incident Management für die Organisation nicht aktiviert ist - `400 Bad Request` (`invalidRequestBody`), wenn `:id` keine positive Ganzzahl ist, der Body weder `category` noch `isNearMiss` enthält, `category` keiner der drei Werte oder `null` ist, `isNearMiss` kein Boolean ist oder der Body einen unbekannten Schlüssel enthält - `404 Not Found` (`imIncidentNotFound`), wenn der Incident nicht existiert oder zu einer anderen Organisation gehört
### Incident kommentieren
URL: https://docs.uptimeify.io/de/api/incident-management/incident-comment
Description: Fügt der Timeline eines Incident-Management-Incidents einen Kommentar hinzu.
Summary: `POST /api/im/incidents/:id/comment` Fügt der Timeline des Incidents einen Freitext-Kommentar hinzu (ein Event der Art `comment`, sichtbar in `events` von [Incident abrufen](/de/api/incident-management/get-incident)). Ausgehende Integrationen erfahren vom Kommentar, und Abonnenten einer Statusseite, die über eine [Statusseiten-Regel](/de/api/incident-management/statuspage-rules) gesteuert wird, können ihn als Update erhalten. Auch geschlossene Incidents nehmen Kommentare an. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. Es gibt keine Team-Einschränkung. ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|--------------| | `text` | string | Ja | Kommentartext, nicht leer, höchstens 10.000 Zeichen. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents/42/comment" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "text": "Failover to the replica is running, ETA 10 minutes." }' ``` ## Antwort (Response) `200 OK` ```json { "ok": true } ``` ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imTeamMembershipRequired`) wenn du kein Mitglied im Team des Incidents und kein Organisations-`admin` bist - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `400 Bad Request` (`invalidRequestBody`) wenn `:id` keine positive Ganzzahl ist, oder `text` fehlt, leer ist oder länger als 10.000 Zeichen - `404 Not Found` (`imIncidentNotFound`) wenn der Incident nicht existiert oder zu einer anderen Organisation gehört
### Offene Incidents zählen
URL: https://docs.uptimeify.io/de/api/incident-management/incident-count
Description: Liefert die Zahl der offenen, noch nicht bestätigten Incident-Management-Incidents deiner Organisation.
Summary: `GET /api/im/incidents/count` Liefert, wie viele Incidents offen **und** noch nicht bestätigt sind: Status weder `resolved` noch `merged`, und kein `acknowledgedAt`. Dazu zählen auch Incidents, die ohne Bestätigung direkt von `triggered` nach `investigating`, `identified` oder `monitoring` gewechselt sind. Test-Incidents (`isTest: true`) werden nie mitgezählt. Eine einzelne, günstige Zählung, gedacht zum regelmäßigen Abfragen für ein Badge oder ein Wallboard; für gefilterte Abfragen nimm [Incidents auflisten](/de/api/incident-management/list-incidents); dessen Filter `unacknowledged=true` liefert genau die Incidents, die diese Zählung abdeckt. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/incidents/count" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "count": 4 } ``` ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist
### Sofort eskalieren
URL: https://docs.uptimeify.io/de/api/incident-management/incident-escalate-now
Description: Überspringt die Wartezeit und alarmiert sofort den nächsten Eskalations-Tier eines ausgelösten Incident-Management-Incidents.
Summary: `POST /api/im/incidents/:id/escalate-now` Alarmiert den nächsten [Eskalations-Tier](/de/api/incident-management/team-tiers) des Teams sofort, statt auf das Timeout des aktuellen Tiers zu warten. Nur gültig, solange der Incident `triggered` ist (also noch eskaliert). Die anstehenden Jobs des aktuellen Tiers werden abgebrochen und der nächste Tier (die niedrigste Tier-Reihenfolge über der aktuellen) wird sofort scharf geschaltet. Den Tier-Wechsel selbst trägt die Eskalations-Engine einen Moment später ein, `currentTier` in der Antwort zeigt also noch den Tier, von dem aus du eskaliert hast. Im Zeitverlauf des Incidents entsteht ein Ereignis `escalated` mit `payload` `{ fromTier, toTier, toTargetName }`. `toTargetName` ist der Name dessen, was der neue Tier alarmiert, so wie er in diesem Moment hieß: der erste Schedule des Tiers, bei einem Tier ohne Schedule der Name des Teams; `null`, wenn es beides nicht gibt. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. Dem Team des Incidents vorbehalten: du musst Mitglied im Team des Incidents (`teamId`) oder Organisations-Admin sein. Ein organisationsweiter API-Token gilt dabei als Organisations-Admin. Kein Request-Body. ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents/42/escalate-now" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort (Response) `200 OK`: der aktualisierte Incident-Datensatz (gleiche Form wie die `items` von [Incidents auflisten](/de/api/incident-management/list-incidents), ohne die Ergänzungsfelder). ```json { "id": 42, "teamId": 3, "title": "Database connection pool exhausted", "severity": "sev1", "status": "triggered", "currentTier": 1, "escalationEpoch": 3 } ``` (Gekürzt; zurück kommt der vollständige Datensatz.) ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `403 Forbidden` (`imTeamMembershipRequired`) wenn du weder Mitglied im Team des Incidents noch Organisations-Admin bist - `400 Bad Request` (`invalidRequestBody`) wenn `:id` keine positive Ganzzahl ist - `404 Not Found` (`imIncidentNotFound`) wenn der Incident nicht existiert oder zu einer anderen Organisation gehört - `422 Unprocessable Entity` (`imIncidentNotEscalating`) wenn der Incident nicht `triggered` ist - `422 Unprocessable Entity` (`imNoFurtherTier`) wenn das Team keinen Tier über dem aktuellen hat - `409 Conflict` (`imIncidentStatusConflict`) wenn sich der Eskalationszustand gleichzeitig geändert hat, sicher wiederholbar
### Dienst eines Vorfalls setzen
URL: https://docs.uptimeify.io/de/api/incident-management/incident-service
Description: Nennt den Dienst, den ein Incident-Management-Vorfall betrifft, oder nimmt ihn weg.
Summary: `POST /api/im/incidents/:id/service` Setzt den betroffenen [Dienst](/de/api/incident-management/services) eines Vorfalls von Hand oder nimmt ihn mit `null` weg. Erlaubt in jedem Status, auch nach dem Lösen. Rein beschreibend: niemand wird alarmiert, keine Statusseite und keine Outbound-Integration erfährt davon. Die Änderung steht in der Timeline des Vorfalls (`service_changed`, Payload `{ from, to }` mit `{ id, name }` oder `null`) und im Audit-Protokoll der Organisation. Ein Aufruf ohne Änderung schreibt nichts. ## Authentifizierung Jede IM-berechtigte Rolle oder ein organisationsweites API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Sie müssen Mitglied im Team des Vorfalls oder `admin` der Organisation sein. ## Request-Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `serviceId` | integer \| string \| null | Ja | `id` oder `publicId` eines Dienstes der Organisation des Vorfalls; `null` nimmt den Dienst weg. | ```bash curl -X POST "$BASE_URL/api/im/incidents/42/service" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "serviceId": 4 }' ``` ## Antwort `200 OK`: die geänderte Vorfall-Zeile (dieselbe Form wie die `items` von [Vorfälle auflisten](/de/api/incident-management/list-incidents), ohne die Anreicherungsfelder), mit gesetztem `serviceId`. ## Häufige Fehler - `401 Unauthorized` ohne Anmeldung - `403 Forbidden` (`imTeamMembershipRequired`) wenn Sie weder Mitglied im Team des Vorfalls noch `admin` der Organisation sind - `400 Bad Request` (`invalidRequestBody`) wenn `serviceId` fehlt oder weder Ganzzahl, UUID noch `null` ist - `404 Not Found` (`imIncidentNotFound`) wenn es den Vorfall nicht gibt oder er einer anderen Organisation gehört - `404 Not Found` (`imServiceNotFound`) wenn es den Dienst nicht gibt oder er einer anderen Organisation gehört
### Schweregrad ändern
URL: https://docs.uptimeify.io/de/api/incident-management/incident-severity
Description: Setzt den Schweregrad eines Incident-Management-Incidents von Hand. Der Wert bleibt dann bestehen und wird nicht mehr aus den Alerts abgeleitet.
Summary: `POST /api/im/incidents/:id/severity` Setzt den Schweregrad eines Incidents. Der Incident wird mit `severityManual: true` markiert, neue Alerts heben oder senken ihn also nicht mehr automatisch. Ist der Incident noch `triggered`, wird die anstehende Eskalation abgebrochen und mit dem neuen Schweregrad beim aktuellen Tier des Incidents neu scharf geschaltet. Statusseiten, die über eine [Statusseiten-Regel](/de/api/incident-management/statuspage-rules) gesteuert werden, und ausgehende Integrationen erfahren von der Änderung. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. Anders als Lösen oder Statuswechsel hat dieser Einzel-Endpunkt keine Team-Einschränkung. (Die Aktion `severity` von [Incidents gesammelt ändern](/de/api/incident-management/bulk-update-incidents) schon.) ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|--------------| | `severity` | string | Ja | Einer von `sev1`, `sev2`, `sev3`, `sev4`. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents/42/severity" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "severity": "sev2" }' ``` ## Antwort (Response) `200 OK`: der aktualisierte Incident-Datensatz (gleiche Form wie die `items` von [Incidents auflisten](/de/api/incident-management/list-incidents), ohne die Ergänzungsfelder), mit gesetztem `severity` und `severityManual: true`. ```json { "id": 42, "teamId": 3, "title": "Database connection pool exhausted", "severity": "sev2", "severityManual": true, "status": "triggered", "currentTier": 1, "escalationEpoch": 1 } ``` (Gekürzt; zurück kommt der vollständige Datensatz.) ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imTeamMembershipRequired`) wenn du kein Mitglied im Team des Incidents und kein Organisations-`admin` bist - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `400 Bad Request` (`invalidRequestBody`) wenn `:id` keine positive Ganzzahl ist, oder `severity` fehlt oder nicht `sev1` bis `sev4` ist - `404 Not Found` (`imIncidentNotFound`) wenn der Incident nicht existiert oder zu einer anderen Organisation gehört
### Incident schlummern lassen
URL: https://docs.uptimeify.io/de/api/incident-management/incident-snooze
Description: Pausiert Eskalation und Erinnerungen eines offenen Incident-Management-Incidents bis zu einem Zeitpunkt (höchstens 7 Tage voraus) oder beendet das Schlummern vorzeitig.
Summary: `POST /api/im/incidents/:id/snooze` Pausiert Eskalation und Erinnerungen eines offenen Incidents bis `snoozedUntil`. Anstehende Eskalations-Jobs werden abgebrochen, die Alarmierung läuft nach Ablauf automatisch weiter. Mit `null` (oder ohne das Feld) endet das Schlummern sofort: ein `triggered`-Incident eskaliert dann gleich ab seinem aktuellen Tier weiter. Jeder Aufruf wird in der Timeline des Incidents vermerkt. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. Dem Team des Incidents vorbehalten: du musst Mitglied im Team des Incidents (`teamId`) oder Organisations-Admin sein. Ein organisationsweiter API-Token gilt dabei als Organisations-Admin. ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|--------------| | `snoozedUntil` | ISO-8601-Datum/Zeit oder null | Nein | Wann die Alarmierung weiterläuft. Muss in der Zukunft liegen, höchstens 7 Tage ab jetzt. `null` oder weggelassen beendet das Schlummern. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents/42/snooze" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "snoozedUntil": "2026-07-17T13:00:00.000Z" }' ``` Schlummern vorzeitig beenden: ```bash curl -X POST "$BASE_URL/api/im/incidents/42/snooze" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "snoozedUntil": null }' ``` ## Antwort (Response) `200 OK`: der aktualisierte Incident-Datensatz (gleiche Form wie die `items` von [Incidents auflisten](/de/api/incident-management/list-incidents), ohne die Ergänzungsfelder). ```json { "id": 42, "teamId": 3, "title": "Database connection pool exhausted", "severity": "sev1", "status": "triggered", "currentTier": 1, "escalationEpoch": 2, "snoozedUntil": "2026-07-17T13:00:00.000Z" } ``` (Gekürzt; zurück kommt der vollständige Datensatz.) ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `403 Forbidden` (`imTeamMembershipRequired`) wenn du weder Mitglied im Team des Incidents noch Organisations-Admin bist - `400 Bad Request` (`invalidRequestBody`) wenn `:id` keine positive Ganzzahl ist, oder `snoozedUntil` kein gültiger Zeitpunkt ist - `400 Bad Request` (`imSnoozeRangeInvalid`) wenn `snoozedUntil` nicht in der Zukunft oder mehr als 7 Tage voraus liegt - `404 Not Found` (`imIncidentNotFound`) wenn der Incident nicht existiert oder zu einer anderen Organisation gehört - `422 Unprocessable Entity` (`imIncidentClosed`) wenn der Incident `resolved` oder `merged` ist
### Statusseiten-Text aktualisieren
URL: https://docs.uptimeify.io/de/api/incident-management/incident-statuspage-update
Description: Setzt den öffentlichen Statusseiten-Text eines Incident-Management-Incidents, angezeigt auf Statusseiten, die eine Statusseiten-Regel für diesen Incident umgeschaltet hat.
Summary: `POST /api/im/incidents/:id/statuspage-update` Setzt den kuratierten Text, den Statusseiten für diesen Incident zeigen (`statuspageUpdate` am Incident), und hängt ihn seit dem 27. Oktober 2026 an die **öffentliche Timeline** des Incidents an (`publicUpdates` in [Incident abrufen](/de/api/incident-management/get-incident)). Jede Statusseite, die eine [Statusseiten-Regel](/de/api/incident-management/statuspage-rules) des Teams trifft (Team und Schweregrad), listet den Incident ab dem ersten Update mit dieser Timeline in jedem Layout; ohne Update erscheint er dort nicht. Statusseiten, die eine Regel wegen dieses Incidents gerade umgeschaltet hat, zeigen den neuen Text sofort im Banner. Hat sich der Text tatsächlich geändert, erhalten die Abonnenten der passenden Seiten ein Incident-Update. Die Timeline ist append-only: ein Eintrag wird nie geändert oder gelöscht. Ein neuer Text hängt einen an; derselbe Text noch einmal nur, wenn du `status` mitgibst; Leeren (`null`) leert nur `statuspageUpdate`, die Timeline behält, was schon veröffentlicht war. Ob überhaupt eine Regel für den Incident greift, meldet [Incident abrufen](/de/api/incident-management/get-incident) als `statuspageRuleApplies`; ohne passende Regel wird der Text gespeichert, erscheint aber nirgends. Die Änderung landet im IM-Audit-Log. ## Authentifizierung Erfordert IM-Zugriff, siehe [Authentifizierung](/de/api/incident-management#authentifizierung), **und** Schreibrechte für Statusseiten: Rolle `admin` oder `editor`. Ein `responder` kann diesen Endpunkt nicht nutzen. Ein organisationsweiter API-Token gilt dabei als Organisations-Admin. Incident Management muss für die Organisation aktiviert sein. Es gibt keine Team-Einschränkung. ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|--------------| | `update` | string oder null | Ja | Der öffentliche Text. Leerraum am Anfang und Ende wird entfernt, der Text wird auf 5.000 Zeichen gekürzt. Ein leerer String oder `null` löscht ihn. | | `status` | string | Nein | Phase des Timeline-Eintrags: `investigating`, `identified`, `monitoring` oder `resolved`. Standard: die Phase des letzten öffentlichen Updates dieses Incidents, damit ein Nachtrag nicht auf `investigating` zurückfällt; das erste Update ist `investigating`. Ein gelöster Incident bekommt `resolved`; nach Wiedereröffnung wird aus einem früheren `resolved` wieder `investigating`. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents/42/statuspage-update" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "update": "We are investigating slow logins. Next update in 30 minutes.", "status": "investigating" }' ``` ## Antwort (Response) `200 OK`: der Text, wie er gespeichert wurde, und der Timeline-Eintrag, den dieser Aufruf angehängt hat (`null`, wenn nichts angehängt wurde). ```json { "ok": true, "statuspageUpdate": "We are investigating slow logins. Next update in 30 minutes.", "publicUpdate": { "id": 17, "publicId": "6f1d2c3b-4a5e-4f60-8a7b-9c0d1e2f3a4b", "status": "investigating", "body": "We are investigating slow logins. Next update in 30 minutes.", "createdAt": "2026-10-27T09:15:00.000Z", "createdByUserId": "u_abc123" } } ``` ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `403 Forbidden` (ohne `data.code`) wenn deine Rolle weder `admin` noch `editor` ist - `400 Bad Request` (`invalidRequestBody`) wenn `:id` keine positive Ganzzahl ist, `update` fehlt oder weder String noch `null` ist, oder `status` keine der vier Phasen ist - `404 Not Found` (`imIncidentNotFound`) wenn der Incident nicht existiert oder zu einer anderen Organisation gehört
### Ingest-Webhook
URL: https://docs.uptimeify.io/de/api/incident-management/ingest-webhook
Description: Die Ingest-URL je Alarmquelle, an die deine Monitoring-Tools Alarme senden: Authentifizierung, Grenzen und Statuscodes.
Summary: `POST /api/im/ingest/:token` Jede Webhook-[Alarmquelle](/de/api/incident-management/alert-sources-api) hat ihre eigene Ingest-URL. Dein Monitoring-Tool sendet sein Alarm-JSON dorthin, und das Mapping der Quelle macht daraus einen Alarm in Incident Management. Die [Einrichtungsanleitungen](/de/api/incident-management/alert-sources) zeigen die Konfiguration für Zabbix, Datadog, Grafana, Prometheus Alertmanager, Sentry und eigene Webhooks. Um Alarme aus deinem eigenen Code mit einem organisationsweiten API-Token zu senden, nimm stattdessen [Events Ingest](/de/api/incident-management/events-ingest). ## Authentifizierung Der Token in der URL **ist** die Zugangsberechtigung: Behandle die vollständige URL wie ein Passwort. Sie wird einmal beim Anlegen der Quelle und bei jeder [Rotation](/de/api/incident-management/alert-sources-api) zurückgegeben; nach einer Rotation funktioniert der vorige Token bis `secondaryExpiresAt` weiter. Eine Quelle kann zusätzlich eines oder beides verlangen: - **Bearer-Token**: `Authorization: Bearer `. - **HMAC-Signatur**: `X-Uptimeify-Timestamp` (Unix-Sekunden) und `X-Uptimeify-Signature` = HMAC-SHA256 in Hex über `.` mit dem HMAC-Secret der Quelle, optional mit Präfix `sha256=`. Der Zeitstempel darf höchstens 5 Minuten von der Serverzeit abweichen. Jeder Authentifizierungsfehler, auch ein unbekannter Token, antwortet mit demselben `404`. So lässt sich ein falscher Token nicht von einer falschen Signatur unterscheiden. ## Request - Body: JSON, höchstens 256 KB, höchstens 20 Ebenen tief verschachtelt. Ein leerer Body gilt als `{}`. - Der Content-Type wird nicht geprüft; der Body wird als JSON gelesen. - Welche Felder zählen, bestimmt das Mapping der Quelle (Vorlage oder eigenes). Der Body unten passt zu einer eigenen Webhook-Quelle, die auf diese Feldnamen gemappt ist. ### Beispiel (cURL) ```bash curl -X POST "https://uptimeify.io/api/im/ingest/$INGEST_TOKEN" \ -H "Content-Type: application/json" \ -d '{"title":"Disk almost full on db-1","severity":"high","status":"firing","dedup_key":"db-1-disk"}' ``` Mit HMAC: ```bash TS=$(date +%s) BODY='{"title":"Disk almost full on db-1","status":"firing"}' SIG=$(printf '%s.%s' "$TS" "$BODY" | openssl dgst -sha256 -hmac "$HMAC_SECRET" -hex | sed 's/^.* //') curl -X POST "https://uptimeify.io/api/im/ingest/$INGEST_TOKEN" \ -H "Content-Type: application/json" \ -H "X-Uptimeify-Timestamp: $TS" \ -H "X-Uptimeify-Signature: sha256=$SIG" \ -d "$BODY" ``` ## Antwort (Response) `202 Accepted`: ```json { "accepted": true } ``` Der Payload ist zur Verarbeitung angenommen; Mapping, Deduplizierung und Alarmierung laufen asynchron. Was daraus wurde, zeigen [Statistik und letzte Payloads](/de/api/incident-management/alert-sources-api) der Quelle. ## Grenzen - 300 Requests pro Minute und Quelle - 50 MB Request-Bodies pro Stunde und Organisation ## Statuscodes | Status | Body | Bedeutung | |--------|------|-----------| | `202` | `{"accepted":true}` | Angenommen. | | `404` | `{"error":"not_found"}` | Unbekannter oder abgelaufener Token, fehlgeschlagene Bearer- oder HMAC-Prüfung, der Token eines [Meldeformulars](/de/api/incident-management/alert-sources/report-form), oder die Organisation wurde gelöscht. | | `413` | `{"error":"payload_too_large"}` | Body größer als 256 KB. | | `422` | `{"error":"invalid_json"}` | Body ist kein gültiges JSON oder weder Objekt noch Array. | | `422` | `{"error":"payload_too_deep"}` | JSON tiefer als 20 Ebenen verschachtelt. | | `429` | `data.code` `imIngestRateLimited` | Mehr als 300 Requests pro Minute für diese Quelle. | | `429` | `data.code` `imIngestByteBudgetExceeded` | Stündliches Byte-Budget der Organisation aufgebraucht. | | `503` | `{"error":"unavailable"}` | Vorübergehend nicht annahmebereit; mit Backoff wiederholen. Die eingebaute Wiederholung deines Tools ist die richtige Antwort. |
### Incidents auflisten
URL: https://docs.uptimeify.io/de/api/incident-management/list-incidents
Description: Liefert eine gefilterte, paginierte Liste der Incident-Management-Incidents deiner Organisation, per Cursor oder per Seitennummer.
Summary: `GET /api/im/incidents` Liefert eine gefilterte Liste der Incidents deiner Organisation, neueste zuerst (`triggeredAt` absteigend, dann `id` absteigend). Jeder Eintrag trägt die Felder des Incidents selbst und dazu eine kleine, seitenweit aufgelöste Ergänzung: die primäre Zuweisung, die Personen hinter den Lebenszyklus-Spalten und die Alert-Aktivität des Incidents (siehe [Aufgelöste Personen](#aufgelöste-personen) weiter unten). Die vollständigen Alerts, Timeline-Events und Zuweisungen eines Incidents liefert der Endpunkt [Incident abrufen](/de/api/incident-management/get-incident). ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. ## Query-Parameter | Parameter | Typ | Beschreibung | |-----------|------|--------------| | `status` | string, wiederholbar | Filter nach Status. Ein oder mehrere von `triggered`, `acknowledged`, `investigating`, `identified`, `monitoring`, `resolved`, `merged`. | | `severity` | string, wiederholbar | Filter nach Schweregrad. Ein oder mehrere von `sev1`, `sev2`, `sev3`, `sev4`. | | `category` | string, wiederholbar | Filter nach NIS-2-Kategorie. Ein oder mehrere von `availability`, `security`, `other`, `uncategorized` (noch nicht eingestuft, `category: null`). | | `teamId` | number, wiederholbar | Filter nach besitzendem Team. | | `customerId` | number, wiederholbar | Filter nach dem zugeordneten Kunden des Incidents. | | `sourceId` | number, wiederholbar | Filter nach primärer Alert-Source. | | `serviceId` | number, wiederholbar | Filter nach betroffenem [Dienst](/de/api/incident-management/services). | | `assignedUserId` | string | Nur Incidents, in denen diese User-ID eine Rolle hält (beliebige Rolle). | | `onCall` | boolean (`true`/`false`/`1`/`0`) | `true` beschränkt auf Incidents, die einem Team gehören, für das die **aufrufende Person** gerade Bereitschaft hat; hat sie für kein Team Bereitschaft, ist die Seite leer. Ein API-Token hat selbst nie Bereitschaft, mit einem Token liefert `onCall=true` also immer eine leere Seite. `false` oder weggelassen wendet keinen Bereitschaftsfilter an. | | `unacknowledged` | boolean (`true`/`false`/`1`/`0`) | `true` beschränkt auf offene Incidents, die nie bestätigt wurden: Status weder `resolved` noch `merged`, kein `acknowledgedAt` und kein Test-Incident (`isTest`). Das ist genau die Menge, die [Offene Incidents zählen](/de/api/incident-management/incident-count) zählt, Liste und Zahl stimmen also überein; sie enthält auch Incidents, die direkt von `triggered` auf `investigating`, `identified` oder `monitoring` gesetzt wurden. Funktioniert im Cursor- und im Seiten-Modus (`total` berücksichtigt es). `false` oder weggelassen wendet keinen Filter an. | | `from` | ISO-8601-Datum/Zeit | Nur Incidents, die zu diesem Zeitpunkt oder später ausgelöst wurden. | | `to` | ISO-8601-Datum/Zeit | Nur Incidents, die zu diesem Zeitpunkt oder früher ausgelöst wurden. | | `q` | string | Volltextsuche im Incident-Titel. Nur ganze Wörter, keine Präfixsuche; Websuche-Syntax wird unterstützt (`"Phrase in Anführungszeichen"`, `or`, `-ausgeschlossen`). | | `limit` | number | Seitengröße. Standard 50. Werte über 100 werden auf 100 begrenzt. | | `cursor` | string | Cursor-Modus: der `nextCursor` einer vorherigen Antwort. Als undurchsichtig behandeln, exakt zurückgeben, nicht selbst konstruieren. | | `page` | number | Seiten-Modus: Seitennummer ab 1. Nicht mit `cursor` kombinierbar. Die Antwort enthält dann zusätzlich `total` und `asOf`. | | `asOf` | ISO-8601-Datum/Zeit | Nur Incidents, die zu diesem Zeitpunkt oder früher ausgelöst wurden. Im Seiten-Modus friert es die Ergebnismenge ein: lässt du es weg, wählt der Server die aktuelle Zeit und gibt sie als `asOf` zurück. Gib diesen Wert bei jeder Folgeseite mit, damit neue Incidents die Seiten nicht verschieben. | | `envelope` | stri…
### Incidents zusammenführen
URL: https://docs.uptimeify.io/de/api/incident-management/merge-incidents
Description: Führt einen Incident-Management-Incident in einen anderen zusammen: seine Alerts und seine Timeline wandern mit, der zusammengeführte Incident eskaliert nicht weiter.
Summary: `POST /api/im/incidents/:id/merge` Führt den Incident `:id` (die Quelle) in `targetIncidentId` zusammen, etwa wenn sich zwei Alerts als derselbe Ausfall herausstellen. In einem Schritt: - alle Alerts und Timeline-Events der Quelle wandern zum Ziel, - die Quelle erhält den Status `merged` und `mergedIntoId` zeigt auf das Ziel, ihre Eskalation endet, - die Timeline der Quelle vermerkt `merged`, die des Ziels `merge_received`. Rollen-Zuweisungen bleiben bei der Quelle. Über die API lässt sich ein Zusammenführen nicht rückgängig machen. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. Dem Team des Quell-Incidents vorbehalten: du musst Mitglied im Team von Incident `:id` oder Organisations-Admin sein. Ein organisationsweiter API-Token gilt dabei als Organisations-Admin. ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|--------------| | `targetIncidentId` | number | Ja | Der Incident, in den zusammengeführt wird. Muss zur selben Organisation gehören und darf weder `merged` noch `resolved` sein. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents/43/merge" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "targetIncidentId": 42 }' ``` ## Antwort (Response) `200 OK`: der aktualisierte Quell-Incident (gleiche Form wie die `items` von [Incidents auflisten](/de/api/incident-management/list-incidents), ohne die Ergänzungsfelder) und die Ziel-ID. ```json { "source": { "id": 43, "teamId": 3, "title": "Replica lag above threshold", "status": "merged", "mergedIntoId": 42, "currentTier": null, "escalationEpoch": 1 }, "targetIncidentId": 42 } ``` (`source` gekürzt; zurück kommt der vollständige Datensatz.) ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `403 Forbidden` (`imTeamMembershipRequired`) wenn du weder Mitglied im Team des Quell-Incidents noch Organisations-Admin bist - `400 Bad Request` (`invalidRequestBody`) wenn `:id` keine positive Ganzzahl ist, oder `targetIncidentId` fehlt oder keine positive Ganzzahl ist - `404 Not Found` (`imIncidentNotFound`) wenn Quell- oder Ziel-Incident nicht existiert oder zu einer anderen Organisation gehört - `422 Unprocessable Entity` (`imIncidentCannotMergeIntoSelf`) wenn `targetIncidentId` gleich `:id` ist - `422 Unprocessable Entity` (`imIncidentAlreadyMerged`) wenn der Quell-Incident bereits `merged` ist - `422 Unprocessable Entity` (`imIncidentTargetAlreadyMerged`) wenn der Ziel-Incident `merged` ist - `422 Unprocessable Entity` (`imMergeTargetClosed`) wenn der Ziel-Incident `resolved` ist
### Mein Bereitschaftsstatus
URL: https://docs.uptimeify.io/de/api/incident-management/my-on-call
Description: Deine eigene Bereitschaft über alle Teams: ob du gerade Bereitschaft hast, kommende Schichten, Vertretungen und deine Bereitschaftsstunden.
Summary: `GET /api/im/me/on-call` · `GET /api/im/me/on-call-stats` Die persönliche Sicht auf die Bereitschaft: ob **du** gerade Bereitschaft hast, in welchen Teams, was als Nächstes kommt und wie viele Stunden du Bereitschaft hattest. Wer allgemein Bereitschaft hat, zeigt [Wer hat Bereitschaft](/de/api/incident-management/on-call). ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) mit einer **Benutzersitzung**. Incident Management muss für die Organisation aktiviert sein. Diese Endpunkte beschreiben eine Person, deshalb erhält ein organisationsweiter API-Token `403` (`imUserSessionRequired`): Ein Token hat weder Schicht noch Pager. ## Meine aktuelle Bereitschaft `GET /api/im/me/on-call` Wird genauso aufgelöst wie in der Alarmierung, inklusive Vertretungen auf Teamebene. `upcomingShifts` schaut zwei Wochen voraus. ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/me/on-call" \ -b "$SESSION_COOKIE" \ -H "Accept: application/json" ``` ### Antwort (Response) ```json { "currentlyOnCall": true, "currentTeams": [ { "teamId": 7, "teamName": "Platform", "tierOrder": 1 } ], "currentShift": { "teamId": 7, "teamName": "Platform", "tierOrder": 1, "startsAt": "2026-10-10T07:00:00.000Z", "endsAt": "2026-10-11T07:00:00.000Z", "scheduleName": "Platform primary" }, "upcomingShifts": [ { "teamId": 7, "teamName": "Platform", "scheduleId": 12, "scheduleName": "Platform primary", "startsAt": "2026-10-17T07:00:00.000Z", "endsAt": "2026-10-18T07:00:00.000Z", "isOverride": false } ], "myOverrides": [ { "id": 91, "teamId": 7, "teamName": "Platform", "scheduleId": 12, "type": "offline", "startsAt": "2026-10-12T18:00:00.000Z", "endsAt": "2026-10-12T22:00:00.000Z", "coveredBy": [{ "userId": "u_8f2", "name": "Mara" }] } ], "degraded": false } ``` | Feld | Beschreibung | |------|--------------| | `currentlyOnCall` | Ob du gerade in mindestens einem Team für neue Incidents alarmiert wirst. | | `currentTeams` | Teams, in denen du jetzt Bereitschaft hast. `tierOrder` ist die niedrigste Stufe, in der du bist, also die zuerst alarmierte. | | `currentShift` | Die laufende Bereitschaft mit ihrem echten Beginn und Ende, über aneinanderliegende Schichten und Vertretungen hinweg. Bei Bereitschaft in mehreren Teams die am längsten laufende. `endsAt` ist derselbe Wert wie `shiftEndsAt` von [`GET /api/im/on-call`](/api/incident-management/on-call) für dich in diesem Team (bei Bereitschaft in mehreren Stufen eines Teams: die Stufe, deren Bereitschaft am längsten läuft), an derselben Stelle berechnet. `startsAt` ist `null`, wenn die Bereitschaft vor mehr als zwei Wochen begann, `endsAt` ist `null`, wenn sie nicht innerhalb von 90 Tagen endet (dort ist `shiftEndsAtIsLowerBound` `true`). `scheduleName` ist `null`, wenn die Bereitschaft nur aus einer Vertretung auf Teamebene stammt. `null`, wenn du keine Bereitschaft hast. | | `upcomingShifts` | Deine Schichten, die in den nächsten zwei Wochen beginnen. `isOverride` markiert Schichten aus einer Vertretung. | | `myOverrides` | Deine eigenen laufenden oder kommenden Vertretungen (`type` `online` = du übernimmst, `offline` = du gibst ab). Bei einer Offline-Vertretung nennt `coveredBy`, wer in der Zeit den Pager hält; jeder Eintrag wird an deiner Stelle alarmiert. Bei Online-Vertretungen und bei einer Offline-Vertretung ohne Ersatz ist die Liste leer. | | `degraded` | `true`, wenn der Status mindestens eines Teams nicht aufgelöst werden konnte. `currentlyOnCall` ist dann eine Untergrenze: als „Status unvollständig“ lesen, nicht als „keine Bereitschaft“. | ## Meine Bereitschaftsstunden `GET /api/im/me/on-call-stats` Deine Bereitschaftszeit in dieser Woche, in diesem Monat und in den letzten 30 Tagen, jeweils mit dem vorigen Zeitraum derselben Art. ### Query-Parameter | Parameter | Typ | Pflicht | Beschreibung | |-----------|-----|---------|--------------| | `tz` | string | Nein | IANA-Zeitzone, z. B. `Europe/Berlin`. Bestimmt, wo eine Woche (Montag 00:00) und ein Monat (1., 00:00) beginnen. Unbekannt…
### NIS-2-Einstellungen
URL: https://docs.uptimeify.io/de/api/incident-management/nis2-settings
Description: NIS-2-Meldefälle für Ihre Organisation einschalten, die Einstufung der Einrichtung setzen und die Meldeverantwortlichen festlegen.
Summary: `GET /api/im/nis2/settings` · `PUT /api/im/nis2/settings` Meldefälle helfen, die NIS-2-Meldefristen einzuhalten (Frühwarnung nach 24 h, Meldung nach 72 h, Abschlussmeldung nach einem Monat). Sie sind standardmäßig aus. Jede Meldung geben Sie selbst im BSI-Portal ab; Uptimeify übermittelt nichts und stuft keinen Vorfall selbst ein. ## Authentifizierung Nur mit Sitzung (Dashboard-Anmeldung). API-Tokens, auch organisationsweite, werden mit `403` (`nis2OfficerRequired`) abgewiesen. Voraussetzung ist Zugang zum Incident Management (`admin`, `editor` oder `responder`). Lesen dürfen Organisations-Admins und die eingetragenen Meldeverantwortlichen, auch wenn Meldefälle ausgeschaltet sind (dann können Admins und die eingetragenen Meldeverantwortlichen die Einstellungen weiterhin lesen; ändern dürfen nur Admins). **Ändern** verlangt die Rolle `admin`. ## Einstellungen lesen `GET /api/im/nis2/settings` ### Beispiel (cURL) ```bash curl "$BASE_URL/api/im/nis2/settings" \ -H "Cookie: $SESSION_COOKIE" \ -H "Accept: application/json" ``` ### Antwort `200 OK` ```json { "enabled": true, "entityClass": "important", "postmortemMinSeverity": "sev2", "timezone": "Europe/Berlin", "officers": [ { "userId": "u_8f2c", "name": "Jana Weber", "email": "jana.weber@example.com" } ], "canEdit": true } ``` | Feld | Beschreibung | |------|--------------| | `enabled` | Meldefälle sind eingeschaltet. Standard `false`. | | `entityClass` | `important` (wichtige Einrichtung), `essential` (besonders wichtige Einrichtung) oder `kritis` (Betreiber kritischer Anlagen). Bei `kritis` enthalten die Berichtsentwürfe zusätzlich Anlage und kritische Dienstleistung. | | `postmortemMinSeverity` | Gelöste Incidents ab dieser Severity (`sev1` ist die höchste) brauchen ein [Postmortem](/de/api/incident-management/postmortems); Incidents mit Meldefall oder Kategorie `security` immer. Standard `sev2`. | | `timezone` | IANA-Zeitzone für Quartale und Fälligkeiten von Maßnahmen. Standard `Europe/Berlin`. | | `officers` | Meldeverantwortliche. Sie bekommen die Fristerinnerungen. Admins haben immer Zugriff und stehen nicht in der Liste. | | `canEdit` | `true` für Organisations-Admins. | ## Einstellungen ändern `PUT /api/im/nis2/settings` Ersetzt die Einstellungen und die Liste der Meldeverantwortlichen; `postmortemMinSeverity` und `timezone` ändern sich nur, wenn sie mitgeschickt werden. Jeder andere Schlüssel ist ein `400`. ### Request-Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `enabled` | boolean | Ja | Meldefälle ein- oder ausschalten. | | `entityClass` | string | Ja | `important`, `essential` oder `kritis`. | | `officerUserIds` | string[] | Ja | Nutzer-IDs dieser Organisation mit der Rolle `admin`, `editor` oder `responder`, höchstens 100. Einem Kunden zugeordnete Editoren sind Kundenseite und werden abgelehnt. `[]` leert die Liste. | | `postmortemMinSeverity` | string | Nein | `sev1` bis `sev4`. Weggelassen: unverändert. | | `timezone` | string | Nein | IANA-Name wie `Europe/Berlin`; ein unbekannter Name ist ein `400`. Weggelassen: unverändert. | ### Beispiel (cURL) ```bash curl -X PUT "$BASE_URL/api/im/nis2/settings" \ -H "Cookie: $SESSION_COOKIE" \ -H "Content-Type: application/json" \ -d '{ "enabled": true, "entityClass": "kritis", "officerUserIds": ["u_8f2c"] }' ``` ### Antwort `200 OK`: die gespeicherten Einstellungen, gleiche Form wie bei GET. ## Häufige Fehler - `401 Unauthorized` (`unauthorized`) ohne Anmeldung - `403 Forbidden` (`imAccessDenied`) für einen Kunden-Login oder eine Rolle ohne Incident-Management-Zugang - `403 Forbidden` (`nis2OfficerRequired`) für ein API-Token oder eine Person, die weder Admin noch Meldeverantwortliche ist - `403 Forbidden` (`nis2AdminRequired`) beim Ändern ohne die Rolle `admin` - `400 Bad Request` (`invalidRequestBody`), wenn ein Feld fehlt, den falschen Typ hat, `entityClass` oder `postmortemMinSeverity` keinen erlaubten Wert hat, `timezone` keine bekannte IANA-Zeitzone ist oder der Body einen u…
### Persönliche Benachrichtigungseinstellungen
URL: https://docs.uptimeify.io/de/api/incident-management/notification-settings
Description: Wie Incident Management dich erreicht: Kanäle, Benachrichtigungsregeln je Dringlichkeit, Kanäle je Schweregrad, Telefonbestätigung, Test-Benachrichtigungen und dein Benachrichtigungsprotokoll.
Summary: `GET /api/im/notification-settings` · `PATCH /api/im/notification-settings` · `PUT /api/im/notification-settings/channels` · `PUT /api/im/notification-settings/severity` · `POST /api/im/notification-settings/rules` · `DELETE /api/im/notification-settings/rules/:id` · `POST /api/im/notification-settings/verify-phone` · `POST /api/im/notification-settings/verify-phone-confirm` · `POST /api/im/notification-settings/test` · `GET /api/im/notification-settings/caller-ids` · `GET /api/im/notification-settings/logs` Wenn eine Eskalation dich alarmiert, entscheiden diese Einstellungen, **wie** du erreicht wirst. Jeder Endpunkt auf dieser Seite liest und schreibt die Einstellungen der aufrufenden Person. Ein Organisations-Admin kann sie auch für dich setzen ([Benachrichtigungen einer Person](/de/api/incident-management/user-notification-settings)); es gilt der letzte Schreibzugriff, und `lastAdminChangeAt` zeigt dir, wann das war. Beim ersten Zugriff werden deine Einstellungen angelegt, ausgehend von der [Standard-Benachrichtigung](/de/api/incident-management/notification-template) der Organisation, falls eine gesetzt ist. ## Begriffe - **Kanäle**: `push` (Mobile App), `sms`, `voice` und `email`. - **Regeln** bilden deine persönliche Benachrichtigungskette je **Dringlichkeit** (`high` oder `low`): „nach `delayMinutes` über `channel` benachrichtigen“. Eine Verzögerung von `0` benachrichtigt sofort; erlaubt sind 0 bis 1440 Minuten. Dieselbe Kombination aus Dringlichkeit, Verzögerung und Kanal gibt es höchstens einmal. - **Schweregrad-Filter** (`severityChannels`): je Schweregrad des Incidents (`sev1` bis `sev4`), welche Kanäle genutzt werden dürfen. Er wird sparsam gespeichert: Ein nicht genannter Schweregrad oder Kanal ist **erlaubt**. `{"sev4": {"sms": false, "voice": false}}` hält Incidents niedriger Schwere von deinem Telefon fern und ändert sonst nichts. - **Telefon**: `sms` und `voice` gehen nur an eine bestätigte Telefonnummer im E.164-Format (`+` und 7 bis 15 Ziffern, z. B. `+491701234567`). `sms`/`voice`-Regeln lassen sich schon vor der Bestätigung speichern: Sie warten, und jede Alarmierung bis dahin steht im Protokoll als übersprungen mit dem Grund `unverified`. Eine geänderte Nummer muss neu bestätigt werden. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) mit einer **Benutzersitzung**. Incident Management muss für die Organisation aktiviert sein. Persönliche Einstellungen gehören einer Person: Ein organisationsweiter API-Token erhält `403` (`imAccessDenied`), beim Protokoll `403` (`imUserSessionRequired`). ## Einstellungen lesen `GET /api/im/notification-settings` ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/notification-settings" \ -b "$SESSION_COOKIE" \ -H "Accept: application/json" ``` ### Antwort (Response) ```json { "id": 31, "phoneNumber": "+491701234567", "phoneVerified": true, "channels": { "push": true, "sms": true, "email": true }, "severityChannels": { "sev4": { "sms": false, "voice": false } }, "rules": [ { "id": 201, "urgency": "high", "delayMinutes": 0, "channel": "push" }, { "id": 202, "urgency": "high", "delayMinutes": 5, "channel": "sms" }, { "id": 203, "urgency": "low", "delayMinutes": 0, "channel": "email" } ], "lastAdminChangeAt": "2026-10-28T09:12:00.000Z", "lastAdminChangeBy": { "id": "usr_admin", "name": "Ada Admin" } } ``` `rules` ist nach Dringlichkeit, dann Verzögerung sortiert. `lastAdminChangeAt` ist der Zeitpunkt, zu dem ein Organisations-Admin diese Einstellungen zuletzt gesetzt hat (`null`, wenn nie); `lastAdminChangeBy` ist dieser Admin, `null`, wenn nie oder das Konto nicht mehr existiert. ## Telefonnummer oder Kanalschalter ändern `PATCH /api/im/notification-settings` ### Request Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `phoneNumber` | string oder null | Nein | E.164-Nummer, oder `null` zum Entfernen. Eine neue Nummer ist unbestätigt, bis sie bestätigt wird; ein offener Bestätigungscode verfällt. Vorhan…
### Standard-Benachrichtigung
URL: https://docs.uptimeify.io/de/api/incident-management/notification-template
Description: Die Standard-Benachrichtigungskette der Organisation: womit neue Nutzer starten, wenn ihre persönlichen Benachrichtigungen zum ersten Mal angelegt werden.
Summary: `GET /api/im/notification-template` · `PUT /api/im/notification-template` Die Standard-Benachrichtigung ist die Kette, mit der eine Person startet. Sie wird in die [persönlichen Benachrichtigungen](/de/api/incident-management/notification-settings) einer Person kopiert, wenn diese angelegt werden, also beim ersten Öffnen durch die Person (oder durch einen Admin über [Benachrichtigungen einer Person](/de/api/incident-management/user-notification-settings)). **Sie wirkt nicht rückwirkend**: Wer schon Einstellungen hat, behält sie, und alle können ihre eigene Kette danach ändern. `sms`- und `voice`-Schritte warten, bis die Person eine Telefonnummer bestätigt hat. ## Authentifizierung Erfordert die Rolle `admin` der Organisation, mit Sitzung oder organisationsweitem API-Token (der Token arbeitet mit der Rolle der Person, die ihn erstellt hat). Kundengebundene Tokens und Kunden-Logins werden abgewiesen. Incident Management muss für die Organisation aktiviert sein. ## Standard-Benachrichtigung lesen `GET /api/im/notification-template` ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/notification-template" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ### Antwort (Response) ```json { "channels": { "push": true, "sms": true, "voice": false, "email": true }, "rules": [ { "urgency": "high", "delayMinutes": 0, "channel": "push" }, { "urgency": "high", "delayMinutes": 5, "channel": "sms" }, { "urgency": "low", "delayMinutes": 0, "channel": "email" } ], "updatedAt": "2026-10-28T09:12:00.000Z" } ``` Vor dem ersten Speichern lautet die Antwort `{ "channels": {}, "rules": [], "updatedAt": null }`, und neue Nutzer starten ohne Kette. ## Standard-Benachrichtigung setzen `PUT /api/im/notification-template` Ersetzt die ganze Vorlage. ### Request Body | Feld | Typ | Pflicht | Beschreibung | |-------|------|----------|-------------| | `rules` | array | Ja | Die Kette, höchstens 64 Schritte. Jeder Schritt `{ "urgency": "high" oder "low", "delayMinutes": 0..1440, "channel": "push", "sms", "voice" oder "email" }`. Jede Kombination aus Dringlichkeit, Verzögerung und Kanal höchstens einmal. Eine leere Liste (ohne `channels`) schaltet die Vorlage ab. | | `channels` | object | Nein | Die vier Kanalschalter (`push`, `sms`, `voice`, `email` → boolean). Fehlt das Feld, ist ein Kanal genau dann an, wenn `rules` einen Schritt dafür hat. | Unbekannte Felder werden abgewiesen. ### Beispiel (cURL) ```bash curl -X PUT "$BASE_URL/api/im/notification-template" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"rules":[{"urgency":"high","delayMinutes":0,"channel":"push"},{"urgency":"high","delayMinutes":5,"channel":"sms"},{"urgency":"low","delayMinutes":0,"channel":"email"}]}' ``` ### Antwort (Response) `200 OK`: die Vorlage nach dem Schreiben, gleiche Form wie die GET-Antwort. Jede Änderung steht im Audit-Protokoll. ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) bei ungültigem Body: unbekanntes Feld, unbekannter Kanal oder Dringlichkeit, Verzögerung außerhalb 0 bis 1440, mehr als 64 Schritte, dieselbe Kombination zweimal - `401 Unauthorized` ohne Anmeldung - `403 Forbidden` (`forbidden`), wenn du kein `admin` der Organisation bist - `403 Forbidden` (`imAccessDenied`) für Kunden-Logins und kundengebundene Tokens - `403 Forbidden` (`imNotEnabled`), wenn Incident Management für die Organisation nicht aktiviert ist
### Wer hat Bereitschaft
URL: https://docs.uptimeify.io/de/api/incident-management/on-call
Description: Liefert, wer in deiner Organisation gerade Bereitschaft hat, ein Eintrag pro Team, Eskalationsstufe und Person, aufgelöst genau wie die Alarmierung.
Summary: `GET /api/im/on-call` Liefert, wer in deiner Organisation **gerade jetzt** Bereitschaft hat: ein Eintrag pro Team, Eskalationsstufe und Person. Die Auflösung ist genau dieselbe wie bei [`GET /api/im/teams/{id}/on-call-now`](/de/api/incident-management/team-insights#bereitschaft-jetzt) und in der Alarmierung: die Rotation des [Schedules](/de/api/incident-management/schedules), zum Zeitpunkt der Anfrage berechnet (nicht nur die materialisierten Schichten), jeden [Schedule-Override](/de/api/incident-management/schedule-overrides) (für alle Stufen und stufengebunden), jeden [Team-Override](/de/api/incident-management/team-overrides) und alle gleichzeitig Diensthabenden. Legst du einen Override an, änderst oder löschst ihn, zählt das sofort; du musst nicht warten, bis die Schichten neu materialisiert sind. ## Authentifizierung Erfordert den Basis-IM-Zugriff, den jeder Endpunkt dieser API benötigt (eine der IM-berechtigten Rollen `admin`, `editor` oder `responder`, oder einen organisationsweiten API-Token; Incident Management muss für die Organisation aktiviert sein). ## Query-Parameter | Parameter | Typ | Standard | Beschreibung | |-----------|------|---------|-------------| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/on-call?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) `200 OK`: ein Eintrag pro Team, Stufe und Person, die gerade Bereitschaft hat. Eine Stufe ohne aktuelle Abdeckung (eine Lücke) fehlt schlicht in der Liste. Sie wird nicht als `null` oder Fehler zurückgegeben. Ein Team ganz ohne Schedule (nur mit Team-Overrides) taucht hier ebenfalls nicht auf, weil `scheduleId` nicht gefüllt werden kann; wer dort Bereitschaft hat, siehst du über `GET /api/im/teams/{id}/on-call-now`. ```json { "items": [ { "teamId": 3, "tierId": 12, "tierOrder": 1, "scheduleId": 7, "sourceScheduleId": 7, "userId": "MFcTjWmYq2LpzR8vK1sXo", "userName": "Grace Hopper", "userImage": "/api/assets/avatar/MFcTjWmYq2LpzR8vK1sXo", "shiftEndsAt": "2026-07-18T09:00:00.000Z", "shiftEndsAtIsLowerBound": false } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Einträge); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. `userImage` ist die Auslieferungs-URL des Profilbilds oder `null`, wenn die Person keines hat. Ein selbst hochgeladenes Bild liegt hinter einem autorisierenden Pfad dieser API und muss mit denselben Zugangsdaten abgerufen werden. | Feld | Beschreibung | |------|-------------| | `teamId` | Das Team. | | `tierId` | Die Eskalationsstufe, für die die Person Bereitschaft hat. | | `tierOrder` | Position dieser Stufe in der Eskalationskette des Teams, ab 1 gezählt. | | `scheduleId` | Altfeld, immer gesetzt: der Schedule, aus dem die Person kommt, sonst der erste Schedule der Stufe, sonst der erste Schedule des Teams. Den genauen Wert liefert `sourceScheduleId`. | | `sourceScheduleId` | Der Schedule, dessen Rotation und Overrides die Person in Bereitschaft bringen, oder `null`, wenn das nur ein Team-Override tut. | | `userId`, `userName`, `userImage` | Die Person in Bereitschaft. | | `shiftEndsAt` | Ende der ununterbrochenen Bereitschaft der Person in dieser Stufe: der nächste Zeitpunkt, an dem sie keine Bereitschaft mehr hat. Rotationsabschnitte, in denen direkt danach wieder dieselbe Person dran ist, aneinanderliegende Schichten und Overrides werden übersprungen. Ein Plan mit einer Person bis zum 31. Dezember meldet also den 31. Dezember, nicht das Ende des laufenden Rotationsabschnitts. Ein Override, der die Bereitschaft wegnimmt, beendet sie mit seinem Beginn. | | `shiftEndsAtIsLowerBound` | `true`, wenn die Bereitschaft nicht innerhalb der nächsten 90 Tage (…
### Organisationseinstellungen
URL: https://docs.uptimeify.io/de/api/incident-management/org-settings
Description: Die Incident-Management-Einstellungen deiner Organisation lesen und ändern: Monitoring-Brücke, SMS/Anruf-Mehrverbrauch und Fallback-Kanal.
Summary: `GET /api/im/org-settings` · `PATCH /api/im/org-settings` Die Incident-Management-Einstellungen deiner Organisation. Beide Endpunkte funktionieren auch, solange Incident Management **noch nicht aktiviert** ist; so kannst du den Stand prüfen und die Konfiguration vor der Aktivierung vorbereiten. Die Aktivierung selbst erfolgt im Dashboard, nicht über diesen Endpunkt. ## Authentifizierung Erfordert eine IM-berechtigte Rolle (`admin`, `editor` oder `responder`) oder ein organisationsweites API-Token. Anders als beim Rest dieser API muss Incident Management nicht aktiviert sein. Lesen darf jede IM-berechtigte Rolle. **Ändern** erfordert die Rolle `admin`. Ein organisationsweites API-Token läuft mit der Rolle der Person, die es erstellt hat. ## Einstellungen abrufen `GET /api/im/org-settings` ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/org-settings" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ### Antwort (Response) `200 OK` ```json { "organizationId": 1, "enabled": true, "overageEnabled": false, "monitoringBridge": "both", "fallbackChannelId": 10, "fallbackChannel": null } ``` | Feld | Beschreibung | |-------|-------------| | `enabled` | Ob Incident Management aktiv ist. Hier nur lesbar. | | `overageEnabled` | Ob SMS- und Anruf-Benachrichtigungen über das enthaltene Kontingent hinaus weiterlaufen dürfen (kostenpflichtig). Standard `false`. | | `monitoringBridge` | Wie Monitoring-Incidents mit Incident Management zusammenhängen. `both` (Standard): Monitoring-Incidents öffnen auch IM-Incidents, klassische Alarme gehen weiter raus. `im_only`: Monitoring-Incidents öffnen IM-Incidents, klassische Alarme werden unterdrückt. `classic_only`: keine Brücke, nur klassische Alarme. | | `fallbackChannelId` | ID des [Kanals](/de/api/incident-management/channels), der benachrichtigt wird, wenn einer Eskalation die Stufen ausgehen, oder `null`. | | `fallbackChannel` | Altfeld, nur lesbar, ohne Wirkung. Nutze `fallbackChannelId`. | ## Einstellungen ändern `PATCH /api/im/org-settings` Teilweise Aktualisierung. Mindestens ein Feld ist nötig; jeder andere Schlüssel ergibt `400`. ### Request Body | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|-------------| | `overageEnabled` | boolean | Nein | SMS/Anrufe über das enthaltene Kontingent hinaus erlauben. | | `monitoringBridge` | string | Nein | `im_only`, `classic_only` oder `both`. | | `fallbackChannelId` | integer \| null | Nein | Ein **aktiver** Kanal deiner Organisation, oder `null` zum Entfernen. | `enabled` lässt sich hier nicht setzen, und das Altfeld `fallbackChannel` wird abgelehnt. ### Beispiel (cURL) ```bash curl -X PATCH "$BASE_URL/api/im/org-settings" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "fallbackChannelId": 10, "monitoringBridge": "im_only" }' ``` ### Antwort (Response) `200 OK`: die aktualisierten Einstellungen, in derselben Form wie die GET-Antwort. ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`imAccessDenied`) bei Verwendung eines kunden-gescopten Tokens, oder wenn deine Session keine IM-berechtigte Rolle hat - `403 Forbidden` (`forbidden`) wenn du ohne die Rolle `admin` ändern willst - `400 Bad Request` (`invalidRequestBody`) wenn der Body leer ist oder einen nicht unterstützten Schlüssel enthält (auch `enabled`), `overageEnabled` kein Boolean ist, `monitoringBridge` keinen erlaubten Wert hat, oder `fallbackChannelId` weder eine positive Ganzzahl noch `null` noch ein Kanal deiner Organisation ist - `400 Bad Request` (`imChannelInactive`) wenn `fallbackChannelId` auf einen inaktiven Kanal zeigt - `400 Bad Request` (`imFallbackChannelDeprecated`) wenn der Body `fallbackChannel` enthält
### Ausgehende Integrationen
URL: https://docs.uptimeify.io/de/api/incident-management/outbound-integrations
Description: Incident-Management-Ereignisse an Slack, Microsoft Teams, Discord, Jira, PagerDuty, Opsgenie oder einen generischen Webhook weiterleiten, Zustellungen einsehen und erneut senden.
Summary: `GET /api/im/outbound` · `POST /api/im/outbound` · `GET /api/im/outbound/:id` · `PATCH /api/im/outbound/:id` · `DELETE /api/im/outbound/:id` · `GET /api/im/outbound/:id/history` · `POST /api/im/outbound/:id/retry` Eine **ausgehende Integration** leitet Incident-Ereignisse (angelegt, bestätigt, Severity oder Status geändert, Kommentar, gelöst) an ein externes System weiter. Anders als ein [Kanal](/de/api/incident-management/channels), der ein Paging-Ziel einer Eskalation ist, spiegelt eine ausgehende Integration den Lebenszyklus des Incidents in ein anderes Werkzeug. Eine Integration gilt entweder organisationsweit (`teamId: null`) oder gehört zu einem [Team](/de/api/incident-management/teams). ## Authentifizierung Erfordert den Basiszugriff auf Incident Management, den jeder Endpunkt dieser API braucht (eine IM-berechtigte Rolle `admin`, `editor` oder `responder`, oder ein organisationsweites API-Token; Incident Management muss für die Organisation aktiviert sein). Lesen (Liste, Detail, Verlauf) darf jede IM-berechtigte Rolle. **Anlegen, Ändern, Löschen und erneutes Senden** erfordern bei einer organisationsweiten Integration die Rolle `admin`, bei einer Team-Integration die Rolle `admin` oder eine Team-Admin-Mitgliedschaft. Ein organisationsweites API-Token läuft mit der Rolle der Person, die es erstellt hat; ein Token, das ein Organisations-Admin erstellt hat, erfüllt diese Hürde also. Eine Team-Admin-Mitgliedschaft gilt für ein Token nie. ## Integrationstypen und `config` | `type` | Pflichtfelder in `config` | Optionale Felder in `config` | Nur schreibbare Felder | |--------|--------------------------|--------------------------|-------------------| | `slack` | `webhookUrl` | | `webhookUrl` | | `teams` | `webhookUrl` | | `webhookUrl` | | `discord` | `webhookUrl` | | `webhookUrl` | | `jira` | `baseUrl` (muss mit `https://` beginnen), `email`, `apiToken`, `projectKey` | `issueType` (Standard `Task`) | `apiToken` | | `pagerduty_v2` | `routingKey` | | `routingKey` | | `opsgenie` | `apiKey` | `region` (`us` oder `eu`, Standard `eu`) | `apiKey` | | `webhook` | `webhookUrl` | `bearerToken`, `headers` (Objekt aus Header-Name und Wert) | `webhookUrl`, `bearerToken`, `headers` | **Nur schreibbare Felder werden verschlüsselt gespeichert und nie zurückgegeben.** Jede Antwort setzt sie auf `null` und ergänzt pro Feld ein Flag: `hasWebhookUrl`, `hasApiToken`, `hasRoutingKey`, `hasApiKey`, `hasBearerToken`, und bei `webhook` zusätzlich `hasHeaders` (das ganze `headers`-Objekt kommt als `null` zurück). Nur schreibbare Felder eines anderen Typs werden verworfen, nicht gespeichert: ein `bearerToken` oder `headers` bei einer `slack`-Integration wird ignoriert, ebenso ein `apiKey` bei `jira`. URLs werden beim Speichern nicht auf Erreichbarkeit geprüft. Vom Kunden angegebene Ziele werden beim Senden geprüft: Eine URL, die auf eine private oder lokale Adresse auflöst, lässt die Zustellung scheitern; sie erscheint dann als `failed` im [Zustellverlauf](#zustellverlauf). ## Das `filters`-Objekt | Feld | Typ | Beschreibung | |-------|------|-------------| | `teams` | integer[] | Nur Ereignisse von Incidents dieser Team-IDs weiterleiten. | | `severities` | string[] | Teilmenge von `sev1`, `sev2`, `sev3`, `sev4`. | | `eventKinds` | string[] | Teilmenge von `incident_created`, `acknowledged`, `severity_changed`, `status_changed`, `comment`, `resolved`. | Ein leeres Objekt `{}` leitet alles weiter. Bei `jira` wird ein weggelassenes `eventKinds` zu `["incident_created"]`, Jira bekommt also ein Ticket pro Incident. **Abgelöstes Feld:** Bis zum 18.01.2027 liefern Antworten `filters.event_kinds` weiter neben `filters.eventKinds`, und Request-Bodys nehmen es noch an. Sende `eventKinds`; beide mit verschiedenen Werten ergeben `400` `invalidRequestBody`. ## Integrationen auflisten `GET /api/im/outbound` Liefert alle Integrationen deiner Organisation, nach Name sortiert, Geheimnisse geschwärzt. ### Query-Parameter | Parameter | Typ | Standard | Beschreibung | |-…
### Postmortem und Nachbereitung
URL: https://docs.uptimeify.io/de/api/incident-management/postmortems
Description: Nach einem Vorfall Ursache, Lessons Learned und Maßnahmen festhalten, einen Katalog der Ursachen führen und die Nachbereitung verfolgen.
Summary: `GET /api/im/causes` · `POST /api/im/causes` · `PATCH /api/im/causes/:id` `GET /api/im/incidents/:id/postmortem` · `PUT /api/im/incidents/:id/postmortem` · `POST /api/im/incidents/:id/postmortem/complete` · `POST /api/im/incidents/:id/postmortem/reopen` `GET /api/im/postmortems` · `GET /api/im/postmortems/:id` · `POST /api/im/postmortems/:id/actions` · `PATCH /api/im/postmortems/:id/actions/:actionId` · `DELETE /api/im/postmortems/:id/actions/:actionId` `GET /api/im/follow-up` · `GET /api/im/quarterly-reviews` · `POST /api/im/quarterly-reviews` Nach einem gelösten Vorfall schreiben Sie dazu ein Postmortem: Zusammenfassung, Auswirkung, Ursache, eine Ursache aus dem Katalog Ihrer Organisation, Lessons Learned und Maßnahmen. Die Katalog-Ursache macht wiederholte Vorfälle zählbar: Ist NIS-2 eingeschaltet, erscheinen Ursachen, die in mindestens zwei abgeschlossenen Postmortems innerhalb von sechs Monaten vorkommen, als wiederholt (Art. 4 Durchführungsverordnung (EU) 2024/2690). **Uptimeify zählt nur. Ob eine Wiederholung erheblich ist, entscheiden Sie über einen [Meldefall](/de/api/incident-management/report-cases).** Ein Postmortem hält eine Kopie der Vorfallsdaten. Wird der Vorfall nach 12 Monaten gelöscht, wird `incidentId` zu `null`; das Postmortem bleibt drei Jahre nach dem Abschluss erhalten. `:id` unter `/incidents` ist die numerische ID eines IM-Incidents. `:id` unter `/postmortems` und `/causes` sowie `:actionId` sind eine `publicId` oder eine numerische `id`. ## Authentifizierung Postmortem und Maßnahmen gehen mit Sitzung, organisationsweitem API-Token oder Agent-Token, wie die übrigen Incident-Endpunkte. Lesen braucht Zugriff auf den Incident; Schreiben braucht die Mitgliedschaft im Team des Incidents oder die Rolle `admin` (`403 imTeamMembershipRequired`). Ursachen anlegen oder ändern und ein abgeschlossenes Postmortem wieder öffnen brauchen eine Sitzung als Organisations-Admin oder [Meldeverantwortliche](/de/api/incident-management/nis2-settings) (`403 nis2OfficerRequired`). Postmortems gelöschter Incidents sehen ebenfalls nur sie. Ein Incident, Postmortem oder eine Ursache einer anderen Organisation antwortet `404`, wie ein fehlender. ## Ursachen Der Katalog gilt für alle Postmortems Ihrer Organisation. Lesen geht mit Sitzung oder Token; Ursachen anlegen und ändern braucht eine **angemeldete Sitzung** als Organisations-Admin oder Meldeverantwortliche. API- und Agent-Tokens erhalten dort `403 nis2OfficerRequired`; die Anfragen unten laufen deshalb aus der Dashboard-Sitzung und stehen ohne Token da. `GET /api/im/causes` antwortet `{ items, total, page, perPage }`, sortiert nach Name. | Query | Beschreibung | |-------|--------------| | `includeArchived` | `true` oder `1` listet auch archivierte Ursachen. Standard `false`. | | `page` | Standard `1`. | | `perPage` | Standard `50`, höchstens `200`. | `POST /api/im/causes` legt eine Ursache an und antwortet `201` mit ihr. | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `name` | string | Ja | 1 bis 200 Zeichen, je Organisation eindeutig ohne Rücksicht auf Groß/Klein (`409 causeNameTaken`). | | `description` | string oder null | Nein | Höchstens 2000 Zeichen. | `PATCH /api/im/causes/:id` ändert `name`, `description` oder `archived` (`true` archiviert, `false` holt zurück) und antwortet die Ursache. Eine Ursache einer anderen Organisation oder eine unbekannte antwortet `404 causeNotFound`, ein schon vergebener Name `409 causeNameTaken`. Ursachen werden nie gelöscht: archivierte bleiben an alten Postmortems und zählen für Wiederholungen weiter. ```http POST /api/im/causes Content-Type: application/json { "name": "Abgelaufenes TLS-Zertifikat" } ``` `201 Created` ```json { "id": 3, "publicId": "0b7f1c52-6a0e-4c4f-9d1e-2f7c9a3b8e11", "name": "Abgelaufenes TLS-Zertifikat", "description": null, "archivedAt": null, "createdAt": "2026-10-22T09:00:00.000Z", "updatedAt": "2026-10-22T09:00:00.000Z" } ``` | Feld | Beschreibung | |------|--------------| | `…
### Meldefälle (NIS-2)
URL: https://docs.uptimeify.io/de/api/incident-management/report-cases
Description: Einen NIS-2-Meldefall führen: Kriterien, Entscheidung zur Meldepflicht, Zeitpunkt der Kenntnis, Fristen, Berichtsentwürfe und das Protokoll Ihrer Abgaben im BSI-Portal.
Summary: `GET /api/im/report-cases` · `POST /api/im/report-cases` · `GET /api/im/report-cases/:id` · `PATCH /api/im/report-cases/:id` `POST /api/im/report-cases/:id/aware-at` · `POST /api/im/report-cases/:id/criteria` · `POST /api/im/report-cases/:id/decision` · `POST /api/im/report-cases/:id/interim-request` · `POST /api/im/report-cases/:id/close` `POST /api/im/report-cases/:id/incidents` · `DELETE /api/im/report-cases/:id/incidents/:incidentId` · `GET /api/im/report-cases/:id/draft` · `POST /api/im/report-cases/:id/submissions` Ein Meldefall sammelt, was Sie für eine NIS-2-Meldung brauchen (Art. 23 NIS-2-Richtlinie, § 32 BSIG): die verknüpften Vorfälle, je Erheblichkeitskriterium eine Entscheidung, die Entscheidung zur Meldepflicht, den Zeitpunkt der Kenntnis und die Fristen daraus (Frühwarnung 24 h, Meldung 72 h, Abschlussmeldung einen Monat nach der Meldung, Zwischenmeldung auf Anfrage). **Jede Meldung geben Sie selbst im BSI-Portal ab. Uptimeify übermittelt nichts und stuft keinen Vorfall selbst ein.** Kriterien, Abgaben und Zeitachse sind nur anfügbar: nachträglich lässt sich nichts ändern oder löschen. Geschlossene Fälle werden drei Jahre aufbewahrt. `:id` ist die `publicId` des Falls oder seine numerische `id`. `:incidentId` ist die numerische ID eines IM-Vorfalls. ## Authentifizierung Nur mit Sitzung (Dashboard-Anmeldung); API-Tokens werden mit `403` (`nis2OfficerRequired`) abgewiesen. NIS-2-Meldefälle müssen eingeschaltet sein ([NIS-2-Einstellungen](/de/api/incident-management/nis2-settings)). Organisations-Admins und eingetragene Meldeverantwortliche dürfen lesen und schreiben, alle anderen bekommen `403`. Ein Fall einer anderen Organisation antwortet `404` (`reportCaseNotFound`), genau wie ein fehlender. ## Meldefälle auflisten `GET /api/im/report-cases` | Query | Beschreibung | |-------|--------------| | `status` | Kommagetrennter Statusfilter, z. B. `reportable,early_warning_submitted`. | | `page` | Standard `1`. | | `perPage` | Standard `50`, höchstens `200`. | Sortiert nach der nächsten offenen Frist; Fälle ohne Frist stehen am Ende, neueste zuerst. ```bash curl "$BASE_URL/api/im/report-cases?status=reportable&perPage=20" -H "Cookie: $SESSION_COOKIE" ``` `200 OK` ```json { "items": [ { "id": 12, "publicId": "0b6f9a52-7a43-4c8e-9f1e-5c2d8a1b3e77", "title": "Ausfall Kundenportal", "status": "reportable", "awareAt": "2026-10-21T07:00:00.000Z", "createdAt": "2026-10-21T07:05:00.000Z", "nextDeadline": { "stage": "early_warning", "dueAt": "2026-10-22T07:00:00.000Z", "met": false, "metAt": null, "late": false }, "lateStages": [], "incidentCount": 1 } ], "total": 1, "page": 1, "perPage": 20 } ``` `nextDeadline` ist die früheste offene Frist (`{ stage, dueAt, met, metAt, late }`, siehe [Fristfelder](#meldefall-lesen)) oder `null`. `lateStages` nennt die Stufen, deren Frist verspätet erfüllt wurde, auch bei geschlossenen Fällen. Statuswerte: `assessment`, `not_reportable`, `reportable`, `early_warning_submitted`, `notification_submitted`, `final_submitted`, `closed`. ## Meldefall öffnen `POST /api/im/report-cases` | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `title` | string | Ja | 1 bis 200 Zeichen. | | `incidentIds` | integer[] | Nein | IM-Vorfälle Ihrer Organisation, höchstens 50, keine Test-Vorfälle. | `awareAt` beginnt mit dem Zeitpunkt der Anfrage; korrigieren mit `aware-at`. Jeder andere Schlüssel ist ein `400`. ```bash curl -X POST "$BASE_URL/api/im/report-cases" -H "Cookie: $SESSION_COOKIE" -H "Content-Type: application/json" \ -d '{ "title": "Ausfall Kundenportal", "incidentIds": [4812] }' ``` `201 Created`: der ganze Fall, gleiche Form wie [Meldefall lesen](#meldefall-lesen). ## Meldefall lesen `GET /api/im/report-cases/:id` `200 OK` ```json { "id": 12, "publicId": "0b6f9a52-7a43-4c8e-9f1e-5c2d8a1b3e77", "organizationId": 2, "title": "Ausfall Kundenportal", "status": "reportable", "awareAt": "2026-10-21T07:00:00.000Z", "decision": "reportable", "decidedBy": "u_8f2c", "decidedAt": "2…
### Berichte
URL: https://docs.uptimeify.io/de/api/incident-management/reports
Description: Incident-Bericht (Volumen, MTTA, MTTR nach Team, Schweregrad, Kategorie oder Monat) und On-Call-Bericht (Minuten pro Person) für einen Zeitraum, als JSON oder CSV, und der NIS-2-Leitungsbericht als JSON oder PDF.
Summary: Zwei Berichte über einen expliziten Zeitraum, jeweils als JSON oder als CSV-Download, und der [NIS-2-Leitungsbericht](#nis-2-leitungsbericht) als JSON oder PDF. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token. Incident Management muss für die Organisation aktiviert sein. ## Zeitraum Beide Berichte verlangen `from` und `to` als ISO 8601. `from` zählt mit, `to` nicht, `to` muss nach `from` liegen, und der Zeitraum darf höchstens 400 Tage umfassen. ## Incident-Bericht `GET /api/im/reports/incidents` Zählt die im Zeitraum ausgelösten Incidents und ihre mittlere Zeit bis zur Bestätigung (MTTA) und bis zur Lösung (MTTR), in Minuten. Ein Incident, der nie bestätigt oder gelöst wurde, fällt aus dem jeweiligen Durchschnitt heraus, er zählt nicht als null. Test-Incidents zählen nicht mit. ### Query-Parameter | Parameter | Typ | Erforderlich | Beschreibung | |-----------|------|----------|--------------| | `from`, `to` | ISO 8601 | Ja | Siehe [Zeitraum](#zeitraum). | | `groupBy` | string | Nein | `month` (Standard), `team`, `severity`, `category` oder `service`. Bei `service` ist `groupKey` die ID des [Dienstes](/de/api/incident-management/services), Vorfälle ohne Dienst bilden die Gruppe `none`. Jeder andere Wert wird mit `400` abgewiesen. | | `tz` | number | Nein | Dein UTC-Versatz in Minuten (z. B. `120`), Standard `0`, begrenzt auf plus/minus 1440. Entscheidet, in welchen lokalen Monat ein Incident fällt. Keine Ganzzahl: `400`. | | `format` | string | Nein | `json` (Standard) oder `csv`, das eine CSV-Datei statt JSON liefert. Jeder andere Wert: `400`. | ### Beispiel (cURL) ```bash curl "$BASE_URL/api/im/reports/incidents?from=2026-07-01T00:00:00Z&to=2026-10-01T00:00:00Z&groupBy=severity" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort (Response) ```json { "from": "2026-07-01T00:00:00.000Z", "to": "2026-10-01T00:00:00.000Z", "groupBy": "severity", "summary": { "count": 27, "mttaMinutes": 6.4, "mttrMinutes": 82.15 }, "groups": [ { "groupKey": "sev1", "groupLabel": "sev1", "count": 3, "mttaMinutes": 1.8, "mttrMinutes": 41.5 }, { "groupKey": "sev3", "groupLabel": "sev3", "count": 24, "mttaMinutes": 7.1, "mttrMinutes": 87.24 } ] } ``` `groupKey` / `groupLabel` je Gruppierung: `team` liefert Team-ID und Teamname, `severity` liefert `sev1` bis `sev4`, `category` liefert `availability`, `security`, `other` oder `uncategorized` (noch nicht eingestuft), `month` liefert in beiden Feldern den UTC-Zeitpunkt des lokalen Monatsbeginns (z. B. `2026-08-31T22:00:00.000Z` für August bei `tz=120`). Gruppen ohne Incidents fehlen. Durchschnitte sind auf zwei Nachkommastellen gerundet und `null`, wenn kein Incident der Gruppe in Frage kommt. Mit `format=csv` ist die Antwort `text/csv` mit `Content-Disposition: attachment; filename="incidents-report-.csv"` und den Spalten `,count,mttaMinutes,mttrMinutes`. Monate stehen als `YYYY-MM` darin, leere Durchschnitte als leere Zellen. Die Zusammenfassung ist nicht Teil der CSV. ## On-Call-Bericht `GET /api/im/reports/on-call` On-Call-Minuten pro Person innerhalb des Zeitraums. Schichten, die vor `from` beginnen oder nach `to` enden, zählen nur mit ihrem Anteil im Zeitraum. Team-Overrides vom Typ `online` (ohne Schedule) kommen zu den geplanten Schichten hinzu. ### Query-Parameter | Parameter | Typ | Erforderlich | Beschreibung | |-----------|------|----------|--------------| | `from`, `to` | ISO 8601 | Ja | Siehe [Zeitraum](#zeitraum). | | `format` | string | Nein | `json` (Standard) oder `csv`, das eine CSV-Datei statt JSON liefert. Jeder andere Wert: `400`. | ### Beispiel (cURL) ```bash curl "$BASE_URL/api/im/reports/on-call?from=2026-09-01T00:00:00Z&to=2026-10-01T00:00:00Z" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort (Response) ```json { "periodStart": "2026-09-01T00:00:00.000Z", "periodEnd": "2026-10-01T00:00:00.000Z", "users": [ { "userId": "u_abc123", "userName": "Jana Weber", "minutes": 21600 }, { "userId": "u_d…
### Incident lösen
URL: https://docs.uptimeify.io/de/api/incident-management/resolve-incident
Description: Löst einen Incident-Management-Incident aus jedem nicht geschlossenen Status. Das ist der einzige Endpunkt, der einen Incident auf resolved setzen kann.
Summary: `POST /api/im/incidents/:id/resolve` Löst einen Incident aus jedem nicht geschlossenen Status (`triggered`, `acknowledged`, `investigating`, `identified`, `monitoring`). Das ist der einzige Endpunkt, der einen Incident auf `resolved` setzen kann; [Status ändern](/de/api/incident-management/acknowledge-incident#status-ändern) lehnt `resolved` als Ziel bewusst ab. Das Lösen stoppt die Eskalation, schickt den alarmierten Personen die Entwarnung, aktualisiert Statusseiten, die über eine [Statusseiten-Regel](/de/api/incident-management/statuspage-rules) gesteuert werden, und benachrichtigt ausgehende Integrationen. Bei einem Test-Incident (`isTest: true`) entfallen Entwarnung, Statusseiten-Aktualisierung und ausgehende Benachrichtigung. ## Authentifizierung Jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder ein organisationsweiter API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). Incident Management muss für die Organisation aktiviert sein. Dem Team des Incidents vorbehalten: du musst Mitglied im Team des Incidents (`teamId`) oder Organisations-Admin sein. Ein organisationsweiter API-Token gilt dabei als Organisations-Admin. Das [Bestätigen](/de/api/incident-management/acknowledge-incident#bestätigen) ist nicht so eingeschränkt. ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Standard | Beschreibung | |-------|------|----------|---------|-------------| | `note` | string | Nein | `null` | Optionale Lösungsnotiz als Freitext, höchstens 10.000 Zeichen. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/incidents/42/resolve" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "note": "Restarted the connection pool, monitoring for recurrence." }' ``` ## Antwort (Response) `200 OK`: der aktualisierte Incident-Datensatz (gleiche Form wie die `items` von [Incidents auflisten](/de/api/incident-management/list-incidents), ohne die Ergänzungsfelder). ```json { "id": 42, "organizationId": 1, "teamId": 3, "title": "Database connection pool exhausted", "customerId": null, "primarySourceId": 7, "severity": "sev1", "severityManual": false, "status": "resolved", "mergedIntoId": null, "escalationPolicyId": null, "currentTier": null, "escalationEpoch": 2, "escalationCycle": 0, "acknowledgedBy": "MFcTjWmYq2LpzR8vK1sXo", "acknowledgedAt": "2026-07-17T09:20:00.000Z", "snoozedUntil": null, "autoResolve": true, "resolvedBy": null, "resolveNote": "Restarted the connection pool, monitoring for recurrence.", "statuspageUpdate": null, "createdBy": null, "sourceKind": "alert", "isTest": false, "triggeredAt": "2026-07-17T09:12:00.000Z", "resolvedAt": "2026-07-17T09:45:00.000Z" } ``` ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn die angemeldete Person keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `403 Forbidden` (`imTeamMembershipRequired`) wenn du weder Mitglied im Team des Incidents noch Organisations-Admin bist - `400 Bad Request` (`invalidRequestBody`) wenn `:id` keine positive Ganzzahl ist, oder `note` kein String ist oder 10.000 Zeichen überschreitet - `404 Not Found` (`imIncidentNotFound`) wenn der Incident nicht existiert oder zu einer anderen Organisation gehört - `422 Unprocessable Entity` (`imIncidentAlreadyClosed`) wenn der Incident bereits `resolved` oder `merged` ist - `409 Conflict` (`imIncidentStatusConflict`) wenn der Incident zwischen Lesen und Schreiben gleichzeitig geschlossen wurde
### Routing-Regeln
URL: https://docs.uptimeify.io/de/api/incident-management/routing-rules
Description: Routing-Regeln im Incident Management auflisten, anlegen, ändern und löschen: welchem Team ein neuer Incident zugeordnet wird, optional mit überschriebener Severity.
Summary: `GET /api/im/routing` · `POST /api/im/routing` · `GET /api/im/routing/:id` · `PATCH /api/im/routing/:id` · `DELETE /api/im/routing/:id` Eine **Routing-Regel** entscheidet, zu welchem [Team](/de/api/incident-management/teams) ein neuer Incident gehört. Wenn ein Alert einen Incident öffnet, werden die Regeln deiner Organisation nach `priority` durchlaufen (niedrigste zuerst, bei Gleichstand nach `id`). Die erste Regel, deren `match` zutrifft, gewinnt: Der Incident geht an das `teamId` dieser Regel, und `severityOverride` (falls gesetzt) ersetzt die Severity des Alerts. Trifft keine Regel zu, geht der Incident an das Team der [Alert-Quelle](/de/api/incident-management/alert-sources), die den Alert empfangen hat. ## Authentifizierung Erfordert den Basiszugriff auf Incident Management, den jeder Endpunkt dieser API braucht (eine IM-berechtigte Rolle `admin`, `editor` oder `responder`, oder ein organisationsweites API-Token; Incident Management muss für die Organisation aktiviert sein). Lesen darf jede IM-berechtigte Rolle. **Anlegen, Ändern und Löschen** erfordern zusätzlich die Schreibhürde: Deine Rolle muss `admin` sein, oder du musst Team-Admin des Teams der Regel sein. Ein organisationsweites API-Token läuft mit der Rolle der Person, die es erstellt hat; ein Token, das ein Organisations-Admin erstellt hat, erfüllt diese Hürde also. Eine Team-Admin-Mitgliedschaft gilt für ein Token nie. ## Das `match`-Objekt | Feld | Typ | Beschreibung | |-------|------|-------------| | `sourceIds` | integer[] | IDs von Alert-Quellen. Maximal 500 Einträge. | | `severity` | string[] | Severities des Alerts, jeweils `sev1`, `sev2`, `sev3` oder `sev4`. | | `customerIds` | integer[] | Kunden-IDs. Maximal 500 Einträge. | | `monitorIds` | integer[] | Monitor-IDs. Maximal 500 Einträge. | | `tags` | string[] | Nicht-leere Strings. Maximal 200 Einträge. | | `fieldMatches` | object | Nur String-Werte. Maximal 50 Schlüssel. | Ein leeres Objekt `{}` (oder ein weggelassenes `match`) trifft auf jeden Alert zu; damit baust du eine Auffangregel mit hoher `priority`-Zahl. Jede ID in `sourceIds`, `customerIds` und `monitorIds` muss zu deiner Organisation gehören, sonst schlägt die Anfrage mit `422` fehl. Alle gesetzten Felder müssen zutreffen (UND); ein leeres Array oder ein leeres `fieldMatches` schränkt nichts ein. **Abgelöste Felder:** Bis zum 18.01.2027 liefern Antworten `match.source_ids`, `match.customer_ids`, `match.monitor_ids` und `match.field_matches` weiter neben ihren Nachfolgern, und Request-Bodys nehmen sie noch an. Sende die camelCase-Namen; beide Schreibweisen mit verschiedenen Werten ergeben `400` `invalidRequestBody`. - `customerIds` und `monitorIds` treffen auf Alerts der eingebauten Monitoring-Brücke zu, die Kunde und Id des Monitors mitbringen. Alerts anderer Quellen haben beides nicht, eine Regel mit diesen Feldern trifft auf sie also nie zu. - `tags` trifft zu, wenn die gemappten `tags` des Alerts (Attribut-Mapping) mindestens einen Wert teilen, ohne Groß-/Kleinschreibung. - `fieldMatches` vergleicht jeden Schlüssel als Text mit dem gemappten Feld dieses Namens, sonst mit dem gleichnamigen Feld auf oberster Ebene der Nutzlast. Ein fehlendes Feld trifft nicht zu. ## Routing-Regeln auflisten `GET /api/im/routing` Liefert alle Regeln deiner Organisation in Auswertungsreihenfolge (`priority` aufsteigend, dann `id` aufsteigend). ### Query Parameter | Parameter | Typ | Standard | Beschreibung | |-----------|------|---------|-------------| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/routing?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ### Antwort (Response) `200 OK` ```json { "items": [ { "id": 4, "organizationId": 1, "priority": 10, "match": { "sourceIds": [7], "severity": ["sev1", "sev2"] }, "teamId": 3, "escalationPolicyId": null, "severityOverride": "sev1", "createdAt": "202…
### Schedule-Overrides
URL: https://docs.uptimeify.io/de/api/incident-management/schedule-overrides
Description: Overrides auf einem Schedule auflisten, hinzufügen, ändern und löschen: einmalige Zeitfenster, die jemanden in Bereitschaft setzen oder aus ihr nehmen, ohne die Rotation anzufassen.
Summary: Ein **Override** ist ein einmaliges Zeitfenster zusätzlich zur regulären Rotation eines [Schedules](/de/api/incident-management/schedules), für einen Urlaubstausch oder einen Krankheitstag, ohne die Rotation selbst zu bearbeiten. Diese Seite behandelt Overrides, die an einem Schedule hängen. Overrides, die dem Team ohne Schedule gehören, stehen unter [Team-Overrides](/de/api/incident-management/team-overrides). ## Authentifizierung Basis-IM-Zugriff: eine IM-berechtigte Rolle oder ein organisationsweiter API-Token, und Incident Management für die Organisation aktiviert. Auflisten darf jeder mit diesem Zugriff. Hinzufügen, Ändern und Löschen brauchen die Team-Schreibhürde für das Team des Schedules: Organisationsrolle `admin`, oder Team-Admin. Ein API-Token läuft mit der Rolle des Users, der ihn erstellt hat, also kommt nur ein Token durch, den ein Organisations-Admin erstellt hat. **Ausnahme: die eigene Schicht abgeben.** Ein einfaches Mitglied des Schedule-Teams darf eine Art Override ohne die Schreibhürde anlegen und wieder löschen: - `userId` ist der Aufrufer selbst, `type` ist `offline`, `applyScope` ist `this_team` (oder fehlt), `escalationTierOrder` ist `null` (oder fehlt), - `coveredByUserIds` enthält genau eine Person, nicht den Aufrufer, und diese ist Mitglied des Schedule-Teams, - das Fenster ist noch nicht vorbei, höchstens 7 Tage lang und liegt von `startsAt` (oder jetzt, falls später) bis `endsAt` innerhalb eines zusammenhängenden Stücks eigener Bereitschaftsschichten des Aufrufers auf diesem Schedule (direkt aneinander anschließende Schichten zählen als ein Stück), - noch kein `offline`-Override des Aufrufers auf diesem Schedule überschneidet das Fenster. Die übernehmende Person hat genau für dieses Fenster Bereitschaft. Das gilt auch für Bereitschaft, die ein Admin dem Aufrufer per `online`-Override gegeben hat: `offline`-Overrides wirken nach `online`-Overrides, also kann das Mitglied auch diese Bereitschaft abgeben. Die übernehmende Person bekommt eine E-Mail (den Bereitschaftshinweis, außer sie hat E-Mail oder Übergabehinweise in ihren Benachrichtigungseinstellungen abgeschaltet) und eine weitere, wenn der Override wieder gelöscht wird, vom Aufrufer oder von einem Admin; eine identische Wiederholung (gleiche Art, sich überschneidendes Fenster) innerhalb von 10 Minuten geht nur einmal raus, ein Wechsel zwischen abgegeben und zurückgenommen immer. Nimmt sich jemand selbst mit Vertretungen aus der Bereitschaft (ein Mitglied oder ein Admin), bekommt jede übernehmende Person diesen Hinweis, und beim Löschen des Overrides bekommt jede den Hinweis „zurückgenommen". Ein Mitglied kann höchstens 10 Schichten pro Stunde abgeben; die elfte bekommt `429` `imShiftGiveAwayRateLimited`. Löschen darf ein Mitglied nur einen `offline`-Override über sich selbst, den es selbst angelegt hat; einen Override, den ein Admin über es angelegt hat, löscht weiterhin nur ein Admin. Ändern bleibt Admins vorbehalten. Alles andere, was ein Mitglied schickt, wird mit `403` `imShiftGiveAwayDenied` und einem `reason` abgelehnt (siehe [Häufige Fehler](#häufige-fehler)). ## Override-Felder | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|-------------| | `userId` | string | Ja | Die betroffene Person: wer in Bereitschaft geht (`online`) oder aus ihr herausgenommen wird (`offline`). | | `startsAt` | string | Ja | ISO-8601-Zeitstempel, Beginn des Fensters. | | `endsAt` | string | Ja | ISO-8601-Zeitstempel, Ende des Fensters. Muss nach `startsAt` liegen. | | `type` | string | Ja | `online`: Die Person hat im Fenster Bereitschaft und ersetzt alle anderen, die gerade Bereitschaft haben. `offline`: Die Person wird aus der Bereitschaft genommen. | | `coveredByUserIds` | string[] | Nein | Nur bei `offline`, bis zu 200: wer übernimmt. Alle genannten Vertretungen werden alarmiert, jede genau für die Alarme, die die betroffene Person bekäme. Leer oder weggelassen hinterlässt eine Lücke, die die Eskalations-Engine beim Alarmieren aus ei…
### Schedule-Vorschau
URL: https://docs.uptimeify.io/de/api/incident-management/schedule-preview
Description: Die Schichten und Abdeckungslücken berechnen, die die gespeicherte Rotation eines Schedules in den nächsten vier Wochen ergibt, ohne etwas zu schreiben.
Summary: `POST /api/im/schedules/:id/preview` Rechnet die **gespeicherte** Konfiguration des Schedules (Kadenz, Rotationsgruppen, Wochenfenster, Gültigkeitszeitraum) mit derselben Schichtberechnung durch, die der Alarmierungs-Worker verwendet, für die nächsten vier Wochen ab jetzt, und liefert die Schichten und die Lücken, in denen niemand Bereitschaft hat. Es wird nichts gespeichert. Standardmäßig fließen die gespeicherten Overrides des Schedules ein. Mit `overrides` probierst du stattdessen andere Override-Fenster aus. Team-Overrides und `all_teams`-Overrides, die an anderen Schedules angelegt wurden, sind nicht Teil der Vorschau. ## Authentifizierung Basis-IM-Zugriff: eine IM-berechtigte Rolle (`admin`, `editor` oder `responder`) oder ein organisationsweiter API-Token, und Incident Management für die Organisation aktiviert. Eine Team-Rolle ist nicht nötig. ## Anfrage (Request Body) Der Body ist optional. | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|-------------| | `overrides` | array | Nein | Bis zu 500 Override-Fenster, die für diese Vorschau die gespeicherten Overrides ersetzen. Jeweils: `{ userId, startsAt, endsAt, type?, coveredByUserIds? }`, `type` `online` (Standard) oder `offline`, `coveredByUserIds` nur bei `offline`. `[]` zeigt die Vorschau ganz ohne Overrides. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/schedules/7/preview" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{}' ``` ## Antwort (Response) `200 OK` ```json { "from": "2026-10-09T12:00:00.000Z", "to": "2026-11-06T12:00:00.000Z", "timezone": "Europe/Berlin", "shifts": [ { "userId": "u_abc123", "layerIndex": 0, "startsAt": "2026-10-09T12:00:00.000Z", "endsAt": "2026-10-12T07:00:00.000Z", "isOverride": false }, { "userId": "u_def456", "layerIndex": 0, "startsAt": "2026-10-12T07:00:00.000Z", "endsAt": "2026-10-19T07:00:00.000Z", "isOverride": false } ], "gaps": [ { "from": "2026-11-02T07:00:00.000Z", "to": "2026-11-06T12:00:00.000Z" } ] } ``` - `layerIndex` nummeriert die gleichzeitigen Bereitschaftsplätze (`0` bis `roundRobinSize - 1`); Override-Schichten liegen auf höheren Indizes. `isOverride` ist `true` für eine Schicht, die aus einem Override stammt. - `gaps` listet jeden Abschnitt des Fensters, in dem keine Schicht jemanden abdeckt. Ein Schedule ohne Rotationsgruppen hat eine Lücke über das ganze Fenster. ## Häufige Fehler - `401 Unauthorized` (`unauthorized`) wenn du nicht authentifiziert bist - `403 Forbidden` (`imAccessDenied`) bei einem kunden-gescopten Token, oder wenn deine Session keine IM-berechtigte Rolle hat - `403 Forbidden` (`imNotEnabled`) wenn Incident Management für die Organisation nicht aktiviert ist - `404 Not Found` (`imScheduleNotFound`) wenn `:id` nicht existiert oder zu einer anderen Organisation gehört - `400 Bad Request` (`invalidRequestBody`) wenn `:id` keine positive Ganzzahl ist, `overrides` kein Array ist oder mehr als 500 Einträge hat, ein Eintrag keine `userId` oder kein gültiges `startsAt` vor `endsAt` hat, oder sich die gespeicherte Konfiguration nicht in Schichten umrechnen lässt (die Meldung nennt den Grund)
### Schedules (Bereitschaftspläne)
URL: https://docs.uptimeify.io/de/api/incident-management/schedules
Description: Incident-Management-Bereitschaftspläne auflisten, lesen, anlegen und löschen, und wie die Rotationskadenz eines Schedules funktioniert.
Summary: Ein **Schedule** (Bereitschaftsplan) gehört zu einem Team und einer seiner [Eskalationsstufen](/de/api/incident-management/team-tiers). Zeitzone, Gültigkeitszeitraum, Wochenfenster, Rotationskadenz und Rotationsgruppen bestimmen, wer wann Schicht hat. Ein Hintergrund-Worker macht daraus konkrete Schichten bis zu 90 Tage im Voraus; Alarmierung, [Wer hat Bereitschaft](/de/api/incident-management/on-call) und der [Team-Kalender](/de/api/incident-management/team-insights#kalender) lesen diese Schichten. Diese Endpunkte verwalten die Definition, nicht die Schichten. Die Rotation konfigurierst du mit [Schedule aktualisieren](/de/api/incident-management/update-schedule), oder du legst einen fertig konfigurierten Schedule in einem Aufruf mit [Schedule zu einer Stufe hinzufügen](/de/api/incident-management/team-tiers) an. [Schedule-Vorschau](/de/api/incident-management/schedule-preview) zeigt die entstehenden Schichten. ## Authentifizierung Basis-IM-Zugriff: eine IM-berechtigte Rolle (`admin`, `editor` oder `responder`) oder ein organisationsweiter API-Token, und Incident Management für die Organisation aktiviert. Auflisten und Lesen darf jeder mit diesem Zugriff. Anlegen und Löschen brauchen die Team-Schreibhürde für das Team des Schedules: Organisationsrolle `admin`, oder Team-Admin. Ein API-Token läuft mit der Rolle des Users, der ihn erstellt hat, also kommt nur ein Token durch, den ein Organisations-Admin erstellt hat. ## Schedules auflisten `GET /api/im/schedules` Liefert jeden Schedule deiner Organisation, sortiert nach Name. ### Query-Parameter | Parameter | Typ | Standard | Beschreibung | |-----------|------|---------|-------------| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/schedules?envelope=items" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort (Response) `200 OK` ```json { "items": [ { "id": 7, "organizationId": 1, "teamId": 3, "teamName": "Platform Team", "name": "Primary On-Call", "timezone": "Europe/Berlin", "tierId": 21, "createdAt": "2026-06-02T08:00:00.000Z", "updatedAt": "2026-09-14T10:12:00.000Z" } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Schedules); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. ## Schedule lesen `GET /api/im/schedules/:id` Liefert die vollständige Konfiguration des Schedules, sein Team und seine Overrides (gleiche Eintragsform wie unter [Schedule-Overrides](/de/api/incident-management/schedule-overrides)). `rotations` listet die Rotationsgruppen mit ihren Mitgliedern (mit `userImage`), in derselben Form wie `schedules[].rotations` beim [Stufe lesen](/de/api/incident-management/team-tiers#stufe-lesen); sie sind außerdem Teil der [Eskalationskette](/de/api/incident-management/team-tiers#eskalationskette-lesen) des Teams. ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/schedules/7" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort (Response) `200 OK` ```json { "id": 7, "organizationId": 1, "teamId": 3, "tierId": 21, "name": "Primary On-Call", "timezone": "Europe/Berlin", "effectiveFrom": null, "effectiveUntil": null, "weeklySchedules": [], "rotationMode": "explicit", "rotationRepeats": "weekly", "customRepeatUnit": null, "customRepeatValue": null, "autoRotationSize": null, "roundRobinSize": 1, "roundRobinCursor": 4, "startsOnDayOfWeek": 1, "startsOnDateOfMonth": null, "startsOnTime": "09:00", "createdAt": "2026-06-02T08:00:00.000Z", "updatedAt": "2026-09-14T10:12:00.000Z", "team": { "id": 3, "name": "Platform Team" }, "overrides": [], "rotations": [ { "id": 31, "rotationOrder": 1, "members": [ { "userId": "usr_abc", "userName": "Alex Example", "userImage": null, "memberOrder": 1 } ] } ] } ``` `roundRobinCursor` ist ein interner Zähler für di…
### Dienste
URL: https://docs.uptimeify.io/de/api/incident-management/services
Description: Dienste Ihrer Organisation auflisten, anlegen, ändern und löschen (Dienst- und Asset-Inventar mit Kritikalität und verantwortlichem Team), und wie Vorfälle ihnen zugeordnet werden.
Summary: `GET /api/im/services` · `POST /api/im/services` · `GET /api/im/services/:id` · `PATCH /api/im/services/:id` · `DELETE /api/im/services/:id` Ein **Dienst** ist etwas, das Ihre Organisation betreibt und das ein Vorfall treffen kann, etwa „Webshop“, „Kundenportal“ oder „Mail“. Jeder Dienst hat eine **Kritikalität** (`critical`, `high`, `medium`, `low`), optional ein verantwortliches [Team](/de/api/incident-management/teams) und die Monitore, aus denen er besteht. Das ist das Dienst- und Asset-Inventar, das NIS-2 verlangt (Durchführungsverordnung (EU) 2024/2690, Anhang 12 und 5.2). Jeder Vorfall trägt `serviceId` (`null` = kein Dienst). Gesetzt wird es auf zwei Wegen: - **Automatisch**, wenn die eingebaute Monitoring-Brücke einen Vorfall öffnet und dessen Monitor **genau einem** Dienst Ihrer Organisation gehört. Ein Monitor in zwei Diensten ist mehrdeutig und lässt `serviceId` leer; Alerts aus anderen Quellen (Webhooks, E-Mail, API) werden nie automatisch zugeordnet. - **Von Hand** mit [Dienst eines Vorfalls setzen](/de/api/incident-management/incident-service). `:id` nimmt die numerische `id` oder die `publicId`. ## Authentifizierung Lesen darf jede IM-berechtigte Rolle (`admin`, `editor`, `responder`) und jedes organisationsweite API-Token, siehe [Authentifizierung](/de/api/incident-management#authentifizierung). **Anlegen, Ändern und Löschen** verlangen die Rolle `admin` der Organisation; ein API-Token läuft mit der Rolle der Person, die es angelegt hat. Andere Rollen erhalten `403` `imServiceWriteDenied`. ## Das Dienst-Objekt | Feld | Typ | Beschreibung | |------|-----|--------------| | `id` | integer | Interne ID. | | `publicId` | string (UUID) | Öffentliche ID. | | `organizationId` | integer | Besitzende Organisation. | | `name` | string | 1 bis 200 Zeichen, je Organisation eindeutig ohne Rücksicht auf Groß/Klein. | | `description` | string \| null | Höchstens 2000 Zeichen. | | `criticality` | string | `critical`, `high`, `medium` oder `low`. | | `ownerTeamId` | integer \| null | Verantwortliches Team; wird `null`, wenn das Team gelöscht wird. | | `monitors` | object[] | `{ monitorType, monitorId, monitorName }`, nach Namen sortiert. Ein gelöschter Monitor erscheint nicht mehr. | | `createdAt` / `updatedAt` | string (ISO 8601) | | `monitorType` ist eines von `website` (auch Heartbeat- und Browser-Monitore), `dns`, `icmp`, `smtp`, `ssh`, `tcp`, `ftp`, `imap_pop`. Jede Art hat eigene IDs, ein Monitor ist deshalb immer das Paar `monitorType` + `monitorId`. ## Dienste auflisten `GET /api/im/services` | Parameter | Typ | Standard | Beschreibung | |-----------|-----|----------|--------------| | `page` | integer | `1` | Seitennummer. | | `perPage` | integer | `50` | Seitengröße, höchstens `200`. | ```bash curl "$BASE_URL/api/im/services" \ -H "Authorization: Bearer $TOKEN" ``` `200 OK`, nach Namen sortiert: ```json { "items": [ { "id": 4, "publicId": "0d7c6a0e-6f43-4d3b-9b1e-2a8f1d1c5e77", "organizationId": 1, "name": "Webshop", "description": "Shop und Kasse", "criticality": "critical", "ownerTeamId": 3, "monitors": [ { "monitorType": "website", "monitorId": 46, "monitorName": "shop.example.com" }, { "monitorType": "dns", "monitorId": 9, "monitorName": "example.com DNS" } ], "createdAt": "2026-10-25T08:00:00.000Z", "updatedAt": "2026-10-25T08:00:00.000Z" } ], "total": 1, "page": 1, "perPage": 50 } ``` ## Einen Dienst abrufen `GET /api/im/services/:id` liefert einen Dienst in derselben Form. ## Dienst anlegen `POST /api/im/services` | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `name` | string | Ja | 1 bis 200 Zeichen, je Organisation eindeutig ohne Rücksicht auf Groß/Klein (`409 imServiceNameTaken`). | | `description` | string \| null | Nein | Höchstens 2000 Zeichen. | | `criticality` | string | Nein | `critical`, `high`, `medium` (Standard) oder `low`. | | `ownerTeamId` | integer \| null | Nein | Ein Team Ihrer Organisation (`404 imTeamNotFound`). | | `monitors` | object[] | Nein | `{ monitorT…
### Einrichtungsstand und Test-Alarm
URL: https://docs.uptimeify.io/de/api/incident-management/setup
Description: Den Fortschritt der Incident-Management-Einrichtung lesen und speichern, und dir selbst über ein Team einen Test-Alarm schicken.
Summary: `GET /api/im/setup/state` · `PATCH /api/im/setup/state` · `POST /api/im/setup/test-page` Die Organisation hat ein frei gestaltbares Einrichtungsobjekt, damit sich eine Einrichtung (Team, Dienstplan, Alarmquelle, Test-Alarm) auf einem anderen Gerät oder von einem anderen Admin fortsetzen lässt. Diese Endpunkte lesen und schreiben dieses Objekt und schicken einen Test-Alarm, mit dem du prüfst, ob die Alarmierung dich erreicht. ## Authentifizierung Alle drei brauchen eine IM-berechtigte Rolle (`admin`, `editor`, `responder`) oder einen organisationsweiten API-Token. - Der **Einrichtungsstand** ist schon vor der [Aktivierung](/de/api/incident-management/activate) von Incident Management erreichbar. Schreiben erfordert die Rolle `admin` der Organisation. - Der **Test-Alarm** erfordert aktiviertes Incident Management und Schreibrechte am Team: die Rolle `admin` oder Team-Admin-Mitgliedschaft. Er alarmiert **dich**, braucht also eine Benutzersitzung; ein organisationsweiter API-Token erhält `403` (`imAccessDenied`). ## Einrichtungsstand lesen `GET /api/im/setup/state` ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/setup/state" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ### Antwort (Response) ```json { "organizationId": 42, "setupState": { "teamId": 7, "sourceCreated": true } } ``` `setupState` ist das zuletzt gespeicherte Objekt (die Schlüssel oben sind nur ein Beispiel). Solange nichts gespeichert wurde, ist es `{}`. ## Einrichtungsstand speichern `PATCH /api/im/setup/state` Ersetzt das gespeicherte Objekt vollständig. ### Request Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `setupState` | object | Ja | Ein einfaches JSON-Objekt, serialisiert höchstens 8 KB. | ### Beispiel (cURL) ```bash curl -X PATCH "$BASE_URL/api/im/setup/state" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"setupState":{"teamId":7,"sourceCreated":true}}' ``` ### Antwort (Response) Der gespeicherte Stand, in derselben Form wie beim GET. ## Test-Alarm senden `POST /api/im/setup/test-page` Legt im angegebenen Team einen Test-Incident an (`isTest: true`, Schweregrad `sev4`, Titel „Setup wizard test page“) und alarmiert dich auf jedem Kanal, der dich erreichen kann: - `email`, immer - `sms`, wenn in den [Benachrichtigungseinstellungen](/de/api/incident-management/notification-settings) eine bestätigte Telefonnummer hinterlegt ist - `voice`, zusätzlich wenn `includeVoice` `true` ist und die Telefonnummer bestätigt ist Test-Incidents zählt [Offene Incidents zählen](/de/api/incident-management/incident-count) nicht mit. Test-Alarme und [Test-Benachrichtigungen](/de/api/incident-management/notification-settings#test-benachrichtigung-senden) teilen sich eine Grenze von 5 pro Stunde und Person. ### Request Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `teamId` | number | Ja | Ein Team deiner Organisation. | | `includeVoice` | boolean | Nein | Zusätzlich anrufen. Standard `false`. | ### Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/setup/test-page" \ -H "Content-Type: application/json" \ -b "$SESSION_COOKIE" \ -d '{"teamId":7}' ``` ### Antwort (Response) ```json { "incidentId": 1834, "channels": ["email", "sms"], "enqueueErrors": [] } ``` `enqueueErrors` nennt die Kanäle, deren Alarm nicht in die Warteschlange kam. Leer bei Erfolg. ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `setupState` fehlt, kein Objekt oder größer als 8 KB ist, oder wenn `teamId` fehlt oder keine Ganzzahl ist, oder `includeVoice` kein Boolean - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei Verwendung eines kunden-gescopten Tokens - `403 Forbidden` (`imAccessDenied`) wenn keine IM-berechtigte Rolle vorliegt, oder wenn der Test-Alarm mit einem API-Token angefordert wird - `403 Forbidden` (`forbidden`) wenn jemand ohne Admin-Rolle den Einrichtungsstand schrei…
### Statusseiten-Regeln
URL: https://docs.uptimeify.io/de/api/incident-management/statuspage-rules
Description: Incident Management mit deinen Statusseiten koppeln: Regeln, die eine Seite bei Incidents eines Teams auf warning oder degraded setzen, plus eine manuelle Übersteuerung.
Summary: `GET /api/im/statuspage-rules` · `POST /api/im/statuspage-rules` · `GET /api/im/statuspage-rules/:id` · `PATCH /api/im/statuspage-rules/:id` · `DELETE /api/im/statuspage-rules/:id` · `GET /api/im/statuspage-rules/override` · `POST /api/im/statuspage-rules/override` · `DELETE /api/im/statuspage-rules/override/:statusPageId` Eine **Statusseiten-Regel** bedeutet: „Incidents von Team X mit Severity `minSeverity` oder schwerer setzen Statusseite Y auf `targetState`." `sev1` ist die schwerste Stufe. Als Text zeigt die Seite das Statusseiten-Update des Incidents; hat er keines, die `message` der Regel. Mit `autoResolve` wird der Zustand der Seite zurückgesetzt, sobald der Incident gelöst ist. Eine **manuelle Übersteuerung** setzt einen Zustand auf einer Statusseite von Hand. Solange eine manuelle Übersteuerung aktiv ist, ändern und löschen Regeln den Zustand dieser Seite nicht. ## Authentifizierung Erfordert den Basiszugriff auf Incident Management, den jeder Endpunkt dieser API braucht (eine IM-berechtigte Rolle `admin`, `editor` oder `responder`, oder ein organisationsweites API-Token; Incident Management muss für die Organisation aktiviert sein). Regeln auflisten und lesen darf jede IM-berechtigte Rolle. - **Regeln anlegen, ändern und löschen** erfordert die Schreibhürde: Deine Rolle muss `admin` sein, oder du musst Team-Admin des Teams der Regel sein. - **Eine manuelle Übersteuerung setzen oder aufheben** erfordert die Rolle `admin` oder `editor`, dieselbe Hürde wie andere Änderungen an Statusseiten. Ein organisationsweites API-Token läuft mit der Rolle der Person, die es erstellt hat. Eine Team-Admin-Mitgliedschaft gilt für ein Token nie. ## Regeln auflisten `GET /api/im/statuspage-rules` Liefert alle Regeln deiner Organisation, sortiert nach `id`. ### Query-Parameter | Parameter | Typ | Standard | Beschreibung | |-----------|------|---------|-------------| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/statuspage-rules?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ### Antwort (Response) `200 OK` ```json { "items": [ { "id": 2, "organizationId": 1, "teamId": 3, "statusPageId": 15, "minSeverity": "sev2", "targetState": "degraded", "autoResolve": true, "componentIds": [8], "message": "Wir untersuchen derzeit eine Störung.", "createdAt": "2026-09-25T09:00:00.000Z", "updatedAt": "2026-09-25T09:00:00.000Z" } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Regeln); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. ## Regel lesen `GET /api/im/statuspage-rules/:id` Liest eine Regel zurück, in derselben Form wie ein Eintrag von [Regeln auflisten](#regeln-auflisten). Jede IM-berechtigte Rolle darf ihn aufrufen. ### Beispiel (cURL) ```bash curl "$BASE_URL/api/im/statuspage-rules/4" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort `200 OK`, ein Regelobjekt wie in der Liste oben. `404` mit `imStatuspageRuleNotFound`, wenn die Regel nicht existiert oder zu einer anderen Organisation gehört. ## Regel anlegen `POST /api/im/statuspage-rules` ### Request Body | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|-------------| | `teamId` | integer | Ja | Team deiner Organisation, dessen Incidents die Regel auslösen. Du brauchst die Schreibhürde dafür. | | `statusPageId` | integer | Ja | Statusseite deiner Organisation. | | `minSeverity` | string | Nein | `sev1` bis `sev4`, Standard `sev2`. | | `targetState` | string | Nein | `warning` oder `degraded` (Standard). | | `autoResolve` | boolean | Nein | Zustand der Seite zurücksetzen, wenn der Incident gelöst ist. Standard `true`. Nimmt auch die Strings `"true"`/`"false"` an. | | `componentIds` | Array oder nul…
### Team-Bereitschaft und Statistik
URL: https://docs.uptimeify.io/de/api/incident-management/team-insights
Description: Lesen, wer in einem Team gerade Bereitschaft hat, den Bereitschaftskalender des Teams für ein Zeitfenster und die Incident-Statistik des Teams.
Summary: Lesende Ansichten auf ein Team: die aktuelle Bereitschaft je Stufe, der Bereitschaftskalender und die Incident-Statistik. Die organisationsweite Ansicht steht unter [Wer hat Bereitschaft](/de/api/incident-management/on-call). ## Authentifizierung Basis-IM-Zugriff: eine IM-berechtigte Rolle (`admin`, `editor` oder `responder`) oder ein organisationsweiter API-Token, und Incident Management für die Organisation aktiviert. Eine Team-Rolle ist nicht nötig. Ein Team einer anderen Organisation antwortet mit `404`. ## Bereitschaft jetzt `GET /api/im/teams/:id/on-call-now` Ein Eintrag je Eskalationsstufe, in Stufenreihenfolge, mit allen, die in dieser Stufe gerade Bereitschaft haben. Overrides sind bereits angewendet. Eine Stufe ohne Bereitschaft (kein Schedule oder eine Lücke) hat ein leeres `users`-Array. `uncoveredSince` (ISO 8601 oder `null`) ist der Zeitpunkt, an dem die letzte Abdeckung einer leeren Stufe endete, Overrides eingerechnet. `null` bei einer besetzten Stufe und bei einer, die in den letzten 14 Tagen nie besetzt war. Jeder Eintrag in `users` trägt `shiftEndsAt` und `shiftEndsAtIsLowerBound`: das Ende der ununterbrochenen Bereitschaft dieser Person in dieser Stufe, mit genau derselben Bedeutung und demselben Wert wie in [`GET /api/im/on-call`](/api/incident-management/on-call). `shiftEndsAtIsLowerBound` ist `true`, wenn die Bereitschaft nicht innerhalb der nächsten 90 Tage endet; `shiftEndsAt` heißt dann nur „mindestens bis“. ### Query-Parameter | Parameter | Typ | Standard | Beschreibung | |-----------|------|---------|-------------| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/teams/3/on-call-now?envelope=items" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort (Response) `200 OK` ```json { "items": [ { "tierId": 21, "tierOrder": 1, "users": [{ "userId": "u_abc123", "userName": "Ada Lovelace", "userImage": null, "shiftEndsAt": "2026-10-17T07:00:00.000Z", "shiftEndsAtIsLowerBound": false }], "uncoveredSince": null }, { "tierId": 22, "tierOrder": 2, "users": [], "uncoveredSince": "2026-10-10T06:00:00.000Z" } ], "total": 2, "page": 1, "perPage": 2 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Einträge); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. ## Kalender `GET /api/im/teams/:id/calendar` Bereitschaftszeiträume aller Stufen in einem Zeitfenster, als flache Liste sortiert nach Beginn. Overrides sind bereits angewendet, Team-Overrides ebenso wie Schedule-Overrides, die auf eine Eskalationsstufe beschränkt sind, nach denselben Regeln wie beim Alarmieren. ### Query-Parameter | Parameter | Typ | Erforderlich | Beschreibung | |-----------|------|----------|-------------| | `from` | string | Ja | ISO-8601-Zeitstempel, Beginn des Fensters (inklusive). | | `to` | string | Ja | ISO-8601-Zeitstempel, Ende des Fensters (exklusive). Muss nach `from` liegen. | | `tier` | integer | Nein | Eine Stufen-ID dieses Teams: nur die Zeiträume dieser Stufe. Eine ID, die keine Stufe des Teams ist, liefert eine leere Liste. | | `envelope` | string | Nein | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/teams/3/calendar?from=2026-10-01T00:00:00Z&to=2026-11-01T00:00:00Z&envelope=items" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort (Response) `200 OK` ```json { "items": [ { "scheduleId": 7, "tierOrder": 1, "userId": "u_abc123", "userName": "Ada Lovelace", "startsAt": "2026-09-28T07:00:00.000Z", "endsAt": "2026-10-05T07:00:00.000Z", "userImage": null }, { "scheduleId": null, "tierOrder": 1, "userId": "u_def456", "userName": "Bob Fixit", "startsAt": "2026-10-10T18:00:00.000Z", "endsAt": "2026-10-12T08:00:00.000Z", "userImage": null, "isTeamOverride"…
### Team-Mitglieder
URL: https://docs.uptimeify.io/de/api/incident-management/team-members
Description: Mitglieder eines Incident-Management-Teams hinzufügen, einladen, umstufen und entfernen.
Summary: Die Mitgliedschaft entscheidet, wer in die Rotationen und Overrides eines Teams aufgenommen werden kann, und wer **Team-Admin** (`imRole: "admin"`) mit Schreibrecht auf genau dieses Team ist. Die aktuellen Mitglieder liest du mit [Team lesen](/de/api/incident-management/teams#team-lesen). Mitgliederrollen (`imRole`): `admin`, `member` oder `stakeholder`. Standard ist `member`. Mitglied werden kann nur, wer Incident Management selbst nutzen dürfte: aktive User mit der Organisationsrolle `admin`, `editor` oder `responder`. ## Authentifizierung Basis-IM-Zugriff (eine IM-berechtigte Rolle oder ein organisationsweiter API-Token, Incident Management aktiviert) plus die Team-Schreibhürde: Organisationsrolle `admin`, oder Team-Admin dieses Teams. Ein API-Token läuft mit der Rolle des Users, der ihn erstellt hat, also kommt nur ein Token durch, den ein Organisations-Admin erstellt hat. Ein **neues** User-Konto über die Einladung anzulegen braucht zusätzlich die Organisationsrolle `admin`. ## Mitglied lesen `GET /api/im/teams/:id/members/:memberId` Liest eine Mitgliedschaft zurück, in derselben Form wie ein Eintrag von `members` in [Team lesen](/de/api/incident-management/teams#team-lesen) (gleiche Maskierung: `user.email` ist `null` und `user.phone` zeigt nur die letzten vier Ziffern, außer du bist Organisations-Admin). `user.phoneVerified` und `user.notificationRules` (Bereitschafts-Schalter je Dringlichkeit) sind dort ebenfalls erklärt. Jede IM-berechtigte Rolle darf ihn aufrufen. ### Beispiel (cURL) ```bash curl "$BASE_URL/api/im/teams/3/members/18" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort `200 OK` ```json { "id": 18, "userId": "u_def456", "imRole": "member", "user": { "name": "Bob Fixit", "email": "bob@example.com", "image": null, "phone": "+4915112345678", "activeChannels": ["email", "push"], "phoneVerified": false, "notificationRules": { "high": { "hasPushRule": true, "hasSmsRule": false, "hasVoiceRule": false, "hasEmailRule": true }, "low": { "hasPushRule": false, "hasSmsRule": false, "hasVoiceRule": false, "hasEmailRule": true } } } } ``` `404` mit `imTeamMemberNotFound`, wenn `:memberId` keine Mitgliedschaft dieses Teams ist. ## Mitglied hinzufügen `POST /api/im/teams/:id/members` Fügt einen bestehenden User deiner Organisation zum Team hinzu. ### Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|-------------| | `userId` | string | Ja | Der hinzuzufügende User. Muss zur Organisation des Teams gehören. | | `imRole` | string | Nein | `admin`, `member` oder `stakeholder`. Standard `member`. | ### Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/im/teams/3/members" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "userId": "u_def456", "imRole": "member" }' ``` ### Antwort (Response) `200 OK` ```json { "id": 18, "userId": "u_def456", "imRole": "member", "user": { "name": "Bob Fixit", "email": "bob@example.com" } } ``` `id` ist die Mitgliedschafts-ID, die die Endpunkte unten verwenden. `user.email` ist `null`, außer du bist Organisations-Admin. ## Mitglied per E-Mail einladen `POST /api/im/teams/:id/invite` Fügt ein Mitglied über die E-Mail-Adresse statt über die User-ID hinzu: - **Die E-Mail gehört zu einem User deiner Organisation:** Dieser User wird mit dem Team verknüpft. Sein Konto und seine Rolle bleiben unberührt, es geht keine E-Mail raus. - **Zur E-Mail gibt es kein Konto:** Ein neuer User mit der Organisationsrolle `responder` wird angelegt, mit dem Team verknüpft und bekommt eine Einladungs-E-Mail. Braucht die Organisationsrolle `admin`. - **Die E-Mail gehört zu einem Konto in einer anderen Organisation:** Abgelehnt mit `422`, es wird nichts angelegt. Die E-Mail wird ohne Beachtung der Groß-/Kleinschreibung abgeglichen und klein gespeichert. ### Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|-------------| | `email` | string | Ja | E-Mail-Adresse der Person, die du hinzufügst. | | `i…
### Team-Overrides
URL: https://docs.uptimeify.io/de/api/incident-management/team-overrides
Description: Die On-Call-Overrides eines Teams auflisten, hinzufügen, ändern und löschen, sowohl Team-Overrides als auch solche an einem Schedule des Teams.
Summary: Diese Endpunkte verwalten alle Overrides eines Teams an einer Stelle: - **Team-Overrides** (`scheduleId: null`) brauchen keinen Schedule. Sie gelten überall, wo die Bereitschaft des Teams aufgelöst wird (Alarmierung, [Bereitschaft jetzt](/de/api/incident-management/team-insights#bereitschaft-jetzt), Kalender), ein Team kann also allein über Overrides laufen. - **Schedule-Overrides** (`scheduleId` gesetzt) sind dieselben Overrides wie unter [Schedule-Overrides](/de/api/incident-management/schedule-overrides), nur über das Team angesprochen. Felder und Bedeutung (`type`, Vertretungen, Geltungsbereich, Stufe, Vorrang) stehen unter [Override-Felder](/de/api/incident-management/schedule-overrides#override-felder). Diese Seite ergänzt ein Feld: | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|-------------| | `scheduleId` | integer \| null | Nein | Ein Schedule dieses Teams, an den der Override gehängt wird. Weggelassen oder `null` = Team-Override. | Ein `offline`-Team-Override nimmt die Person nur heraus, solange sie in dieser Stufe tatsächlich eine Schicht hat. Hat sie dort keine Bereitschaft, bewirkt er nichts. Team-Overrides werden nach der Vereinigung der Schedules der Stufe eingerechnet, mit demselben 1:1-Ersatz wie Schedule-Overrides: Alle Vertretungen werden anstelle der vertretenen Person alarmiert. Sie wirken, sobald sie gespeichert sind, auch für den nächsten Alarm eines schon offenen Incidents. Die vollständige Reihenfolge steht unter [Wie Overrides aufgelöst werden](/de/api/incident-management/schedule-overrides#wie-overrides-aufgelöst-werden). ## Authentifizierung Basis-IM-Zugriff: eine IM-berechtigte Rolle oder ein organisationsweiter API-Token, und Incident Management für die Organisation aktiviert. Auflisten darf jeder mit diesem Zugriff. Hinzufügen, Ändern und Löschen brauchen die Team-Schreibhürde: Organisationsrolle `admin`, oder Team-Admin dieses Teams. Ein API-Token läuft mit der Rolle des Users, der ihn erstellt hat, also kommt nur ein Token durch, den ein Organisations-Admin erstellt hat. ## Overrides auflisten `GET /api/im/teams/:id/overrides` Liefert alle Overrides des Teams, Team-Overrides und Schedule-Overrides, sortiert nach `id`. ### Query-Parameter | Parameter | Typ | Standard | Beschreibung | |-----------|------|---------|-------------| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/teams/3/overrides?envelope=items" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort (Response) `200 OK`: dieselbe Eintragsform wie die Liste der Schedule-Overrides. ```json { "items": [ { "id": 31, "scheduleId": null, "userId": "u_def456", "userName": "Bob Fixit", "userImage": null, "type": "online", "applyScope": "this_team", "escalationTierOrder": 1, "startsAt": "2026-12-24T18:00:00.000Z", "endsAt": "2026-12-26T08:00:00.000Z", "createdAt": "2026-10-09T10:00:00.000Z", "coveredBy": [] } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Overrides); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Die Liste und das einzelne `GET` liefern `coveredBy` als Array von Objekten (`userId`, `userName`, `userImage`); Hinzufügen und Ändern liefern stattdessen `coveredByUserIds` (User-IDs als Strings). ## Override lesen `GET /api/im/teams/:id/overrides/:overrideId` Liest einen Override dieses Teams zurück (auf Teamebene oder an einen Schedule gebunden), in derselben Form wie ein Eintrag von [Overrides auflisten](#overrides-auflisten). Jede IM-berechtigte Rolle darf ihn aufrufen. ### Beispiel (cURL) ```bash curl "$BASE_URL/api/im/teams/3/overrides/31" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort `200 OK`, ein Override-Objekt wie in der Liste oben. `404` mit `imOverrideNotFound`…
### Eskalationsstufen
URL: https://docs.uptimeify.io/de/api/incident-management/team-tiers
Description: Die Eskalationskette eines Teams lesen, bearbeiten und testen: geordnete Stufen, ihre Einstellungen für automatische Eskalation und Wiederholung, die Schedules unter jeder Stufe und ein Probelauf, wer alarmiert würde.
Summary: Die Eskalationskette eines Teams ist eine geordnete Liste von **Stufen** (Tiers). Stufe 1 wird zuerst alarmiert; Bereitschaft in einer Stufe hat, wen die Schedules der Stufe gerade in Schicht haben. Jede Stufe legt fest, ob und wann der Incident zur nächsten Stufe weiterwandert und wie oft die Stufe vorher erneut alarmiert wird. Wiederholungen der ganzen Kette stehen am Team ([Team ändern](/de/api/incident-management/teams)). ## Authentifizierung Basis-IM-Zugriff: eine IM-berechtigte Rolle oder ein organisationsweiter API-Token, und Incident Management für die Organisation aktiviert. Die Kette lesen darf jeder mit diesem Zugriff. Jedes Schreiben braucht die Team-Schreibhürde: Organisationsrolle `admin`, oder Team-Admin dieses Teams. Ein API-Token läuft mit der Rolle des Users, der ihn erstellt hat, also kommt nur ein Token durch, den ein Organisations-Admin erstellt hat. ## Stufenfelder | Feld | Typ | Beschreibung | |-------|------|-------------| | `tierOrder` | integer | Position in der Kette, 1 = wird zuerst alarmiert. Änderbar nur über [Neu ordnen](#stufen-neu-ordnen). | | `autoEscalationEnabled` | boolean | Ob der Incident automatisch zur nächsten Stufe weiterwandert. Standard `true`. | | `autoEscalationAfterMinutes` | integer | Minuten bis zum Weiterwandern, `0` oder mehr. Standard `5`. | | `autoEscalationStopMode` | string | `acknowledged` oder `resolved`: der Incident-Zustand, der die Eskalation stoppt. Standard `acknowledged`. | | `autoEscalationSeverities` | array \| null | Schweregrade, die automatisch eskalieren: eine Teilmenge von `critical`, `warning`, `minor`. `null` = alle. | | `autoEscalationTimeFilters` | array | Wochenfenster, in denen die automatische Eskalation greifen darf, bis zu 50, jeweils `{ from: "HH:mm", until: "HH:mm", days: number[] }` mit ISO-Wochentagen (1 = Montag). `until` darf `"24:00"` sein. `[]` = immer. | | `repeats` | integer | Wie oft diese Stufe vor dem Weiterwandern noch einmal alarmiert wird, `0` oder mehr. Standard `0`. | | `repeatsAfterMinutes` | integer \| null | Minuten zwischen diesen Wiederholungen. `null` = `autoEscalationAfterMinutes` verwenden. | | `repeatsStopMode` | string | `acknowledged` oder `resolved`: der Incident-Zustand, der die Wiederholungen stoppt. Standard `acknowledged`. | ## Eskalationskette lesen `GET /api/im/teams/:id/escalations` Liefert alle Stufen in Reihenfolge, jede mit ihren Schedules, Rotationsgruppen und Mitgliedern, dazu die Eskalationseinstellungen des Teams. ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/teams/3/escalations" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort (Response) `200 OK` ```json { "tiers": [ { "id": 21, "tierOrder": 1, "autoEscalationEnabled": true, "autoEscalationAfterMinutes": 5, "autoEscalationStopMode": "acknowledged", "autoEscalationSeverities": null, "autoEscalationTimeFilters": [], "repeats": 0, "repeatsAfterMinutes": null, "repeatsStopMode": "acknowledged", "schedules": [ { "id": 7, "displayName": "Primary On-Call", "timezone": "Europe/Berlin", "effectiveFrom": null, "effectiveUntil": null, "weeklySchedules": [], "rotationMode": "explicit", "rotationRepeats": "weekly", "customRepeatUnit": null, "customRepeatValue": null, "autoRotationSize": null, "roundRobinSize": 1, "startsOnDayOfWeek": 1, "startsOnDateOfMonth": null, "startsOnTime": "09:00", "rotations": [ { "id": 12, "rotationOrder": 1, "members": [ { "userId": "u_abc123", "userName": "Ada Lovelace", "userImage": null, "memberOrder": 1 } ] } ] } ] } ], "teamSettings": { "timezone": "Europe/Berlin", "escalationRepeats": 1, "escalationRepeatsAfterMinutes": 15, "escalationRepeatsStopMode": "acknowledged", "engagementReportEnabled": false, "engagementReportDayOfWeek": null, "engagementReportTime": null } } ``` Die Schedule-Felder sind unter [Rotationskadenz](/de/api/incident-management/schedules#rotationskadenz) und [Schedule aktualisieren](/de/api/incident-management/update-schedule) erklärt. ## Stufe lesen `GET /api/im/teams/:id/tiers/:tierId` Liest eine…
### Teams
URL: https://docs.uptimeify.io/de/api/incident-management/teams
Description: Incident-Management-Teams auflisten, lesen, anlegen, ändern und löschen, einschließlich der Team-Einstellungen für Eskalation und Engagement-Report.
Summary: Ein **Team** ist die oberste Besitz-Einheit in Incident Management: Eskalationsstufen, Schedules, Overrides und Incidents gehören jeweils zu genau einem Team. Diese Seite behandelt das Team selbst. Mitglieder stehen unter [Team-Mitglieder](/de/api/incident-management/team-members), die Eskalationskette unter [Eskalationsstufen](/de/api/incident-management/team-tiers). ## Authentifizierung Jeder Endpunkt braucht den Basis-IM-Zugriff: eine IM-berechtigte Rolle (`admin`, `editor` oder `responder`) oder einen organisationsweiten API-Token, und Incident Management muss für die Organisation aktiviert sein. Lesen darf jeder mit diesem Zugriff. Schreiben braucht mehr: - **Anlegen** braucht die Organisationsrolle `admin`. - **Ändern** und **Löschen** brauchen die Team-Schreibhürde: Organisationsrolle `admin`, oder Team-Admin (`imRole: "admin"`) dieses Teams. Ein API-Token läuft mit der Rolle des Users, der ihn erstellt hat. Nur ein Token, den ein Organisations-Admin erstellt hat, nimmt eine der beiden Schreibhürden. Teams einer anderen Organisation antworten immer mit `404`, nie mit `403`. ## Teams auflisten `GET /api/im/teams` Liefert jedes Team deiner Organisation, sortiert nach Name, mit Mitgliederzahl und einer kurzen Mitgliederliste. ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/teams" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort (Response) `200 OK` ```json [ { "id": 3, "name": "Platform Team", "labelColor": "#4f46e5", "analyticsEnabled": true, "createdAt": "2026-06-02T08:00:00.000Z", "memberCount": 2, "members": [ { "userId": "u_abc123", "name": "Ada Lovelace", "email": "ada@example.com", "src": null }, { "userId": "u_def456", "name": "Bob Fixit", "email": "bob@example.com", "src": "https://uptimeify.io/avatars/u_def456.png" } ] } ] ``` `members[].email` ist nur für Organisations-Admins gefüllt (und für Tokens, die einer von ihnen erstellt hat). Alle anderen bekommen `null`, und ein Mitglied ohne Anzeigenamen hat dann einen leeren `name`. `src` ist die Avatar-URL des Mitglieds oder `null`. ## Team lesen `GET /api/im/teams/:id` Liefert das Team, seine Einstellungen und seine Mitglieder samt Benachrichtigungsbereitschaft. ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/teams/3" \ -H "Authorization: Bearer $TOKEN" ``` ### Antwort (Response) `200 OK` ```json { "id": 3, "name": "Platform Team", "labelColor": "#4f46e5", "analyticsEnabled": true, "organizationId": 1, "createdAt": "2026-06-02T08:00:00.000Z", "updatedAt": "2026-09-14T10:12:00.000Z", "timezone": "Europe/Berlin", "escalationRepeats": 1, "escalationRepeatsAfterMinutes": 15, "escalationRepeatsStopMode": "acknowledged", "engagementReportEnabled": true, "engagementReportDayOfWeek": 1, "engagementReportTime": "09:00", "members": [ { "id": 17, "userId": "u_abc123", "imRole": "admin", "user": { "name": "Ada Lovelace", "email": "ada@example.com", "image": null, "phone": "+4915112345678", "activeChannels": ["email", "push", "sms"], "phoneVerified": true, "notificationRules": { "high": { "hasPushRule": true, "hasSmsRule": true, "hasVoiceRule": false, "hasEmailRule": true }, "low": { "hasPushRule": true, "hasSmsRule": false, "hasVoiceRule": false, "hasEmailRule": true } } } } ] } ``` - `members[].id` ist die Mitgliedschafts-ID, die [Team-Mitglieder](/de/api/incident-management/team-members) in seinen Pfaden verwendet, nicht die User-ID. - `user.email` folgt derselben Regel wie in der Liste. `user.phone` ist die verifizierte Telefonnummer, vollständig für Organisations-Admins, sonst auf die letzten vier Ziffern gekürzt (`***5678`). - `user.activeChannels` listet die Benachrichtigungskanäle, die das Mitglied eingeschaltet hat. - `user.phoneVerified` ist `true`, wenn das Mitglied eine bestätigte Telefonnummer hat, SMS und Anruf es also erreichen. - `user.notificationRules` zeigt, welche Kanäle die eigene Regelkette des Mitglieds nutzt: `high` für `sev1`/`sev2`, `low` für `sev3`/`sev4`, jeweils mit `hasPushRule`, `hasSmsRule`, `hasVoiceRule` und `hasEmailRule`…
### Schedule aktualisieren
URL: https://docs.uptimeify.io/de/api/incident-management/update-schedule
Description: Name, Zeitzone, Gültigkeitszeitraum, Wochenfenster, Rotationskadenz und Rotationsmitglieder eines Bereitschaftsplans ändern, in einem atomaren Aufruf.
Summary: `PATCH /api/im/schedules/:id` Hier wird die Rotation eines Schedules tatsächlich konfiguriert. [Das Anlegen eines Schedules](/de/api/incident-management/schedules) liefert eine leere Hülle (`rotationMode: "none"`, keine Mitglieder); dieser Endpunkt setzt Kadenz, Wochenfenster und die Rotationsbesetzung. Jedes Feld ist **optional**. Nur die im Body vorhandenen Felder werden angefasst, ein Body `{ "name": "Primär" }` benennt den Schedule um und ändert sonst nichts. ## Authentifizierung Erfordert den Basis-IM-Zugriff (eine IM-berechtigte Rolle oder ein organisationsweiter API-Token, Incident Management für die Organisation aktiviert) plus die Team-Schreibhürde: Deine Rolle muss `admin` sein, oder du musst Team-Admin des Teams sein, zu dem der Schedule gehört. Ein API-Token läuft mit der Rolle des Users, der ihn erstellt hat, also kommt nur ein Token durch, den ein Organisations-Admin erstellt hat. Kunden-Logins (`readonly`), an einen Kunden gebundene Editoren und kunden-gescopte Tokens erhalten `403 imAccessDenied`. ## Request-Body | Feld | Typ | Beschreibung | |-------|------|-------------| | `name` | string | Name des Schedules, bis zu 120 Zeichen. | | `timezone` | string | IANA-Zeitzone (z. B. `Europe/Berlin`). Jede Übergabegrenze und jedes Wochenfenster wird in dieser Zone ausgewertet, auch über die Sommerzeit hinweg. | | `effectiveFrom` | string \| null | ISO-Zeitstempel. Vorher alarmiert der Schedule niemanden. `null` = keine Startgrenze. | | `effectiveUntil` | string \| null | ISO-Zeitstempel. Danach alarmiert der Schedule niemanden. `null` = keine Endgrenze. | | `weeklySchedules` | array | Wiederkehrende Bereitschaftsfenster, bis zu 50. Jeweils: `{ from: "HH:mm", until: "HH:mm", days: number[] }`, `days` als ISO-Wochentage (1 = Montag .. 7 = Sonntag). `until` darf `"24:00"` für Tagesende sein; ein `until` gleich oder vor `from` reicht über Mitternacht hinaus. Ein leeres Array bedeutet 24/7. | | `rotations` | array | **Vollständiger Ersatz** der Rotationsgruppen, bis zu 50. Jeweils: `{ members: string[] }`, bis zu 200 Mitglieder. Die Array-Reihenfolge ist die Rotationsreihenfolge, die Reihenfolge innerhalb einer Gruppe bleibt erhalten. Jedes Mitglied muss bereits im Team des Schedules sein. Feld weglassen lässt die Rotationen unberührt, ein `[]` entfernt alle. | Dazu die Kadenzfelder, `rotationMode`, `rotationRepeats`, `customRepeatUnit`, `customRepeatValue`, `autoRotationSize`, `roundRobinSize`, `startsOnTime`, `startsOnDayOfWeek`, `startsOnDateOfMonth`. Sie sind mitsamt ihren erlaubten Werten einmal unter [Rotationskadenz](/de/api/incident-management/schedules#rotationskadenz) dokumentiert. `teamId` und `tierId` sind **nicht** patchbar. Einen Schedule zwischen Teams oder Stufen zu verschieben würde stillschweigend umlenken, wen er alarmiert, das ist keine Teilaktualisierung. ### Wie die Kadenz validiert wird Kadenzfelder werden auf die aktuelle Zeile des Schedules gemergt und dann **als Ganzes** validiert, nicht Feld für Feld. Genau das erlaubt es, ein einzelnes Feld zu patchen, etwa `roundRobinSize`, ohne die restliche Kadenz erneut zu senden, und trotzdem eine unmögliche Kombination abzulehnen (zum Beispiel `rotationRepeats: "weekly"` ohne ein `startsOnDayOfWeek` irgendwo in der effektiven Konfiguration). Die Validierung läuft, bevor irgendetwas geschrieben wird. Eine Kadenz, an der sich der Materializer verschlucken würde, erreicht die Datenbank nie. ### Wann Schichten neu berechnet werden Änderungen an Zeitzone, Gültigkeitszeitraum, Wochenfenstern, einem Kadenzfeld oder den Rotationen lösen eine Neuberechnung der Schichten aus. Eine reine Umbenennung nicht, sie würde die Sperre des Schedules ziehen und Zeilen ohne Grund neu schreiben. ## Beispiel (cURL) ```bash curl -X PATCH "$BASE_URL/api/im/schedules/7" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "rotationMode": "explicit", "rotationRepeats": "custom", "customRepeatUnit": "minutes", "customRepeatValue": 30, "startsOnTime": "09:…
### Benachrichtigungen einer Person
URL: https://docs.uptimeify.io/de/api/incident-management/user-notification-settings
Description: Organisations-Admins lesen und setzen die Benachrichtigungseinstellungen einer Person: Telefonnummer, Kanäle und die ganze Benachrichtigungskette.
Summary: `GET /api/im/users/:userId/notification-settings` · `PUT /api/im/users/:userId/notification-settings` Ein Organisations-Admin richtet ein, wie eine Person alarmiert wird, zum Beispiel beim Einarbeiten einer neuen Bereitschaft, damit die Person das nicht selbst tun muss. Es sind dieselben Einstellungen, die die Person unter [Persönliche Benachrichtigungen](/de/api/incident-management/notification-settings) sieht und ändert. **Es gilt der letzte Schreibzugriff**: Die Person kann danach alles ändern, und ein Admin kann es jederzeit wieder setzen. Die Person sieht auf ihrer Benachrichtigungsseite den Hinweis „Von (Admin) geändert am (Datum)“. `sms`- und `voice`-Schritte werden auch gespeichert, solange die Telefonnummer nicht bestätigt ist. Sie warten: Jede Alarmierung bis dahin steht im Protokoll als übersprungen (Grund `unverified`), und die Person wird bei der nächsten Anmeldung gebeten, die Nummer zu bestätigen. An eine Nummer, die niemand bestätigt hat, geht nichts. ## Authentifizierung Erfordert die Rolle `admin` der Organisation, mit Sitzung oder organisationsweitem API-Token (der Token arbeitet mit der Rolle der Person, die ihn erstellt hat). Kundengebundene Tokens und Kunden-Logins werden abgewiesen. Incident Management muss für die Organisation aktiviert sein. Die Zielperson muss zu deiner Organisation gehören, aktiv sein und eine IM-fähige Rolle haben (`admin`, `editor` oder `responder`). ## Einstellungen einer Person lesen `GET /api/im/users/:userId/notification-settings` Legt die Einstellungen beim ersten Zugriff an, ausgehend von der [Standard-Benachrichtigung](/de/api/incident-management/notification-template), genau wie wenn die Person sie öffnet. ### Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/im/users/usr_8f2c/notification-settings" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ### Antwort (Response) ```json { "userId": "usr_8f2c", "id": 31, "phoneNumber": "+491701234567", "phoneVerified": false, "channels": { "push": true, "sms": true, "voice": false, "email": true }, "severityChannels": {}, "rules": [ { "id": 201, "urgency": "high", "delayMinutes": 0, "channel": "push" }, { "id": 202, "urgency": "high", "delayMinutes": 5, "channel": "sms" }, { "id": 203, "urgency": "low", "delayMinutes": 0, "channel": "email" } ], "lastAdminChangeAt": "2026-10-28T09:12:00.000Z", "lastAdminChangeBy": { "id": "usr_admin", "name": "Ada Admin" } } ``` `phoneVerified: false` mit `sms`/`voice`-Regeln heißt: Diese Schritte warten, bis die Person die Nummer bestätigt. Der Schweregrad-Filter (`severityChannels`) wird angezeigt, aber hier nicht gesetzt; er bleibt die Entscheidung der Person. ## Einstellungen einer Person setzen `PUT /api/im/users/:userId/notification-settings` Ersetzt die **ganze** Benachrichtigungskette der Person durch `rules`. Regeln, die nicht in der Liste stehen, werden gelöscht. Eine Anfrage, die nichts ändert, schreibt nichts und setzt `lastAdminChangeAt` nicht neu. ### Request Body | Feld | Typ | Pflicht | Beschreibung | |-------|------|----------|-------------| | `rules` | array | Ja | Die ganze Kette, höchstens 64 Schritte. Jeder Schritt `{ "urgency": "high" oder "low", "delayMinutes": 0..1440, "channel": "push", "sms", "voice" oder "email" }`. Jede Kombination aus Dringlichkeit, Verzögerung und Kanal höchstens einmal. Eine leere Liste entfernt alle Regeln. | | `channels` | object | Nein | Die vier Kanalschalter (`push`, `sms`, `voice`, `email` → boolean). Fehlt das Feld, ist ein Kanal genau dann an, wenn `rules` einen Schritt dafür hat. Andere Schalter der Person (Schicht-Erinnerungen) bleiben erhalten. | | `phoneNumber` | string oder null | Nein | E.164-Nummer, z. B. `+491701234567`. Fehlt das Feld: unverändert. `null` entfernt sie. Eine andere Nummer ist unbestätigt, bis die Person sie bestätigt; ein offener Bestätigungscode verfällt. | Unbekannte Felder werden abgewiesen. ### Beispiel (cURL) ```bash curl -X PUT "$BASE_URL/api/im/users/usr_8f2c/notification-settings" \ -H "Au…
### Einführung
URL: https://docs.uptimeify.io/de/api/introduction
Description: Willkommen in der Uptimeify API-Dokumentation. Mit dieser REST API kannst du deine Monitoring-Infrastruktur programmatisch verwalten: z. B. Organisationen, Kunden, Websites und Alerts.
Summary: ## Basis-URL Alle API-Anfragen sollten an die folgende Basis-URL gesendet werden: ``` https://uptimeify.io/api ``` ## Authentifizierung Die API unterstützt **Bearer-Token** Authentifizierung für Integrationen. ### API-Token erstellen 1. Logge dich im Uptimeify-Dashboard ein. 2. Öffne im Dashboard **Einstellungen** > **API**. 3. Klicke auf **Token erstellen**, gib einen Namen an und kopiere das erzeugte Secret. Füge das Token im `Authorization`-Header deiner Anfragen hinzu: ```http Authorization: Bearer ``` Das Token ist eine einzige Zeile: kopiere es ohne Leerzeichen oder Zeilenumbruch. Beim Schema ist die Schreibweise egal (`Bearer` oder `bearer`), Leerzeichen um das Token herum werden ignoriert, ein Token mit Leerzeichen darin lehnen wir aber mit `401 Unauthorized` ab. ### Token Scopes (Organization vs Customer) API-Tokens können optional mit einem **Customer Scope** erstellt werden: - **Organisation-weites Token**: kann Ressourcen über alle Kunden der Organisation hinweg lesen/ändern. - **Customer-Scoped Token**: kann nur Ressourcen (Websites, Wartungsfenster usw.) innerhalb dieses einen Kunden lesen/ändern. Customer-Scoped Tokens sind für Agenturen und externe Integrationen empfehlenswert. Requests außerhalb des Scopes liefern `403 Forbidden`. > **Hinweis:** Session-basierte Authentifizierung (Cookies) wird für die Web-Oberfläche verwendet, ist für Integrationen aber nicht empfohlen. ## Antwortformat Alle Antworten werden im JSON-Format zurückgegeben. ### Erfolgsantwort ```json { "id": 123, "name": "Beispiel-Ressource", "createdAt": "2023-01-01T12:00:00Z" } ``` ### Fehlerantwort Fehler werden mit einem passenden HTTP-Statuscode und einem JSON-Body mit Details zurückgegeben. ```json { "statusCode": 400, "statusMessage": "Bad Request", "message": "Validierung fehlgeschlagen: 'url' ist erforderlich." } ``` ## Rate Limiting Damit der Service stabil bleibt, ist die API rate-limitiert. - **Limit**: 600 Requests pro Minute pro IP - **Header**: `X-RateLimit-Remaining` zeigt dein verbleibendes Kontingent - **Überschreitung**: `429 Too Many Requests` ## Endpunkte - [API-Token erstellen](/de/api/introduction/generate-api-token) - [Token-Scopes (Organisation vs. Kunde)](/de/api/introduction/token-scopes-organization-vs-customer) - [Erfolgsantwort](/de/api/introduction/success-response) - [Fehlerantwort](/de/api/introduction/error-response)
### Fehlerantwort
URL: https://docs.uptimeify.io/de/api/introduction/error-response
Description: Fehler werden mit einem passenden HTTP-Statuscode und einem JSON-Body mit Details zurückgegeben.
Summary: ```json { "statusCode": 400, "statusMessage": "Invalid request body", "data": { "code": "invalidRequestBody", "issues": [{ "path": "url", "message": "Invalid input: expected string, received undefined" }], "requestId": "3f2b6c1e-8a4d-4f0e-9b7a-2c5d1e6f7a8b" } } ``` - `data.code` benennt den Fehler. Verzweige darauf, nie auf den Text; die Codes stehen in der Fehlerliste. - `data.issues` (nur bei `invalidRequestBody`) nennt jedes abgewiesene Feld mit `path` (mit Punkt verbunden) und `message`. - `data.requestId` kennzeichnet genau diesen Aufruf. Nenne sie, wenn du den Support kontaktierst. - `statusMessage` ist englisch und sagt, was zu ändern ist: welche Rolle, welches Token oder welcher Scope fehlt, oder welches Feld falsch ist. Der Text kann sich ändern; werte ihn nie aus. - `data.requiredScope` (nur bei `apiTokenScopeForbidden`) nennt den Scope, der dem Token fehlt; `data.reason` (nur bei `agentTokenReadOnly`) sagt, welche Regel für Agent-Tokens den Aufruf abgewiesen hat. - Welche Rolle und welches Token ein Endpunkt braucht: [Berechtigungen je Endpunkt](/api/introduction/permissions-by-endpoint). ## Request-ID Jede API-Antwort trägt den Header `X-Request-ID`. Schickst du selbst eine `X-Request-ID` mit (1 bis 128 Zeichen aus `A-Z`, `a-z`, `0-9`, `.`, `_`, `:`, `-`), etwa die Nummer deines CI-Laufs, gibt die API sie zurück und nutzt sie in `data.requestId`; sonst erzeugt sie eine UUID. Ein Wert außerhalb dieses Formats wird ersetzt, nicht abgewiesen. # Rate Limiting Damit der Service stabil bleibt, ist die API rate-limitiert. - **Limit**: 600 Requests pro Minute pro IP - **Header**: `X-RateLimit-Remaining` zeigt dein verbleibendes Kontingent - **Überschreitung**: `429 Too Many Requests`
### API-Token erstellen
URL: https://docs.uptimeify.io/de/api/introduction/generate-api-token
Description: Schritt-für-Schritt-Anleitung zum Erstellen eines Uptimeify API-Tokens über Einstellungen > API.
Summary: 1. Logge dich im Uptimeify-Dashboard ein. 2. Öffne im Dashboard **Einstellungen** > **API**. 3. Klicke auf **Token erstellen**, gib einen Namen an und kopiere das erzeugte Secret. Füge das Token im `Authorization`-Header deiner Anfragen hinzu: ```http Authorization: Bearer ``` Das Token ist eine einzige Zeile: kopiere es ohne Leerzeichen oder Zeilenumbruch. Beim Schema ist die Schreibweise egal (`Bearer` oder `bearer`), Leerzeichen um das Token herum werden ignoriert, ein Token mit Leerzeichen darin lehnen wir aber mit `401 Unauthorized` ab.
### Berechtigungen je Endpunkt
URL: https://docs.uptimeify.io/de/api/introduction/permissions-by-endpoint
Description: Welche Rolle, welche Token-Art und welchen Token-Scope jeder Endpunkt braucht, und mit welchem Fehlercode ein abgewiesener Aufruf antwortet.
Summary: Jeder Aufruf wird in dieser Reihenfolge geprüft. Die erste Prüfung, die scheitert, bestimmt die Antwort: 1. **Anmeldung.** Kein Token, oder ein widerrufenes, abgelaufenes oder vertipptes: `401 unauthorized`. 2. **Token-Art.** Ein kundengebundenes Token auf einem organisationsweiten Pfad: `403 customerScopedTokenForbidden`. Ein Token mit Scopes, dem der Scope des Pfads fehlt: `403 apiTokenScopeForbidden`. Meldung und `data.requiredScope` nennen den fehlenden Scope, zum Beispiel `api.write.monitors`. Siehe [Token-Scopes](/api/introduction/token-scopes-organization-vs-customer). 3. **Rolle.** Ein Organisations-Token (`wsm_…`) handelt mit der **aktuellen** Rolle des Nutzers, der es angelegt hat. Ist dieser Nutzer deaktiviert oder gelöscht, handelt das Token als `readonly`. Alte Tokens ohne hinterlegten Aussteller handeln als `admin`. Eine nicht zugelassene Rolle bekommt `403` mit dem Code aus der Tabelle unten. 4. **Kundenbereich.** `readonly`-Nutzer, Editoren mit Kundenzuordnung und kundengebundene Tokens erreichen nur ihre eigenen Kunden. Eine einzelne Ressource außerhalb dieses Bereichs antwortet mit `404` und dem Nicht-gefunden-Code der Ressource, nie mit `403`. Ein API-Token, ob organisationsweit oder kundengebunden, folgt der **aktuellen** Rolle und Kundenzuordnung des Nutzers, der es angelegt hat: Ist dieser Nutzer Kunden zugeordnet, erreicht das Token nur diese Kunden (ein kundengebundenes Token erreicht seinen Kunden nur, solange der Nutzer ihn noch hat). Ist der Nutzer deaktiviert oder gelöscht, erreicht das Token keinen Kunden mehr. 5. **Modul.** Statusseiten brauchen das Statusseiten-Modul (`403 statusPagesModuleDisabled`). Incident Management muss für die Organisation aktiviert sein (`403 imNotEnabled`). Jeder abgewiesene Aufruf trägt einen stabilen `data.code` und eine englische `statusMessage`, die sagt, was fehlt. Verzweige auf den Code; der Text kann sich ändern. Rollen: `admin` und `editor` sind Organisationsrollen, `readonly` ist die Self-Service-Rolle des Kunden, `responder` gibt es nur für Incident Management. Global Supporter ändern nie Kundendaten (`403 forbidden`). Agent-Tokens (`wsma_…`, verbundene Apps) erreichen nur die Pfade, die ihre Scopes erlauben; jeder andere Pfad antwortet mit `403 agentTokenReadOnly` und `data.reason`. ## Monitore | Methode | Pfad | Wer darf aufrufen | Scope | Abweisung mit | |---|---|---|---|---| | `GET` | `/api/websites/:id`, `/api/-monitors/:id` | Jede Rolle innerhalb ihres Kundenbereichs | `api.read.monitors` | `404 websiteNotFound` / `monitorNotFound` | | `POST` | `/api/websites`, `/api/-monitors` | `admin`, `editor`. `readonly` und kundengebundene Tokens legen `self_service`-Monitore für den eigenen Kunden an, wenn das Paket Self-Service erlaubt. Nur `admin` darf `managementType` setzen. | `api.write.monitors` | `forbidden`, `selfServiceNotAllowed`, `selfServiceQuotaReached`, Kontingent-Codes | | `PATCH` | `/api/websites/:id`, `/api/-monitors/:id` | `admin`, `editor`. Kundengebundene Aufrufer ändern `self_service`-Monitore, `managed` nur mit `canEditManaged`. `managementType` ändern braucht einen organisationsweiten `admin`. | `api.write.monitors` | `forbidden`, `managed_by_organization`, `managementTypeOrgOnly` | | `DELETE` | `/api/websites/:id`, `/api/-monitors/:id` | Wie `PATCH`, aber nie `readonly` (auch kein Token, das dieser Nutzer angelegt hat) | `api.write.monitors` | `readonlyMayNotDelete`, `managed_by_organization` | | `POST` | `/api/websites/:id/heartbeat-token/rotate` | Wie `PATCH` | `api.write.monitors` | wie `PATCH` | | `GET`, `POST`, `DELETE` | `/api/monitor-tags` | Jede Rolle innerhalb ihres Kundenbereichs | `api.read.monitors` / `api.write.monitors` | `forbidden`, `badRequest` | | `GET` | `/api/tags`, `/api/tags/:id` | Jede Rolle der Organisation | `api.read.monitors` | `404 tagNotFound` | | `POST`, `PATCH`, `DELETE` | `/api/tags`, `/api/tags/:id` | Jede Rolle; kundengebundene Aufrufer legen nur Tags ihrer Kunden an und ändern nur di…
### Erfolgsantwort
URL: https://docs.uptimeify.io/de/api/introduction/success-response
Description: Bei Erfolg liefert die API einen JSON-Body mit den angefragten Daten.
Summary: ```json { "id": 123, "name": "Example Resource", "createdAt": "2023-01-01T12:00:00Z" } ```
### Token-Scopes (Organisation vs. Kunde)
URL: https://docs.uptimeify.io/de/api/introduction/token-scopes-organization-vs-customer
Description: API-Tokens können optional mit einem Customer Scope erstellt werden:
Summary: - **Organisation-weites Token**: kann Ressourcen über alle Kunden der Organisation hinweg lesen/ändern. - **Customer-Scoped Token**: kann nur Ressourcen (Websites, Wartungsfenster usw.) innerhalb dieses einen Kunden lesen/ändern. Customer-Scoped Tokens sind für Agenturen und externe Integrationen empfehlenswert. Requests außerhalb des Scopes liefern `403 Forbidden`. Ein Customer-Scoped Token erreicht organisationsweite Pfade nie, unabhängig von der HTTP-Methode: Organisationseinstellungen und Abrechnung (`/api/organizations/**`, `/api/organization/**` außer `GET /api/organization`), Nutzer, Admin- und Plattform-Admin-Routen, Eskalationskonfiguration, Sonderpreise und eigene Felder, Incident Management, Anlegen und Löschen von Kunden. Solche Aufrufe antworten mit `403` und `data.code: customerScopedTokenForbidden`. Das Lesen von `/api/organization` und `/api/package-configs` bleibt möglich. Kein API-Token kann ein weiteres Token erzeugen. ## Rollen und der Kunden-Scope Jeder Request bringt zwei Dinge mit: eine **Rolle** (welche Art von Schreibzugriffen der Akteur ausführen darf) und einen **Kunden-Scope** (welche Kunden der Akteur sieht). Den Scope bestimmt die Kundenbindung des Tokens, bei einer Benutzer-Session die Kundenzuweisungen dieses Benutzers. Ein Aufruf braucht beides. | Rolle | Wer | Scope | |---|---|---| | `admin` | Administrator der Organisation | Immer organisationsweit. | | `editor` | Teammitglied der Organisation | Organisationsweit, sofern der Benutzer keinen Kunden zugewiesen ist; sonst auf diese Kunden beschränkt. | | `readonly` | **Self-Service-Benutzer eines Kunden** | Immer auf die zugewiesenen Kunden beschränkt. | `readonly` ist die Self-Service-Rolle, mit der ein Kunde arbeitet. Innerhalb des eigenen Kunden-Scopes darf sie **lesen und schreiben**: Monitore, Wartungsfenster für ihren Kunden, Benachrichtigungskanäle ihres Kunden und so weiter. Was sie nie kann: **organisationsweite Ressourcen** anfassen, also organisationsweite (Nur-Tag-)Wartungsfenster, Organisationseinstellungen und Abrechnung, Benutzer, das Anlegen von Kunden. `editor` und `admin` sind die Organisationsrollen; ein `editor` mit Kundenzuweisungen wird auf diesen organisationsweiten Ressourcen genau wie ein kundengebundener Akteur behandelt. Konkret erhält ein Akteur mit eingeschränktem Scope (ein Customer-Scoped Token, ein `readonly`-Benutzer, ein `editor` mit Kundenzuweisungen) `403` mit `data.code: customerScopedTokenForbidden` bei: - Anlegen eines Kunden (`POST /api/customers`) - Bearbeiten oder Löschen eines **organisationsweiten** Wartungsfensters (`PATCH`/`DELETE /api/maintenance-windows/:id` auf ein Fenster ohne Kunden) - Organisationseinstellungen, Abrechnung, Benutzer und den übrigen oben genannten Pfaden und ein Nur-Tag-Wartungsfenster, das er anlegt, wird an seinen einen Kunden gebunden statt organisationsweit zu werden (siehe [Wartungsfenster erstellen](/de/api/maintenance-windows/create)). ## Eine Ressource außerhalb deines Scopes ist ein `404` `403` steht für **das, was du darfst**: eine Rolle, die nicht schreiben darf, ein Customer-Scoped Token auf einem Organisationspfad, ein verwalteter Monitor. Eine **konkrete Ressource**, die existiert, aber einem anderen Kunden oder einer anderen Organisation gehört, ist für dich nicht von einer unterscheidbar, die es nicht gibt: Die API antwortet `404` mit demselben `data.code` wie bei einer unbekannten ID (`websiteNotFound`, `monitorNotFound`, `customerNotFound`, `statusPageNotFound`, …). Lies ein `404` nicht als Beleg, dass eine ID frei ist, und erwarte kein `403` als Hinweis, dass etwas existiert. ## Berechtigungs-Scopes (geringste Rechte) Unabhängig von der Kundenbindung lässt sich ein Token beim Anlegen auf **Scopes** beschränken (`scopes` bei [Organisations-Token erstellen](/de/api/api-tokens/create-organization-token) und [Kunden-Token erstellen](/de/api/api-tokens/create-customer-token)). Ein Token ohne Scopes (`scopes: null`, jedes vor dem 24.10.2026 angelegte Token und jedes…
### Maintenance Windows
URL: https://docs.uptimeify.io/de/api/maintenance-windows
Description: Erstelle und verwalte Wartungsfenster, um Alarme bei geplanten Arbeiten zu unterdrücken. Fenster können einen einzelnen Monitor, mehrere Monitore, einen gesamten Kunden oder alle Monitore mit einem bestimmten Tag abdecken.
Summary: Wartungsfenster unterdrücken Alarme für die betroffenen Monitore während eines geplanten Zeitraums. Während ein Fenster aktiv ist, gilt der betroffene Monitor als **in Wartung**: es werden keine Alarme ausgelöst und, wenn der Kunde eine Statusseite hat, wird der Service als **Wartung** statt **Beeinträchtigt** angezeigt. ## Zieloptionen Ein Fenster kann Monitore auf vier Arten abdecken (gegenseitig ausschließend, außer dass `targets` und `tagIds` kombiniert werden können): | Modus | Angabe | |-------|--------| | **Einzelner Monitor (Legacy)** | Eines der Legacy-ID-Felder: `websiteId`, `icmpMonitorId`, `smtpMonitorId`, `sshMonitorId`, `tcpMonitorId`, `ftpMonitorId`, `imapPopMonitorId`, `dnsMonitorId`, `customerIpId`, `customerDomainId` | | **Mehrere Monitore** | `targets: [{ type, id }, ...]` Array | | **Nach Tag (dynamisch)** | `tagIds: [number, ...]`: deckt alle Monitore des Kunden des Fensters ab, die den Tag aktuell tragen; später getaggte Monitore werden automatisch abgedeckt | | **Kunden-Ebene** | `customerId` allein: deckt jeden Monitor des Kunden ab | ## Dynamisches Tag-Verhalten Tag-basierte Fenster werden vom Monitoring-Worker live ausgewertet: Jedes Mal, wenn ein Check-Ergebnis eintrifft, ermittelt der Worker, welche Wartungsfenster auf diesen Monitor zutreffen, indem er die aktuellen Tags des Monitors nachschlägt. Das bedeutet, dass ein Monitor, der *nach* der Fenstererstellung getaggt wird, automatisch abgedeckt ist, ohne das Fenster zu aktualisieren. Das Entfernen eines Tags von einem Monitor beendet die Abdeckung sofort. Tag-Fenster sind an einen einzelnen Kunden gebunden. Es ist nicht möglich, ein organisationsweites Tag-Fenster zu erstellen, das mehrere Kunden umfasst. ## Endpunkte - [Maintenance Windows auflisten](/de/api/maintenance-windows/list) - [Maintenance Window erstellen](/de/api/maintenance-windows/create) - [Maintenance Window abrufen](/de/api/maintenance-windows/get) - [Maintenance Window aktualisieren](/de/api/maintenance-windows/update) - [Maintenance Window löschen](/de/api/maintenance-windows/delete)
### Maintenance Window erstellen
URL: https://docs.uptimeify.io/de/api/maintenance-windows/create
Description: Erstellt ein neues Wartungsfenster. Unterstützt einen einzelnen Monitor (Legacy), mehrere Monitore, tag-basiertes (inkl. organisationsweit) oder kunden-weites Targeting.
Summary: `POST /api/maintenance-windows` ## Body ```json { "name": "Datenbank-Migration", "startTime": "2026-07-10T22:00:00.000Z", "endTime": "2026-07-11T01:00:00.000Z", "targets": [ { "type": "website", "id": "ef8a6564-0ccf-4f3f-a5ef-d2963176b3eb" }, { "type": "icmp", "id": "3d005a18-fdd8-4dc7-9f26-1a9d409c1bc5" } ], "tagIds": [7], "description": "Geplante Schema-Migration", "isRecurring": false, "isActive": true } ``` ### Pflichtfelder - `name` (string): Eine freundliche Bezeichnung für das Fenster. - `startTime` (ISO 8601 Datetime): Zeitpunkt, an dem das Fenster beginnt. - `endTime` (ISO 8601 Datetime): Zeitpunkt, an dem das Fenster endet. Muss nach `startTime` liegen. - **Mindestens ein Zielfeld** (siehe unten). ### Zielauswahl (gegenseitig ausschließende Modi) Genau ein Targeting-Modus muss verwendet werden. `targets` und `tagIds` können innerhalb des Multi-Monitor-Modus kombiniert werden. | Feld | Typ | Beschreibung | |------|-----|--------------| | `websiteId` | number | Legacy: einzelner Website-Monitor | | `icmpMonitorId` | number | Legacy: einzelner ICMP-Monitor | | `smtpMonitorId` | number | Legacy: einzelner SMTP-Monitor | | `sshMonitorId` | number | Legacy: einzelner SSH-Monitor | | `tcpMonitorId` | number | Legacy: einzelner TCP-Monitor | | `ftpMonitorId` | number | Legacy: einzelner FTP-Monitor | | `imapPopMonitorId` | number | Legacy: einzelner IMAP/POP-Monitor | | `dnsMonitorId` | number | Legacy: einzelner DNS-Monitor | | `customerIpId` | number | Legacy: einzelne Kunden-IP | | `customerDomainId` | number | Legacy: einzelne Kunden-Domain | | `targets` | `{ type, id }[]` | Multi-Monitor: `type` ist eines von `website` \| `dns` \| `icmp` \| `smtp` \| `ssh` \| `tcp` \| `ftp` \| `imap_pop` \| `customer_domain` \| `customer_ip`. `id` ist die öffentliche ID des Monitors (UUID), dieselbe Kennung, die auch die einzelnen Alt-Felder annehmen; eine numerische Zeilen-ID wird weiterhin akzeptiert. | | `tagIds` | number[] | Tag-basiert: siehe [Nur-Tag-Modus (organisationsweit)](#nur-tag-modus-organisationsweit) | | `customerId` | number | Kunden-Ebene: deckt jeden Monitor dieses Kunden ab | ### Nur-Tag-Modus (organisationsweit) Wird `tagIds` **ohne** `customerId`, `targets` oder Legacy-Felder gesendet, entsteht ein **organisationsweites** Wartungsfenster. Es deckt dynamisch jeden Monitor der gesamten Organisation ab, der aktuell die angegebenen Tags trägt, über alle Kunden hinweg. ```json { "name": "Infra-Tag-Freeze", "startTime": "2026-07-10T22:00:00.000Z", "endTime": "2026-07-11T01:00:00.000Z", "tagIds": [7] } ``` - **Erfordert einen organisationsweiten Admin oder Editor**: die Rolle UND einen uneingeschränkten Kunden-Scope. Ein kundengebundener Akteur (ein `readonly`-Benutzer, ein `editor` mit Kundenzuweisungen, ein Customer-Scoped Token) bekommt kein organisationsweites Fenster: Ist er genau einem Kunden zugeordnet, wird das Fenster an diesen Kunden gebunden und deckt nur dessen getaggte Monitore ab; ist er mehreren (oder keinem) zugeordnet, wird der Request mit `400 tagOnlyNeedsCustomer` abgelehnt und er muss stattdessen Monitore oder einen Kunden auswählen. Siehe [Rollen und der Kunden-Scope](/de/api/introduction/token-scopes-organization-vs-customer). - Die Tag-Zugehörigkeit wird live zur Prüfzeit aufgelöst: nach der Fenstererstellung getaggte Monitore werden automatisch abgedeckt. - Alle `tagIds` müssen zur selben Organisation gehören; das Mischen von Tags verschiedener Organisationen gibt `400 mixedTagOrganizations` zurück. ### Kombinationsregeln - **Mindestens ein** Zielfeld ist erforderlich. Das Weglassen aller Felder ist ein Zod-Validierungsfehler (Standard-`400` mit Validierungsantwort, **kein** `data.code`-Fehler). - **`customerId` (Kunden-Ebene-Modus)** kann nicht mit `targets`, `tagIds` oder Legacy-Feldern kombiniert werden. Das Kombinieren ist ein Zod-Validierungsfehler (Standard-`400`). - Alle Monitore in `targets` müssen zum **selben Kunden** gehören; das Mischen von Kunden gibt `{ data: { code: "mixedCustomers"…
### Maintenance Window löschen
URL: https://docs.uptimeify.io/de/api/maintenance-windows/delete
Description: Löscht ein Wartungsfenster dauerhaft. Die aktive Alarm-Unterdrückung endet sofort.
Summary: `DELETE /api/maintenance-windows/{id}` ## Pfad-Parameter - `id` (erforderlich): Die numerische ID des zu löschenden Wartungsfensters. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X DELETE "$BASE_URL/api/maintenance-windows/42" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort (Response) Gibt bei Erfolg `204 No Content` mit leerem Body zurück. ## Häufige Fehler - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Organisation hast oder das Fenster nicht im Scope liegt (globale Support-Konten können keine Wartungsfenster löschen) - `403` mit `data.code: customerScopedTokenForbidden` wenn das Fenster organisationsweit ist (ohne Kunden) und du ein kundengebundener Akteur bist: ein `readonly`-Benutzer, ein `editor` mit Kundenzuweisungen oder ein Customer-Scoped Token. Organisationsweite Fenster löscht nur ein organisationsweiter Admin oder Editor; siehe [Rollen und der Kunden-Scope](/de/api/introduction/token-scopes-organization-vs-customer) - `404 Not Found` wenn kein Wartungsfenster mit der angegebenen ID existiert
### Maintenance Window abrufen
URL: https://docs.uptimeify.io/de/api/maintenance-windows/get
Description: Gibt ein einzelnes Wartungsfenster anhand seiner ID zurück, einschließlich der vollständigen Ziel- und Tag-Auswahl.
Summary: `GET /api/maintenance-windows/{id}` ## Pfad-Parameter - `id` (erforderlich): Die numerische ID des Wartungsfensters. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/maintenance-windows/42" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "id": 42, "publicId": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", "organizationId": 10, "customerId": 1, "name": "Wöchentliches Deployment", "description": "Rollierendes Update jeden Montag", "startTime": "2026-07-07T02:00:00.000Z", "endTime": "2026-07-07T04:00:00.000Z", "isRecurring": true, "recurrencePattern": { "frequency": "weekly", "intervalCount": 1, "daysOfWeek": [1] }, "isActive": true, "timezone": "UTC", "targets": [ { "type": "website", "id": 101 }, { "type": "icmp", "id": 5 } ], "tags": [ { "id": 7, "publicId": "0b0e4c3e-9a1f-4d3e-8a2b-1c2d3e4f5a6b", "name": "Production", "color": "red" } ], "websiteId": null, "icmpMonitorId": null, "smtpMonitorId": null, "sshMonitorId": null, "tcpMonitorId": null, "ftpMonitorId": null, "imapPopMonitorId": null, "dnsMonitorId": null, "customerIpId": null, "customerDomainId": null, "createdAt": "2026-06-01T09:00:00.000Z", "updatedAt": "2026-06-01T09:00:00.000Z" } ``` Das `targets`-Array listet alle explizit ausgewählten Monitore auf. Das `tags`-Array listet die Tags auf, deren Monitore dynamisch abgedeckt werden, jeweils als `{ id, publicId, name, color }`; der Besitzer des Tags ist nicht Teil dieser Antwort. Beide können gleichzeitig nicht leer sein, wenn das Fenster eine gemischte Multi-Monitor- und Tag-Auswahl verwendet. `websiteSummary` (`{ id, publicId, name, url }` oder `null`) nennt die Legacy-Ziel-Website; `website` (die ganze Website-Zeile) ist zugunsten davon veraltet. **Abgelöstes Feld:** `recurrencePattern.interval` wird bis zum Entfall am 18.01.2027 weiter neben `recurrencePattern.intervalCount` geliefert. Lies `intervalCount`. ## Häufige Fehler - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Organisation hast oder das Fenster zu einem nicht zugänglichen Kunden gehört - `404 Not Found` wenn kein Wartungsfenster mit der angegebenen ID existiert
### Maintenance Windows auflisten
URL: https://docs.uptimeify.io/de/api/maintenance-windows/list
Description: Gibt alle Wartungsfenster zurück, die für den authentifizierten Benutzer sichtbar sind, gefiltert nach Organisation und optionalem Kunden-Filter.
Summary: `GET /api/maintenance-windows` ## Query-Parameter - `customerId` (optional): Fenster nach Kunden-ID filtern. - `organizationId` (optional): Standardmäßig die Organisation der Sitzung. - `envelope` (optional): `items` liefert `{ items, total, page, perPage }` statt des nackten Arrays, alle Fenster auf einer Seite. Ab dem 18.01.2027 ist diese Listenform der Standard; das nackte Array ist veraltet. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/maintenance-windows?customerId=1" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json [ { "id": 42, "publicId": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", "organizationId": 10, "customerId": 1, "name": "Wöchentliches Deployment", "description": "Rollierendes Update jeden Montag", "startTime": "2026-07-07T02:00:00.000Z", "endTime": "2026-07-07T04:00:00.000Z", "isRecurring": true, "recurrencePattern": { "frequency": "weekly", "intervalCount": 1, "daysOfWeek": [1] }, "isActive": true, "timezone": "UTC", "targets": [ { "type": "website", "id": 101 }, { "type": "icmp", "id": 5 } ], "tags": [ { "id": 7, "publicId": "0b0e4c3e-9a1f-4d3e-8a2b-1c2d3e4f5a6b", "name": "Production", "color": "red" } ], "websiteId": null, "icmpMonitorId": null, "smtpMonitorId": null, "sshMonitorId": null, "tcpMonitorId": null, "ftpMonitorId": null, "imapPopMonitorId": null, "dnsMonitorId": null, "customerIpId": null, "customerDomainId": null, "createdAt": "2026-06-01T09:00:00.000Z", "updatedAt": "2026-06-01T09:00:00.000Z" } ] ``` Jedes Fenster enthält: - `targets`: Array von `{ type, id }`-Objekten für alle explizit ausgewählten Monitore (`type` ist eines von `website` | `dns` | `icmp` | `smtp` | `ssh` | `tcp` | `ftp` | `imap_pop`). - `tags`: Array von Tag-Objekten `{ id, publicId, name, color }` für tag-basierte Abdeckung; ein leeres Array, wenn das Fenster keine Tag-Auswahl verwendet. Der Besitzer des Tags (`createdBy`) ist nicht Teil dieser Antwort. - `websiteSummary`: `{ id, publicId, name, url }` der Legacy-Ziel-Website oder `null`. `website` (die ganze Website-Zeile) ist zugunsten davon veraltet. - Legacy-Felder für einzelne Ziele (`websiteId`, `icmpMonitorId` usw.) bleiben aus Gründen der Abwärtskompatibilität vorhanden; sie sind `null`, wenn eine Multi-Target- oder Tag-Auswahl verwendet wird. **Abgelöstes Feld:** `recurrencePattern.interval` wird bis zum Entfall am 18.01.2027 weiter neben `recurrencePattern.intervalCount` geliefert. Lies `intervalCount`. ## Sichtbarkeit Welche Fenster zurückkommen, hängt davon ab, wer liest, nicht allein von den Query-Parametern: - Ein **uneingeschränkter Leser** (Organisations-Admin, globaler Admin sowie ein organisationsgebundenes Agent-Token) erhält jedes Fenster der Organisation: die kundengebundenen und die organisationsweiten (`customerId: null`). - Ein **kundengebundener Leser** (ein `readonly`-Benutzer, der einem oder mehreren Kunden zugewiesen ist, und das für ihn ausgestellte Agent-Token) erhält die Fenster seiner eigenen Kunden plus die organisationsweiten. Fenster eines anderen Kunden kommen nie zurück. - Ein **kundengebundenes API-Token** ist auf den Kunden festgelegt, für den es ausgestellt wurde, und erhält ausschließlich dessen Fenster. Ein explizites `customerId` verengt das Ergebnis zusätzlich. Ein `readonly`-Benutzer darf nur einen Kunden nennen, dem er zugewiesen ist; jeder andere Kunde antwortet mit `403 Forbidden`. ## Häufige Fehler - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Organisation hast
### Tag-Abdeckung vorschauen
URL: https://docs.uptimeify.io/de/api/maintenance-windows/preview-count
Description: Gibt zurück, wie viele unterschiedliche Monitore eine Menge von Tags aktuell abdeckt, für den Tag-basierten (organisationsweiten) Wartungsfenster-Modus.
Summary: `POST /api/maintenance-windows/preview-count` Wird vom Wartungsfenster-Formular genutzt, um vor dem Absenden eines [Tag-basierten (organisationsweiten) Fensters](/de/api/maintenance-windows/create#nur-tag-modus-organisationsweit) anzuzeigen: "Dies deckt N Monitore ab". Die Abdeckung wird live ermittelt: Gezählt wird jeder Monitor, über alle Monitor-Typen hinweg, der aktuell mit mindestens einem der angegebenen Tags versehen ist, dieselbe dynamische Zugehörigkeit, die das organisationsweite Fenster selbst zur Prüfzeit verwendet. ## Body ```json { "tagIds": [7] } ``` ### Felder | Feld | Typ | Beschreibung | |------|-----|--------------| | `tagIds` | number[] | Erforderlich, mindestens ein Eintrag. Tags, für die die Abdeckung gezählt wird. Müssen zu deiner Organisation gehören. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/maintenance-windows/preview-count" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "tagIds": [7] }' ``` ## Antwort (Response) ```json { "count": 12 } ``` `count` ist die Anzahl unterschiedlicher `(monitorType, monitorId)`-Paare, die aktuell mindestens eines der angegebenen Tags tragen, nicht die Anzahl der Tags. ## Häufige Fehler | Status | Beschreibung | |--------|--------------| | `400` (Validierung) | `tagIds` fehlt oder ist leer. Standard-Zod-Validierungsfehler, kein `{ data: { code } }`. | | `401 Unauthorized` | Nicht angemeldet. | | `404` `{ data: { code: "tagNotFound" } }` | Ein `tagId` existiert nicht in deiner Organisation oder du kannst ihn nicht sehen. |
### Wartungs-Wiederholungen vorschauen
URL: https://docs.uptimeify.io/de/api/maintenance-windows/preview-occurrences
Description: Berechnet die kommenden Vorkommen eines (noch nicht gespeicherten) Wiederholungsmusters, ohne ein Fenster anzulegen.
Summary: `POST /api/maintenance-windows/preview-occurrences` Reine Berechnung: Dieser Endpunkt greift nie auf die Datenbank zu. Er nutzt dieselbe zeitzonenbewusste Wiederholungs-Engine wie der Alarm-Unterdrückungspfad (`occurrencesInRange`), sodass die Vorschau nie von dem abweichen kann, was ein gespeichertes Fenster mit denselben Werten für `startTime`/`endTime`/`recurrencePattern`/`timezone` tatsächlich unterdrücken wird. Nützlich, um vor dem Absenden von [Maintenance Window erstellen](/de/api/maintenance-windows/create) oder [Maintenance Window aktualisieren](/de/api/maintenance-windows/update) zu zeigen, was ein Muster bedeutet. ## Body ```json { "startTime": "2026-08-10T02:00:00.000Z", "endTime": "2026-08-10T03:00:00.000Z", "isRecurring": true, "recurrencePattern": { "frequency": "weekly", "intervalCount": 1, "daysOfWeek": [1, 3] }, "timezone": "Europe/Berlin" } ``` ### Felder | Feld | Typ | Beschreibung | |------|-----|--------------| | `startTime` | ISO-8601-Datum/Zeit | Erforderlich. Beginn des ersten Vorkommens. | | `endTime` | ISO-8601-Datum/Zeit | Erforderlich. Ende des ersten Vorkommens. Muss nach `startTime` liegen. | | `isRecurring` | boolean | Erforderlich. Bei `false` enthält die Antwort nur das einzelne Anker-Vorkommen. | | `recurrencePattern` | Objekt | Erforderlich, wenn `isRecurring` `true` ist. Gleiche Struktur wie bei [Maintenance Window erstellen](/de/api/maintenance-windows/create#wiederholung). | | `timezone` | string | Standard `"UTC"`. Die IANA-Zeitzone, in der das Muster interpretiert wird, gleiche Validierung und Kanonisierung wie das `timezone`-Feld bei Erstellung/Aktualisierung. | Die Antwort liefert höchstens 5 kommende Vorkommen, mit einem Vorschau-Horizont von bis zu 5 Jahren ab dem aktuellen Zeitpunkt. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/maintenance-windows/preview-occurrences" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "startTime": "2026-08-10T02:00:00.000Z", "endTime": "2026-08-10T03:00:00.000Z", "isRecurring": true, "recurrencePattern": { "frequency": "weekly", "intervalCount": 1, "daysOfWeek": [1, 3] }, "timezone": "Europe/Berlin" }' ``` ## Antwort (Response) ```json { "occurrences": [ { "start": "2026-08-10T00:00:00.000Z", "end": "2026-08-10T01:00:00.000Z" }, { "start": "2026-08-12T00:00:00.000Z", "end": "2026-08-12T01:00:00.000Z" }, { "start": "2026-08-17T00:00:00.000Z", "end": "2026-08-17T01:00:00.000Z" } ] } ``` `occurrences` kann ein leeres Array sein (z. B. wenn das `endRecurrenceDate` eines Wiederholungsmusters bereits vor dem Vorschau-Horizont liegt). `isRecurring: true` ohne `recurrencePattern` ist kein Fehler. Das Fenster gilt dann als nicht wiederkehrend, und die Antwort enthält nur das eine Vorkommen aus `startTime` und `endTime`, derselbe Rückfall, den die Wiederholungsberechnung auch bei einem fehlerhaften Muster anwendet. **Abgelöstes Feld:** Bis zum 18.01.2027 liefern Antworten `recurrencePattern.interval` weiter neben `recurrencePattern.intervalCount`, und Request-Bodys nehmen es noch an. Sende `intervalCount`; beide mit verschiedenen Werten ergeben `400` `invalidRequestBody`. ## Häufige Fehler | Status | Beschreibung | |--------|--------------| | `400` (Validierung) | `timezone` ist ein reiner UTC-Offset oder kein vom Laufzeitsystem erkannter Zonenname. Standard-Zod-Validierungsfehler, kein `{ data: { code } }`. | | `400` `{ data: { code: "invalidWindow" } }` | `endTime` liegt nicht nach `startTime`. | | `401 Unauthorized` | Nicht angemeldet. |
### Maintenance Window aktualisieren
URL: https://docs.uptimeify.io/de/api/maintenance-windows/update
Description: Aktualisiert ein Wartungsfenster partiell. Alle Felder sind optional; nur angegebene Felder werden geändert. Wenn targets oder tagIds angegeben werden, ersetzen sie die bestehende Auswahl vollständig.
Summary: `PATCH /api/maintenance-windows/{id}` ## Pfad-Parameter - `id` (erforderlich): Die numerische ID des zu aktualisierenden Wartungsfensters. ## Body Alle Felder sind optional. Felder weglassen, um sie unverändert zu lassen. ```json { "name": "Erweitertes Deployment-Fenster", "endTime": "2026-07-11T03:00:00.000Z", "targets": [ { "type": "website", "id": "ef8a6564-0ccf-4f3f-a5ef-d2963176b3eb" }, { "type": "dns", "id": "5b0d88a6-397d-4acd-b69f-c31405d7d0da" } ], "tagIds": [7, 12], "isActive": true } ``` ### Aktualisierbare Felder | Feld | Typ | Hinweise | |------|-----|----------| | `name` | string | Anzeigename | | `description` | string | Freitext-Notizen | | `startTime` | ISO 8601 Datetime | Neuer Startzeitpunkt | | `endTime` | ISO 8601 Datetime | Neuer Endzeitpunkt; muss nach `startTime` liegen | | `isActive` | boolean | Aktivieren oder deaktivieren ohne Löschen | | `isRecurring` | boolean | Wiederholung umschalten | | `recurrencePattern` | object | Ersetzt das Wiederholungsmuster; Struktur identisch mit create | | `timezone` | string | Die IANA-Zeitzone (z. B. `"Europe/Berlin"`), in der das Wiederholungsmuster interpretiert wird. Schreibweisen unabhängig von Groß-/Kleinschreibung sowie veraltete IANA-Linknamen (z. B. `"gmt"`, `"Zulu"`) werden akzeptiert und unter der kanonischen Bezeichnung des Laufzeitsystems gespeichert, `"utc"` und `"Zulu"` werden beide als `"UTC"` gespeichert. Ein reiner UTC-Offset (z. B. `"+05:00"`) wird abgewiesen: Er enthält keine Sommerzeit-Regel und kann daher nicht leisten, was ein Zonenname leistet. | | `targets` | `{ type, id }[]` | **Ersetzt** die vollständige Menge der expliziten Monitor-Ziele. `id` ist die öffentliche ID des Monitors (UUID), eine numerische Zeilen-ID wird weiterhin akzeptiert. | | `tagIds` | number[] | **Ersetzt** die vollständige Menge der Tag-IDs | | `websiteId` / `icmpMonitorId` / … | number \| null | Legacy-Felder für einzelne Ziele | | `customerId` | number | Kunden-Anker (nur für tag-only Fenster) | ### Ersetz-Semantik für targets und tagIds Wenn `targets` oder `tagIds` im Request-Body enthalten ist, wird die **gesamte bestehende Auswahl** für dieses Feld ersetzt. Um alle expliziten Ziele zu entfernen, sende `"targets": []`; um alle Tags zu entfernen, sende `"tagIds": []`. ### Kombinationsregeln PATCH validiert den Ziel- und Tag-Scope über denselben Resolver wie create, führt jedoch **nicht** den create-zeitigen Zod-superRefine erneut aus. In der Praxis: - `customerId` kann nicht mit `targets`, `tagIds` oder Legacy-Feldern kombiniert werden. - Alle Monitore in `targets` müssen zum selben Kunden gehören; Mischung gibt `{ data: { code: "mixedCustomers" } }` zurück. - Ein organisationsweites Nur-Tag-Fenster (Tags ohne `customerId`, `targets` oder Legacy-Felder) kann nur von einem **organisationsweiten** Admin oder Editor bearbeitet werden. Ein kundengebundener Akteur (ein `readonly`-Benutzer, ein `editor` mit Kundenzuweisungen, ein Customer-Scoped Token) erhält `403` mit `data.code: customerScopedTokenForbidden`, egal was er sendet. - Ein Fenster, das bereits einem Kunden gehört, bleibt bei diesem Kunden: der vorhandene Kunde bildet den Ausgangspunkt für den Resolver, `tagIds` hinzuzufügen macht es nie organisationsweit. ### Readonly-Benutzer im Scope Readonly-Benutzer, die dem Kunden des Fensters zugewiesen sind, können Wartungsfenster für diesen Kunden bearbeiten (`readonly` ist die Self-Service-Rolle des Kunden, siehe [Rollen und der Kunden-Scope](/de/api/introduction/token-scopes-organization-vs-customer)). Globale Support-Konten können dies nicht. Kein kundengebundener Akteur, ob `readonly` oder nicht, kann ein organisationsweites Nur-Tag-Fenster aktualisieren. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X PATCH "$BASE_URL/api/maintenance-windows/42" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"isActive": false}' ``` ## Antwort (Response) Gibt das aktualisierte Wartungsfenster-Objekt zurüc…
### MCP-Server
URL: https://docs.uptimeify.io/de/api/mcp
Description: Nutze die kostenlosen Uptimeify-Checks aus jedem KI-Agenten über das Model Context Protocol (MCP).
Summary: Uptimeify stellt einen zustandslosen [Model-Context-Protocol](https://modelcontextprotocol.io)-Server bereit, damit KI-Agenten unsere kostenlosen Checks direkt ausführen können. Einen Überblick darüber, was der Server kann und mit welchen Clients er funktioniert, findest du auf der [MCP-Server-Seite auf uptimeify.io](https://uptimeify.io/de/mcp-server). Diese Seite hier ist die technische Referenz. ## Endpunkt `POST https://uptimeify.io/mcp`: Streamable-HTTP-Transport, zustandslos. Die anonymen Check-Tools brauchen keine Authentifizierung; die authentifizierten Tools benötigen einen Bearer-API-Token (siehe unten). Den Server programmatisch über die MCP Server Card entdecken: `GET https://uptimeify.io/.well-known/mcp/server-card.json` **Browser-Origins.** Anfragen mit `Origin`-Header (also Anfragen, die eine Webseite im Browser stellt) werden nur von `https://uptimeify.io` angenommen. Jeder andere Origin erhält HTTP `403` mit dem JSON-RPC-Fehler `data.code: "mcpOriginNotAllowed"`; das schützt vor DNS-Rebinding-Angriffen. MCP-Clients wie Claude, Cursor oder `mcp-remote` senden keinen `Origin`-Header und sind nicht betroffen. ## MCP-Client verbinden Richte einen beliebigen MCP-Client mit **Streamable-HTTP**-Transport auf den Endpunkt oben aus. - **Anonyme Tools** funktionieren allein mit der URL: kein Token nötig. - **Authentifizierte Tools** benötigen deinen Uptimeify-API-Token als `Authorization: Bearer `-Header. Erstelle einen unter **Einstellungen → API-Tokens**: lass das Kunden-Feld leer für einen organisationsweiten Token (sieht alle deine Monitore) oder wähle einen Kunden, um den Token auf diesen Kunden zu beschränken. Der Token wird **nur einmal** bei der Erstellung angezeigt: kopiere ihn sofort. Clients, die HTTP-MCP-Server mit eigenen Headern unterstützen, zeigen direkt auf die URL: ```json { "mcpServers": { "uptimeify": { "url": "https://uptimeify.io/mcp", "headers": { "Authorization": "Bearer wsm_dein_token_hier" } } } } ``` Für Clients, die nur stdio sprechen, überbrückst du zum HTTP-Endpunkt mit [`mcp-remote`](https://www.npmjs.com/package/mcp-remote): ```json { "mcpServers": { "uptimeify": { "command": "npx", "args": ["-y", "mcp-remote", "https://uptimeify.io/mcp", "--header", "Authorization: Bearer wsm_dein_token_hier"] } } } ``` Lass den `Authorization`-Header weg, wenn du nur die anonymen Check-Tools brauchst. ## Rate-Limits Die anonymen Tools führen echte Netzwerk-Checks in deinem Auftrag aus und sind deshalb pro Client-IP gedeckelt. Für diese Limits brauchst du keinen Account, und um darunter zu bleiben ebenfalls nicht: | Bereich | Limit | | --- | --- | | `POST /mcp` insgesamt | 120 Anfragen pro Minute und IP | | Jedes anonyme Check-Tool | 15-30 Aufrufe pro Minute und IP, je nach Aufwand des Checks (`whois` und `domain_expiry` sind mit 15 am strengsten) | | Jedes authentifizierte Lese-Tool | 60 Aufrufe pro Minute und IP | | Jedes authentifizierte Schreib-Tool | 10 Aufrufe pro Minute **je Organisation**, nicht je IP -- Schreiben ist seltener und teurer als Lesen, ein Modell, das einen Schreibaufruf in einer Schleife wiederholt, soll das absichtlich schnell zu spüren bekommen | Beide Ebenen gelten gleichzeitig: 120 Aufrufe pro Minute verteilt über verschiedene Tools sind in Ordnung, 120 Aufrufe `whois` pro Minute nicht. Wird ein Limit überschritten, antwortet der Server mit HTTP `429` und einem `retryAfter`-Wert in Sekunden, der angibt, wann das aktuelle Fenster endet. Die Fenster sind fest, nicht gleitend, wer `retryAfter` abwartet, bekommt sofort das volle Kontingent. Gezählt wird pro IP, nicht pro Token: Ein API-Token hebt die Grenze nicht an, und mehrere Agenten hinter derselben NAT-Adresse teilen sie sich. Wenn du einen Anwendungsfall hast, der wirklich mehr braucht, [melde dich](https://uptimeify.io/de/kontakt), statt es zu umgehen. ## Verfügbare Tools Alle Tools sind anonym und nur lesend. Sie entsprechen unseren öffentlichen Web-Tools: - **check_ssl**: TLS/SSL-Zertifikatsprüfung (`host`, optional…
### Monitoring-Daten & Berichte
URL: https://docs.uptimeify.io/de/api/monitoring
Description: API-Endpunkte zum Abrufen von Monitoring-Daten, Check-Historien, Incident-Details, Uptime-Statistiken und PDF-Berichten.
Summary: ## Monitoring-Daten ### Metriken abrufen `GET /api/websites/:websitePublicId/uptime-stats` Gibt Uptime-Prozentsätze und durchschnittliche Antwortzeiten (Tag/Monat/Jahr) zurück. ### Letzte Checks abrufen `GET /api/websites/:websitePublicId/check-history` Gibt die letzten Monitoring-Checks einer Website zurück. ### Ausfälle auflisten `GET /api/websites/:websitePublicId/incident-history` Gibt die Incident-Historie einer Website zurück. ### Alert-Historie abrufen `GET /api/websites/:websitePublicId/alert-history` Gibt die letzten Benachrichtigungs-/Eskalations-Versuche für Incidents einer Website zurück. ### Monitoring-Daten abrufen `GET /api/websites/:websitePublicId/monitoring-data?range=day|week|month|year` Gibt aggregierte Timeseries-Daten zurück (Charts). ### Ausfall-Details abrufen `GET /api/incidents/:incidentPublicId` Gibt Details zu einem bestimmten Vorfall zurück. ### Ausfälle auflisten (Organisation) `GET /api/incidents?organizationId=:organizationId` Listet Incidents einer Organisation (zugriffsbeschränkt) auf. ## Berichte ### PDF-Bericht herunterladen `GET /api/websites/:websitePublicId/report.pdf?period=last-week|last-month|last-quarter|last-year&startDate=YYYY-MM-DD&endDate=YYYY-MM-DD` Lädt einen PDF-Bericht für eine Website herunter. ## Uptime-Badge Jede Website hat ein öffentliches SVG-Badge mit ihrer Uptime der letzten 24 Stunden, 7 Tage oder 30 Tage. Es braucht keine Authentifizierung und wird **ausschließlich** über die `publicId` der Website angesprochen; die numerische ID wird nicht akzeptiert (Antwort `404`). ``` https://uptimeify.io/api/public/badge/?period=30d ``` | Parameter | Werte | Standard | |-----------|-------|----------| | `period` | `7d`, `30d`; jeder andere oder kein Wert bedeutet die letzten 24 Stunden | letzte 24 Stunden | Die Antwort ist `image/svg+xml` und wird fünf Minuten gecacht. Einbetten als `` in Markdown oder als `
`-Tag; die Badge-URL steht auch auf der Detailseite der Website. ## Endpunkte - [Metriken abrufen](/de/api/monitoring/get-uptime-stats) - [Letzte Checks abrufen](/de/api/monitoring/get-check-history) - [Ausfälle auflisten](/de/api/monitoring/get-incident-history) - [Ausfall-Details abrufen](/de/api/monitoring/get-incident-details) - [Alert-Historie abrufen](/de/api/monitoring/get-alert-history) - [Monitoring-Daten abrufen](/de/api/monitoring/get-monitoring-data) - [Ausfälle auflisten (Organisation)](/de/api/monitoring/list-incidents) - [PDF-Bericht herunterladen](/de/api/monitoring/download-report-pdf)
### Monitoring-Standorte
URL: https://docs.uptimeify.io/de/api/monitoring-locations
Description: Ruft die Liste der Länder und Standorte ab, an denen Monitoring-Probes verfügbar sind.
Summary: ## Endpunkte - [Länder auflisten](/de/api/monitoring-locations/list-countries): authentifiziert, nach Land gruppiert - [Öffentliche Standorte auflisten](/de/api/monitoring-locations/list-public-locations): öffentlich, ohne Authentifizierung ## Verfügbare Standorte | Code | Name | Land | |------|------|---------| | `de-ber` | Berlin | Deutschland | | `de-fra` | Frankfurt | Deutschland | | `de-fsn` | Falkenstein | Deutschland | | `de-nbg` | Nürnberg | Deutschland | | `es-vit` | Logroño | Spanien | | `fi-hel` | Helsinki | Finnland | | `fr-par` | Paris | Frankreich | | `it-mil` | Mailand | Italien | | `pl-waw` | Warschau | Polen |
### Länder mit Standorten auflisten
URL: https://docs.uptimeify.io/de/api/monitoring-locations/list-countries
Description: Gibt Länder zurück, die Monitoring-Standorte mit aktiven Workern haben. Erfordert Authentifizierung.
Summary: `GET /api/monitoring-locations/countries` ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/monitoring-locations/countries" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "countries": [ { "code": "DE", "locations": 4, "workers": 23 }, { "code": "ES", "locations": 1, "workers": 4 }, { "code": "FI", "locations": 1, "workers": 6 }, { "code": "FR", "locations": 1, "workers": 4 }, { "code": "IT", "locations": 1, "workers": 4 }, { "code": "PL", "locations": 1, "workers": 6 } ] } ```
### Öffentliche Monitoring-Standorte auflisten
URL: https://docs.uptimeify.io/de/api/monitoring-locations/list-public-locations
Description: Öffentlicher Endpunkt (keine Authentifizierung erforderlich), der alle Monitoring-Standorte mit aktiven Workern zurückgibt. Geeignet für Landingpages und Marketing.
Summary: `GET /api/public/monitoring-locations` ## Beispiel (cURL) ```bash curl -X GET "https://uptimeify.io/api/public/monitoring-locations" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "locations": [ { "id": 19, "code": "de-ber", "name": "Berlin (DE)", "countryCode": "DE", "activeWorkers": 4 }, { "id": 18, "code": "de-fra", "name": "Frankfurt (DE)", "countryCode": "DE", "activeWorkers": 4 }, { "id": 8, "code": "de-fsn", "name": "Falkenstein (DE)", "countryCode": "DE", "activeWorkers": 6 }, { "id": 7, "code": "de-nbg", "name": "Nuremberg (DE)", "countryCode": "DE", "activeWorkers": 7 }, { "id": 20, "code": "es-vit", "name": "Logroño (ES)", "countryCode": "ES", "activeWorkers": 4 }, { "id": 3, "code": "fi-hel", "name": "Helsinki (FI)", "countryCode": "FI", "activeWorkers": 6 }, { "id": 17, "code": "fr-par", "name": "Paris (FR)", "countryCode": "FR", "activeWorkers": 4 }, { "id": 6, "code": "it-mil", "name": "Milan (IT)", "countryCode": "IT", "activeWorkers": 4 }, { "id": 5, "code": "pl-waw", "name": "Warsaw (PL)", "countryCode": "PL", "activeWorkers": 6 } ] } ``` `activeWorkers` ist ein Live-Wert und schwankt über die Zeit.
### Vorfall nachtragen
URL: https://docs.uptimeify.io/de/api/monitoring/backfill-incident
Description: Trägt einen vergangenen, schon behobenen Vorfall mit seinen echten Zeiten auf Statusseiten nach, ohne jemanden zu benachrichtigen.
Summary: `POST /api/incidents/backfill` Trägt einen Vorfall nach, der schon vorbei ist, wie „Backfill incident“ bei Atlassian Statuspage: ein Ausfall, den du ohne Statusseite behandelt hast, oder einer von vor ihrer Zeit. Du gibst Beginn und Ende an und wahlweise Updates mit eigenen Zeitpunkten. Der Vorfall entsteht behoben und erscheint auf den genannten Statusseiten: - in der Vorfallshistorie jedes Layouts, mit seinen Updates, - in den Verfügbarkeitsbalken der betroffenen **manuellen** Komponenten (Layout `statusboard`), wenn seine Auswirkung `partial_outage` oder `major_outage` ist (`degraded` und `maintenance` zählen nicht als Ausfall). Monitor-Komponenten behalten die Balken, die ihr Monitor misst. Er wird **still** erfasst: keine E-Mail, kein Webhook, keine Slack- oder Teams-Nachricht und kein Eintrag im RSS-/Atom-Feed, egal wie die Abos der Seiten eingestellt sind. Spätere Änderungen laufen über die normalen Endpunkte (zum Beispiel [Vorfall-Update posten](/de/api/monitoring/post-incident-update) mit eigenem `notifySubscribers`). Dasselbe tun „Vorfall nachtragen“ im Statusseiten-Modul und das MCP-Tool `backfill_incident`. Nicht idempotent: ein zweiter Aufruf trägt einen zweiten Vorfall nach. ## Authentifizierung Ohne Statusseiten: Rolle `admin` oder `editor` (oder ein Organisations-API-Token). Mit Statusseiten entscheidet jede Seite in `statusPageIds`: organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor`; kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens brauchen `self_service`-Seiten oder `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Jede Seite in `statusPageIds` muss zu deiner Organisation gehören (sonst `404 statusPageNotFound`) und in deinem Kundenbereich liegen; ohne `customerId` gehört der Vorfall der Organisation, ein kundengebundener Login oder ein solches Token bekommt dann `403 forbidden`. Braucht das Statusseiten-Modul (`403 statusPagesModuleDisabled`). - Header: `Authorization: Bearer ` ## Request-Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `title` | string | ja | Überschrift, 1 bis 200 Zeichen. | | `severity` | string | ja | `minor`, `major`, `critical` oder `maintenance`. | | `startedAt` | string | ja | Beginn als ISO 8601, in der Vergangenheit. | | `resolvedAt` | string | ja | Ende als ISO 8601, in der Vergangenheit und nach `startedAt`. | | `statusPageIds` | array | ja | Statusseiten (id oder publicId), 1 bis 10. Eine Seite ohne eine der `componentIds` bekommt den Vorfall seitenweit. | | `componentIds` | array | nein | Betroffene Komponenten (id oder publicId), höchstens 100; jede muss zu einer der `statusPageIds` gehören. | | `impact` | string | nein | `degraded`, `partial_outage`, `major_outage` oder `maintenance`. Vorgabe aus `severity` wie bei [Manuellen Vorfall anlegen](/de/api/monitoring/create-manual-incident). | | `componentImpacts` | array | nein | Auswirkung einzelner Komponenten, `[{ "componentId": 8, "impact": "major_outage" }]`; jede muss auch in `componentIds` stehen. | | `customerId` | integer | nein | Kunde, dem der Vorfall gehört. Dann nur Seiten ohne Kunde oder dieses Kunden. | | `summary` | string | nein | Bis 5.000 Zeichen. | | `updates` | array | nein | Bis 50 Updates `{ "status", "body", "createdAt" }`: `status` ist `investigating`, `identified`, `monitoring` oder `resolved`, `body` 1 bis 5.000 Zeichen, `createdAt` ein ISO-8601-Zeitpunkt zwischen `startedAt` und `resolvedAt`. | **Zeitregeln:** `startedAt` muss vor `resolvedAt` liegen und jedes Update dazwischen (`400 invalidDateRange`); kein Zeitpunkt darf in der Zukunft liegen (`400 backfillInFuture`); `startedAt` darf höchstens 90 Tage vor dem Anlegen der ältesten genannten Seite liegen, so weit reichen die Verfügbarkeitsbalken (`400 backfillTooOld`). Unbekannte Felder werden mit `400 invalidRequestBody` abgewiesen. ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/incidents/backfi…
### Manuellen Vorfall anlegen
URL: https://docs.uptimeify.io/de/api/monitoring/create-manual-incident
Description: Legt einen manuellen Vorfall auf den Statusseiten eines Kunden oder auf gewählten Statusseiten und Komponenten an.
Summary: `POST /api/incidents` Legt einen **manuellen** Vorfall an: eine Meldung auf Statusseiten, von Ihnen geschrieben statt von einem Monitor erkannt. Mit `customerId` erscheint er wie bisher auf jeder Statusseite dieses Kunden. Seit dem 27. Oktober 2026 ist `customerId` optional: mit `statusPageIds` erscheint der Vorfall auf diesen Seiten, seitenweit oder auf den Komponenten aus `componentIds`, auch auf einer Seite ohne Kunden oder ohne einen einzigen Monitor. Die Abonnenten jeder Seite, auf der er erscheint, werden benachrichtigt. Die Benachrichtigung trägt den Text des ersten Updates (`updateBody`). ## Authentifizierung Ohne Statusseiten: Rolle `admin` oder `editor` (oder ein Organisations-API-Token). Mit Statusseiten entscheidet jede Seite in `statusPageIds`: organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor`; kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens brauchen `self_service`-Seiten oder `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ohne `customerId` gehört der Vorfall der Organisation, wie eine Statusseite ohne Kunden: ein kundengebundenes Login oder Token bekommt `403 forbidden`. Jede Seite in `statusPageIds` muss zu Ihrer Organisation gehören (sonst `404 statusPageNotFound`) und in Ihrem Kundenbereich liegen. - Header: `Authorization: Bearer ` ## Anfrage (Request Body) | Feld | Typ | Erforderlich | Beschreibung | |-------|------|----------|-------------| | `customerId` | integer | Nein* | Kunde, auf dessen Statusseiten der Vorfall erscheint. *Entweder `customerId` oder `statusPageIds` ist Pflicht. | | `websiteId` | integer | Nein | Eine Website von `customerId`, um die es geht. Braucht `customerId`. | | `title` | string | Ja | Überschrift, 1 bis 200 Zeichen. | | `severity` | string | Ja | `minor`, `major`, `critical` oder `maintenance`. | | `summary` | string | Nein | Bis zu 5.000 Zeichen. | | `startedAt` | string | Nein | ISO-8601-Zeitpunkt, Standard jetzt. | | `updateStatus` | string | Nein | Erstes Timeline-Update zusammen mit `updateBody`: `investigating`, `identified`, `monitoring` oder `resolved` (öffnet den Vorfall behoben). | | `updateBody` | string | Nein | Text des ersten Updates, bis zu 5.000 Zeichen. | | `statusPageIds` | Array | Nein* | Statusseiten (id oder publicId), höchstens 10. Eine Seite ohne Komponente aus `componentIds` bekommt den Vorfall seitenweit. Mit `customerId` nur Seiten ohne Kunden oder dieses Kunden. | | `componentIds` | Array | Nein | Betroffene Komponenten (id oder publicId), höchstens 100; jede muss zu einer Seite aus `statusPageIds` gehören. Solange der Vorfall offen ist, übernehmen diese manuellen Komponenten seinen `impact`. | | `impact` | string | Nein | `degraded`, `partial_outage`, `major_outage` oder `maintenance`. Standard aus `severity`: `minor` = `degraded`, `major` = `partial_outage`, `critical` = `major_outage`, `maintenance` = `maintenance`. | | `componentImpacts` | array | Nein | Auswirkung einzelner Komponenten, `[{ "componentId": 8, "impact": "major_outage" }]`, statt `impact` für diese. Jede `componentId` muss auch in `componentIds` stehen (gleiche Schreibweise), sonst `400 invalidRequestBody`. | | `notifySubscribers` | boolean | Nein | Standard `true`. `false` stellt den Vorfall auf die Seiten (Verlauf, RSS-Feed), ohne E-Mail- oder Webhook-Benachrichtigung an deren Abonnenten. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/incidents" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "title": "Card payments failing", "severity": "major", "statusPageIds": ["2b9c7d1e-5f3a-4c8b-9e0d-1a2b3c4d5e6f"], "componentIds": [8], "updateStatus": "investigating", "updateBody": "We are looking into failed card payments." }' ``` ## Antwort (Response) `201 Created` ```json { "incident": { "id": 5121, "publicId": "8d1f0c2e-6a2b-4f1e-9b7c-2e5a1d3c4b5a" } } ``` ## Häufige Fehler - `400 Bad Request` (`incidentTargetRequired`), wenn wed…
### Incident löschen (nur manuell)
URL: https://docs.uptimeify.io/de/api/monitoring/delete-incident
Description: Löscht einen manuell erstellten (Statusseiten-)Incident. Vom Monitoring erzeugte Incidents können nicht gelöscht werden.
Summary: `DELETE /api/incidents/:id` Löscht einen **manuellen** Incident (eine von einem Admin erstellte Statusseiten-Ankündigung) samt seiner Timeline-Updates. Vom Monitoring erzeugte Incidents gehören den Workern und können niemals gelöscht werden, der Endpunkt lehnt sie mit `403 notManualIncident` ab. ## Authentifizierung Im Kundenbereich des Vorfalls. Ist der Vorfall mit Statusseiten verknüpft, muss jede verknüpfte Seite es erlauben: organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor`; kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens brauchen `self_service`-Seiten oder `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein Vorfall ohne verknüpfte Seite folgt weiter der Rolle: `admin` oder `editor`. - Header: `Authorization: Bearer ` ## Pfad-Parameter - `id` (erforderlich): Die numerische ID des Incidents oder seine `publicId` (UUID). ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X DELETE "$BASE_URL/api/incidents/8d1f0c2e-6a2b-4f1e-9b7c-2e5a1d3c4b5a" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort ```json { "success": true, "ok": true } ``` `ok` ist veraltet und bleibt für bestehende Leser; bitte `success` lesen. ## Häufige Fehler - `400 Incident id is required` wenn keine ID übergeben wird - `400 Invalid Incident identifier` wenn die ID weder eine numerische Incident-ID noch eine UUID ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keine Schreibrechte für den Kunden des Incidents hast - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und eine beteiligte Statusseite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `403 Only manual incidents can be deleted` (`data.code: notManualIncident`) wenn der Incident vom Monitoring erzeugt wurde - `404 Incident not found` wenn kein Incident zur ID passt
### PDF-Bericht herunterladen
URL: https://docs.uptimeify.io/de/api/monitoring/download-report-pdf
Description: Lädt einen generierten PDF-Report für eine Website herunter.
Summary: `GET /api/websites/:websitePublicId/report.pdf` Du kannst entweder einen vordefinierten Zeitraum per `period` verwenden oder einen eigenen Zeitraum per `startDate`/`endDate` angeben. ## Query Parameter - `period` (optional): `last-week` | `last-month` | `last-quarter` | `last-year` (Standard: `last-month`) - `startDate` (optional, nur zusammen mit `endDate`): `YYYY-MM-DD` - `endDate` (optional, nur zusammen mit `startDate`): `YYYY-MM-DD` ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -L "$BASE_URL/api/websites/6bfec6f6-245a-47ce-843b-157d97d56f88/report.pdf?period=last-month" \ -H "Authorization: Bearer $TOKEN" \ -o report.pdf ``` ## Antwort (Response) - Content-Type: `application/pdf` - Body: PDF-Binary ## Häufige Fehler - `400 Website public ID (UUID) required` wenn `:websitePublicId` ungültig ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Website hast - `404 Website not found` wenn die Website nicht existiert
### Alert-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitoring/get-alert-history
Description: Gibt die letzten Benachrichtigungs-/Eskalations-Versuche (bis zu 50) für alle Incidents einer Website zurück.
Summary: `GET /api/websites/:websitePublicId/alert-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `websitePublicId` (Pfad, erforderlich): Öffentliche UUID der Website. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `sent` oder `failed`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `sentAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/websites/11111111-1111-4111-8111-111111111111/alert-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 987, "incidentId": 123, "type": "slack", "status": "sent", "channelName": "Ops Slack", "channelType": "slack", "channelConfig": null, "sentAt": "2026-02-26T12:11:00.000Z", "errorMessage": null } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Jeder Eintrag ist ein Zustellversuch an einen Benachrichtigungskanal. `status` ist `sent` oder `failed` (bei Fehler ist `errorMessage` gesetzt); `channelType` ist der Kanaltyp (z. B. `email`, `slack`, `opsgenie`). Bei `channelConfig` sind Secrets geschwärzt. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 Website public ID (UUID) required` wenn `:websitePublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### Letzte Checks abrufen
URL: https://docs.uptimeify.io/de/api/monitoring/get-check-history
Description: Gibt die letzten Monitoring-Checks einer Website zurück.
Summary: `GET /api/websites/:websitePublicId/check-history` ## Query Parameter - `limit` (optional, Standard: `50`, max: `200`) - `checkType` (optional, erlaubt u.a. `http_status`, `ssl_check`, `combined`, `playwright`, `heartbeat`, `dns` sowie Legacy-Werte wie `http` oder `ssl`) ## Pfadparameter - `websitePublicId` (empfohlen): Public-ID der Website als UUID - Legacy-Kompatibilität: numerische Website-IDs werden weiterhin akzeptiert ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/websites/6bfec6f6-245a-47ce-843b-157d97d56f88/check-history?limit=25&checkType=dns" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "data": [ { "id": "chk_01H...", "status": "success", "errorMessage": null, "warningMessage": null, "timingDns": 12, "diagnostics": null, "checkedAt": "2026-02-26T12:34:56.000Z", "locationId": 7, "locationName": "Nuremberg (DE)", "locationCode": "de-nbg" } ] } ``` ## Häufige Fehler - `400 Invalid Website identifier` wenn `:websitePublicId` weder eine gültige UUID noch eine Legacy-ID ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status`, `minMs` oder `maxMs` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `400 Invalid checkType` wenn du einen nicht unterstützten `checkType` sendest - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Website hast
### Ausfall-Details abrufen
URL: https://docs.uptimeify.io/de/api/monitoring/get-incident-details
Description: Gibt Details zu einem bestimmten Vorfall zurück.
Summary: `GET /api/incidents/:incidentPublicId` Enthält neben den Incident-Basisdaten auch eine Timeline (Checks/Alert-Events) sowie optional einen Evidence-Check. ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `incidentPublicId` (Path, required): Öffentliche UUID des Incidents. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/incidents/6bfec6f6-245a-47ce-843b-157d97d56f88" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Hinweis: `evidenceCheck` kann `null` sein. `screenshotUrl` ist nur gesetzt, wenn `hasScreenshot` `true` ist. ## Auflösung der Timeline `timeline.outageChecks` listet jeden Check zwischen der Bestätigung (`confirmationAt`, ausschließlich) und dem Ende des Vorfalls, fehlgeschlagene wie erfolgreiche, aufsteigend und auf 200 begrenzt; `outageChecksTotal` ist die volle Anzahl. Maßgeblich ist `status` je Eintrag: ein aggregierter Zeitraum ist `failure`, sobald darin ein Standort fehlgeschlagen ist. Jeder Eintrag in `outageStartedCheck`, `failedChecks`, `outageChecks` und `recoveryChecks` trägt ein Feld `resolution`: - `raw`: eine einzelne Prüfung an einem einzelnen Standort. `location`, `statusCode` und `errorMessage` sind die Werte, die dieser Standort gemeldet hat. - `1min`: eine Minute aus dem Monitoring-Aggregat. Sie wird verwendet, sobald ein Vorfall älter ist als die Aufbewahrungsfrist der Rohdaten (24 Stunden). `location`, `statusCode` und `errorMessage` sind dann `null`, `responseTimeMs` ist der Mittelwert der Minute, und zwei zusätzliche Felder nennen die Standorte dahinter: `totalLocations` und `failedLocations`. - `15min` und `1day`: ein 15-Minuten- bzw. Tagesintervall, verwendet, sobald das Minutenaggregat nicht mehr zurückreicht (ab 7 Tagen `15min`, ab 30 Tagen `1day`). Dieselben Felder sind `null` wie bei `1min`, die Zähler nennen aber einzelne Standort-Checks statt Standorte: `totalChecks` und `failedChecks`. - Server- und DNS-Monitore (TCP, SSH, FTP, SMTP, IMAP/POP, ICMP, DNS) haben keine 15-Minuten-Stufe: `1min` reicht 30 Tage zurück, ältere Vorfälle bekommen `1day`-Einträge mit `totalChecks` und `failedChecks`. Die `id` eines aggregierten Eintrags ist synthetisch (`-`, z. B. `1min-2026-09-01T10:00:00.000Z`) und lässt sich nicht als Prüfung nachschlagen. Die vier Listen werden unabhängig voneinander aufgelöst; ein Vorfall, der eine Grenze überspannt, kann Auflösungen mischen. ## Antwort (Auszug) ```json { "incident": { "id": 123, "websiteId": 101, "type": "downtime", "status": "open", "startedAt": "2026-02-26T12:10:00.000Z", "resolvedAt": null, "statusCode": null, "errorMessage": "Timeout", "responseTimeMs": null, "falseAlarmAt": null, "falseAlarmReason": null, "publicTitle": null, "publicStatus": "open", "publicResolvedAt": null }, "timeline": { "outageStartedAt": "2026-02-26T12:08:00.000Z", "outageStartedCheck": { "id": "chk_01H...", "checkedAt": "2026-02-26T12:08:00.000Z", "status": "failure", "statusCode": 503, "errorMessage": "Timeout", "responseTimeMs": null, "location": { "id": 7, "code": "de-nbg", "name": "Nuremberg (DE)" }, "resolution": "raw" }, "confirmationAt": "2026-02-26T12:10:00.000Z", "failedChecks": [ { "id": "1min-2026-02-26T12:09:00.000Z", "checkedAt": "2026-02-26T12:09:00.000Z", "status": "failure", "statusCode": null, "errorMessage": null, "responseTimeMs": 246, "location": null, "resolution": "1min", "totalLocations": 3, "failedLocations": 2 } ], "failedChecksTotal": 2, "alertEvents": [ { "id": 987, "sentAt": "2026-02-26T12:11:00.000Z", "type": "email", "status": "sent", "channelName": "Ops Email", "errorMessage": null } ], "recoveryChecks": [], "recoveryChecksTotal": 0, "outageChecks": [], "outageChecksTotal": 0 }, "evidenceCheck": { "id": "chk_01H...", "checkedAt": "2026-02-26T12:08:00.000Z", "diagnostics": null, "hasScreenshot": false, "screenshotUrl": null } } ``` ## Fehlalarm-Markierung Ein Vorfall kann als Feh…
### Ausfälle auflisten
URL: https://docs.uptimeify.io/de/api/monitoring/get-incident-history
Description: Gibt die Incident-Historie einer Website zurück (letzte 100), inklusive berechneter Dauer.
Summary: `GET /api/websites/:websitePublicId/incident-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `websitePublicId` (Pfad, erforderlich): Öffentliche UUID der Website. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `open`, `acknowledged` oder `resolved`. - `type` (string, optional): `downtime`, `http_status`, `ssl_expiry`, `ssl_critical`, `ssl_warning`, `response_time`, `dnsbl`, `domain_expiry_warning`, `critical` oder `inconclusive`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `startedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/websites/11111111-1111-4111-8111-111111111111/incident-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 123, "publicId": "55555555-5555-4555-8555-555555555555", "type": "downtime", "status": "resolved", "startedAt": "2026-02-26T12:10:00.000Z", "endedAt": "2026-02-26T12:12:30.000Z", "durationMs": 150000, "statusCode": null, "errorMessage": "connect ETIMEDOUT", "details": "connect ETIMEDOUT", "isOngoing": false } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. **Abgelöstes Feld:** `duration` (Text, z. B. `2m 30s`) wird bis zum Entfall am 18.01.2027 weiter neben `durationMs` geliefert. Lies `durationMs`. `status` ist `open`, `acknowledged` oder `resolved`. Laufende Vorfälle haben ein `null` bei `endedAt` und `isOngoing: true`. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 Website public ID (UUID) required` wenn `:websitePublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` oder `type` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### Monitoring-Daten abrufen
URL: https://docs.uptimeify.io/de/api/monitoring/get-monitoring-data
Description: Gibt aggregierte Timeseries-Daten für Charts zurück (Antwortzeiten, Status-Tracker, Uptime-Prozent etc.).
Summary: `GET /api/websites/:websitePublicId/monitoring-data?range=day|week|month|year` ## Query Parameter - `range` (optional): `day` | `week` | `month` | `year` (Standard: `day`) - `maxPoints` (optional): begrenzt die Anzahl an Datenpunkten (Standard: `300`, max: `2000`). Hinweis: Die API kann Datenpunkte downsamplen, um die Response klein zu halten. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/websites/6bfec6f6-245a-47ce-843b-157d97d56f88/monitoring-data?range=week" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "responseTimeData": [ { "timestamp": "2026-02-26T12:00:00.000Z", "responseTime": 123, "status": "success", "success": true, "timingDns": 12, "timingTcp": 20, "timingTls": 30, "timingTtfb": 50, "timingTransfer": 11 } ], "statusData": [ { "date": "26.02", "status": "online" } ], "uptimePercentage": "99.95", "checkSuccessRatePercentage": "99.80", "totalChecks": 100, "successfulChecks": 99 } ``` ## Aufbewahrung Die Reihe kommt aus der feinsten Aggregatstufe, die den angefragten Zeitraum noch abdeckt: Minutenwerte für die letzten 7 Tage, 15-Minuten-Werte bis 30 Tage zurück, danach Tageswerte. In den gröberen Stufen kommen `timingDns`, `timingTcp`, `timingTls`, `timingTtfb` und `timingTransfer` als `0` (nicht gemessen), und `successRate` ist der Anteil erfolgreicher Standort-Prüfungen statt des Minuten-Quorums. ## Häufige Fehler - `400 Website public ID (UUID) required` wenn `:websitePublicId` ungültig ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Website hast - `500 Failed to fetch monitoring data` bei Serverfehlern
### Metriken abrufen
URL: https://docs.uptimeify.io/de/api/monitoring/get-uptime-stats
Description: Gibt Uptime-Prozentsätze und durchschnittliche Antwortzeiten für Tag/Monat/Jahr zurück.
Summary: `GET /api/websites/:websitePublicId/uptime-stats` ## Pfadparameter - `websitePublicId` (empfohlen): Public-ID der Website als UUID - Legacy-Kompatibilität: numerische Website-IDs werden weiterhin akzeptiert ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/websites/6bfec6f6-245a-47ce-843b-157d97d56f88/uptime-stats" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "day": "100.00", "month": "99.95", "year": "99.90", "dayAvgResponse": 125, "monthAvgResponse": 118, "yearAvgResponse": 120, "blockedRatio": { "day": 0, "month": 0.02, "year": 0 } } ``` ## Antwortfelder - `day`, `month`, `year`: Uptime in Prozent als String mit zwei Nachkommastellen, oder `null`, wenn im Zeitraum nichts messbar war. - `blockedRatio`: Anteil des Zeitraums, in dem wir nicht messen konnten, zwischen `0` und `1`, `null` bei leerem Zeitraum. Der Bot-Schutz einer Seite kann unseren Check mit einer Challenge statt der Seite beantworten; diese Zeit fällt aus der Uptime-Rechnung heraus, zählt also weder als erreichbar noch als Ausfall, und `day`/`month`/`year` stehen für die übrige, gemessene Zeit. ## Häufige Fehler - `400 Invalid Website identifier` wenn `:websitePublicId` weder eine gültige UUID noch eine Legacy-ID ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Website hast
### Ausfälle auflisten (Organisation)
URL: https://docs.uptimeify.io/de/api/monitoring/list-incidents
Description: Listet Incidents für eine Organisation auf. Die Daten sind durch deine Session/Permissions eingeschränkt.
Summary: `GET /api/incidents?organizationId=:organizationId` Readonly-User sehen nur Incidents für Kunden, denen sie zugewiesen sind. ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Query Parameter - `organizationId` (optional): Wenn nicht gesetzt, wird die `organizationId` aus deiner Session verwendet. - `source` (optional): Filtert nach Incident-Quelle. `manual` liefert von einem Admin erstellte Statusseiten-Ankündigungen; `monitor` liefert automatisch von den Monitoring-Workern erzeugte Incidents. Jeder andere Wert wird ignoriert und alle Quellen werden zurückgegeben. Nützlich, da manuelle Incidents deutlich älter sein können als die neuesten Monitor-Incidents und sonst außerhalb des `limit`-Fensters liegen würden. - `limit` (optional, Standard: `100`, max: `500`): Maximale Anzahl an Incidents. - `offset` (optional, Standard: `0`): Pagination-Offset. - `includeTotal` (optional, Standard: `0`): Wenn `1` (oder `true`), enthält die Response zusätzlich `total`, `limit` und `offset`. - `onStatusPage` (optional): `true` oder `1` liefert nur Vorfälle, die eine Statusseite als Vorfall zeigt: manuelle und solche, die mit einer Statusseite verknüpft sind. Andere Werte als `true`, `false`, `1`, `0` antworten `400`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/incidents?organizationId=1" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Pagination: ```bash curl -X GET "$BASE_URL/api/incidents?organizationId=1&limit=100&offset=0" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Nur manuell erstellte (Statusseiten-)Incidents auflisten: ```bash curl -X GET "$BASE_URL/api/incidents?organizationId=1&source=manual" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Auszug) ```json [ { "id": 123, "websiteId": 101, "status": "open", "severity": "downtime", "startedAt": "2026-02-26T12:10:00.000Z", "resolvedAt": null, "lastNotifiedAt": "2026-02-26T12:11:00.000Z", "errorMessage": "Timeout", "statusCode": null, "responseTimeMs": null, "website": { "id": 101, "name": "Main Marketing Site", "url": "https://deinkunde.com", "status": "active" }, "customer": { "id": 12, "email": "ops@deinkunde.com", "company": "Acme Corp" } } ] ``` Wenn `includeTotal=1`, ändert sich das Response-Format zu: ```json { "incidents": [], "total": 1234, "limit": 100, "offset": 0 } ``` **`statusPages`** (seit 28. Oktober 2026): jeder Eintrag trägt `[{ "id", "publicId", "name" }]`, die Statusseiten, auf denen der Vorfall als Vorfall steht: verknüpfte Seiten und bei einem manuellen Vorfall mit Kunde die Seiten dieses Kunden. Leer für einen nicht verknüpften Monitor-Vorfall. **`publicTitle`, `publicStatus`, `publicResolvedAt`** (seit 28. Oktober 2026): der Vorfall, wie Statusseiten ihn zeigen. `publicTitle` ist der für die Seiten gesetzte Titel oder `null` (die Seiten zeigen dann `title`). `publicStatus` ist `open` oder `resolved`; bei einem Monitor-Vorfall setzen ihn Timeline-Updates unabhängig von `status`, sonst folgt er `status`. `publicResolvedAt` ist der Zeitpunkt, zu dem er auf den Seiten behoben wurde. **Abgelöste Felder:** `started_at`, `resolved_at`, `last_notified_at`, `error_message`, `status_code` und `response_time_ms` werden bis zum Entfall am 18.01.2027 weiter neben `startedAt`, `resolvedAt`, `lastNotifiedAt`, `errorMessage`, `statusCode` und `responseTimeMs` geliefert, mit und ohne `includeTotal`. Lies die camelCase-Felder. ### Manuelle Vorfälle ohne Kunden Seit dem 27. Oktober 2026 kann ein manueller Vorfall ohne Kunden angelegt werden, nur mit Statusseiten verknüpft. Die Liste enthält ihn für organisationsweite Rollen und Tokens mit `customer: null`; ein kundengebundenes Login oder Token sieht ihn nicht. ## Häufige Fehler - `400 Organization ID is required` wenn keine Organisation ermittelt werden kann - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du…
### Vorfall-Update posten
URL: https://docs.uptimeify.io/de/api/monitoring/post-incident-update
Description: Veröffentlicht ein Update in der Timeline eines manuellen oder Monitor-Vorfalls und benachrichtigt die Abonnenten der Statusseiten.
Summary: `POST /api/incidents/:id/updates` Hängt ein Update an die Timeline eines Vorfalls: Der Text erscheint auf jeder Statusseite, die den Vorfall zeigt, und geht an die Abonnenten dieser Seiten. Dasselbe tun „Update posten“ im Statusseiten-Modul und das MCP-Tool `post_incident_update`. Was der `status` des Updates ändert, hängt vom Vorfall ab (seit 28. Oktober 2026): - **Manueller Vorfall:** Der Vorfall folgt dem Update. `resolved` behebt ihn (`status` und `resolvedAt`) und verschickt die Entwarnung; jeder andere Status auf einem behobenen Vorfall öffnet ihn wieder und benachrichtigt die Abonnenten erneut. - **Monitor-Vorfall:** Nur der öffentliche Status ändert sich (`publicStatus`, `publicResolvedAt`). `resolved` behebt ihn auf den Statusseiten und verschickt dort die Entwarnung; jeder andere Status öffnet ihn dort wieder. Der Monitoring-Vorfall bleibt, wie er ist: Sein `status` und `resolvedAt` folgen den Checks des Monitors, nicht dem Update. Solange der Vorfall auf den Seiten noch offen ist, verschickt ein Monitor, der sich erholt, keine Entwarnung. Entwarnung und Wiedereröffnungs-Hinweis gehen nur bei einem echten Wechsel des öffentlichen Status raus. Ein zweites `resolved`-Update auf einem Vorfall, der auf den Seiten schon behoben ist, wird gepostet, verschickt aber keine zweite Entwarnung. **Wiederholungen:** Ein Aufruf mit demselben `status` und `body` wie ein Update, das der Vorfall schon hat, legt nichts Neues an. Er antwortet mit `200 OK`, dem vorhandenen Update und `deduplicated: true` und verschickt nichts erneut. Einen Aufruf, dessen Antwort nicht ankam, können Sie also gefahrlos wiederholen. Um stattdessen internen Status, Titel oder Verknüpfungen zu ändern, nutzen Sie [Vorfall aktualisieren](/de/api/monitoring/update-incident). [Vorfall-Details abrufen](/de/api/monitoring/get-incident-details) liefert `publicStatus` und `publicResolvedAt`. ## Authentifizierung Im Kundenbereich des Vorfalls. Ist der Vorfall mit Statusseiten verknüpft, muss jede verknüpfte Seite es erlauben: organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor`; kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens brauchen `self_service`-Seiten oder `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein Vorfall ohne verknüpfte Seite folgt weiter der Rolle: `admin` oder `editor`. Ein Vorfall ohne Kunden braucht eine organisationsweite Rolle oder einen solchen Token; für jede andere Organisation antwortet er mit `404 incidentNotFound`. Organisationsweites `readonly` bekommt `403 forbidden`. - Header: `Authorization: Bearer ` ## Pfadparameter - `id` (Pflicht): numerische id oder `publicId` (UUID). ## Anfrage (Request Body) | Feld | Typ | Pflicht | Beschreibung | |-------|------|---------|-------------| | `status` | string | ja | `investigating`, `identified`, `monitoring` oder `resolved`. | | `body` | string | ja | Der Text des Updates, 1 bis 5.000 Zeichen nach dem Kürzen von Leerzeichen am Rand. | | `notifySubscribers` | boolean | nein | Standard `true`. `false` hält das Update in Feed und Historie der Seiten fest, ohne E-Mail- oder Webhook-Benachrichtigung; das gilt auch für die Entwarnung oder den Wiedereröffnungs-Hinweis, den es auslöst. | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/incidents/5121/updates" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "status": "identified", "body": "Ursache ist ein fehlerhafter Datenbankknoten. Wir schalten auf die Replik um." }' ``` ## Antwort (Response) `201 Created` für ein neues Update, `200 OK` für eine Wiederholung. ```json { "update": { "id": 8812, "publicId": "3f6c2a8e-6b1d-4c39-9a57-2d0e5b7c1f44", "status": "identified", "body": "Ursache ist ein fehlerhafter Datenbankknoten. Wir schalten auf die Replik um.", "createdAt": "2026-10-28T09:41:12.000Z" }, "deduplicated": false } ``` | Feld | Beschreibung | |-------|-------------| | `update` | Das gepostete Updat…
### Postmortem veröffentlichen
URL: https://docs.uptimeify.io/de/api/monitoring/publish-postmortem
Description: Veröffentlicht die Nachbetrachtung eines behobenen Vorfalls auf seinen Statusseiten, wahlweise mit einer Benachrichtigung an die Abonnenten.
Summary: `POST /api/incidents/:id/postmortem/publish` Veröffentlicht die Nachbetrachtung eines Vorfalls. Sie erscheint dann unter dem Vorfall auf jeder Statusseite, die ihn zeigt, in jedem Layout als aufklappbarer Abschnitt. Dasselbe tun „Veröffentlichen“ in der Karte „Nachbetrachtung“ des Statusseiten-Moduls und das MCP-Tool `publish_postmortem`. - Nur ein **behobener** Vorfall bekommt eine veröffentlichte Nachbetrachtung: behoben auf den Statusseiten (`publicStatus`, siehe [Ausfall-Details abrufen](/de/api/monitoring/get-incident-details)). Sonst antwortet der Aufruf mit `409 postmortemIncidentNotResolved`. - Mit `body` wird der Text zuerst gespeichert, im selben Aufruf. Ohne ihn wird der mit [Postmortem speichern](/de/api/monitoring/save-postmortem) gespeicherte Text veröffentlicht; ohne gespeicherten Text antwortet der Aufruf mit `404 postmortemNotFound`. - Mit `notifySubscribers: true` bekommen die Abonnenten dieser Seiten eine Benachrichtigung `postmortem_published` (E-Mail, Webhook, Slack, Teams), nach der Abo-Verzögerung der Seite. Wird die Nachbetrachtung vorher zurückgenommen, geht nichts raus. - **Wiederholungen:** Eine schon veröffentlichte Nachbetrachtung bleibt veröffentlicht und antwortet mit `200 OK`. Ein `body` ersetzt ihren Text; eine zweite Benachrichtigung gibt es nicht. ## Authentifizierung Im Kundenbereich des Vorfalls. Ist der Vorfall mit Statusseiten verknüpft, muss jede verknüpfte Seite es erlauben: organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor`; kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens brauchen `self_service`-Seiten oder `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein Vorfall ohne verknüpfte Seite folgt weiter der Rolle: `admin` oder `editor`. Ein Vorfall ohne Kunde braucht eine organisationsweite Rolle oder ein solches Token; für jede andere Organisation antwortet er mit `404 incidentNotFound`. Organisationsweites `readonly` bekommt `403 forbidden`. - Header: `Authorization: Bearer ` ## Pfadparameter - `id` (erforderlich): numerische ID oder `publicId` (UUID) des Vorfalls. ## Request-Body Optional; ein leerer Body veröffentlicht den gespeicherten Text ohne Benachrichtigung. | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `body` | string | nein | Markdown, 1 bis 50.000 Zeichen. Wird vor dem Veröffentlichen gespeichert. | | `notifySubscribers` | boolean | nein | Vorgabe `false`. `true` benachrichtigt die Abonnenten der Seiten einmal. | Unbekannte Felder werden mit `400 invalidRequestBody` abgewiesen. ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/incidents/5121/postmortem/publish" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "notifySubscribers": true }' ``` ## Antwort `200 OK` ```json { "incidentId": 5121, "incidentPublicId": "8a3c1f6e-2b7d-4e59-9c1a-5d2e7f0b4c33", "body": "## Ursache\nEinem Datenbankknoten ging der Speicherplatz aus.", "publishedAt": "2026-10-28T14:05:40.000Z", "updatedAt": "2026-10-28T14:02:11.000Z" } ``` Auf der öffentlichen Statusseite ([Öffentliche Statusseite abfragen](/de/api/status-pages/get-public-status-page)) trägt der Vorfall danach `postmortem: { body, publishedAt }`. Zurücknehmen mit [Postmortem zurücknehmen](/de/api/monitoring/unpublish-postmortem). ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`), wenn `body` leer oder länger als 50.000 Zeichen ist, ein Feld den falschen Typ hat oder ein unbekanntes Feld mitkommt - `401 Unauthorized`, wenn nicht angemeldet - `403 Forbidden` (`forbidden`), wenn deine Rolle oder dein Kundenbereich es nicht erlaubt - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und eine beteiligte Statusseite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `404 Not Found` (`incidentNotFound`), wenn der Vorfall in deiner Organisation nicht existiert -…
### Postmortem speichern
URL: https://docs.uptimeify.io/de/api/monitoring/save-postmortem
Description: Speichert die öffentliche Nachbetrachtung (Markdown) eines Vorfalls als Entwurf oder ersetzt den Text einer veröffentlichten.
Summary: `PUT /api/incidents/:id/postmortem` Speichert die öffentliche Nachbetrachtung (Postmortem) eines Vorfalls: was passiert ist, warum, und was geändert wurde, in Markdown. Wie bei Atlassian Statuspage erscheint sie unter dem Vorfall auf jeder Statusseite, die den Vorfall zeigt, sobald sie mit [Postmortem veröffentlichen](/de/api/monitoring/publish-postmortem) veröffentlicht ist. Bis dahin ist sie ein Entwurf, nur im Statusseiten-Modul sichtbar. Ein Vorfall hat höchstens eine Nachbetrachtung; dieser Aufruf legt sie an oder ersetzt ihren Text. Bei einer veröffentlichten Nachbetrachtung ist der neue Text sofort sichtbar, sie bleibt veröffentlicht. Speichern verschickt keine Benachrichtigung. Gespeichert werden kann jederzeit, veröffentlicht nur bei einem behobenen Vorfall. Die Statusseiten zeichnen das Markdown selbst und nie als rohes HTML: Überschriften, Absätze, Listen, **fett**, *kursiv*, `Code` und Links auf `http(s)`-Adressen. Alles andere, auch HTML-Tags, erscheint als einfacher Text. ## Authentifizierung Im Kundenbereich des Vorfalls. Ist der Vorfall mit Statusseiten verknüpft, muss jede verknüpfte Seite es erlauben: organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor`; kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens brauchen `self_service`-Seiten oder `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein Vorfall ohne verknüpfte Seite folgt weiter der Rolle: `admin` oder `editor`. Ein Vorfall ohne Kunde braucht eine organisationsweite Rolle oder ein solches Token; für jede andere Organisation antwortet er mit `404 incidentNotFound`. Organisationsweites `readonly` bekommt `403 forbidden`. - Header: `Authorization: Bearer ` ## Pfadparameter - `id` (erforderlich): numerische ID oder `publicId` (UUID) des Vorfalls. ## Request-Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `body` | string | ja | Markdown, nach dem Trimmen 1 bis 50.000 Zeichen. | Unbekannte Felder werden mit `400 invalidRequestBody` abgewiesen. ## Beispiel (cURL) ```bash curl -X PUT "$BASE_URL/api/incidents/5121/postmortem" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "body": "## Ursache\nEinem Datenbankknoten ging der Speicherplatz aus.\n\n## Maßnahmen\n- Alarm ab 80 % Plattenbelegung" }' ``` ## Antwort `200 OK` ```json { "incidentId": 5121, "incidentPublicId": "8a3c1f6e-2b7d-4e59-9c1a-5d2e7f0b4c33", "body": "## Ursache\nEinem Datenbankknoten ging der Speicherplatz aus.\n\n## Maßnahmen\n- Alarm ab 80 % Plattenbelegung", "publishedAt": null, "updatedAt": "2026-10-28T14:02:11.000Z" } ``` | Feld | Beschreibung | |------|--------------| | `publishedAt` | `null` = Entwurf; sonst der Zeitpunkt der Veröffentlichung (ISO 8601). | | `updatedAt` | Wann der Text zuletzt gespeichert wurde. | [Ausfall-Details abrufen](/de/api/monitoring/get-incident-details) liefert dieselben Felder als `postmortem`. ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`), wenn `body` fehlt, leer oder länger als 50.000 Zeichen ist oder ein unbekanntes Feld mitkommt - `400 Bad Request` (`incidentNoCustomer`), wenn der Vorfall weder einen Kunden noch eine Statusseite hat - `401 Unauthorized`, wenn nicht angemeldet - `403 Forbidden` (`forbidden`), wenn deine Rolle oder dein Kundenbereich es nicht erlaubt - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und eine beteiligte Statusseite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `404 Not Found` (`incidentNotFound`), wenn der Vorfall in deiner Organisation nicht existiert
### Postmortem zurücknehmen
URL: https://docs.uptimeify.io/de/api/monitoring/unpublish-postmortem
Description: Nimmt eine veröffentlichte Nachbetrachtung von den Statusseiten; der Text bleibt als Entwurf.
Summary: `DELETE /api/incidents/:id/postmortem/publish` Nimmt die Nachbetrachtung eines Vorfalls von seinen Statusseiten. Der Text bleibt als Entwurf erhalten und lässt sich mit [Postmortem veröffentlichen](/de/api/monitoring/publish-postmortem) wieder veröffentlichen. Eine noch nicht zugestellte Benachrichtigung `postmortem_published` (Abo-Verzögerung) geht nicht mehr raus. ## Authentifizierung Im Kundenbereich des Vorfalls. Ist der Vorfall mit Statusseiten verknüpft, muss jede verknüpfte Seite es erlauben: organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor`; kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens brauchen `self_service`-Seiten oder `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein Vorfall ohne verknüpfte Seite folgt weiter der Rolle: `admin` oder `editor`. Organisationsweites `readonly` bekommt `403 forbidden`. - Header: `Authorization: Bearer ` ## Pfadparameter - `id` (erforderlich): numerische ID oder `publicId` (UUID) des Vorfalls. ## Beispiel (cURL) ```bash curl -X DELETE "$BASE_URL/api/incidents/5121/postmortem/publish" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `204 No Content`, ohne Body. ## Häufige Fehler - `401 Unauthorized`, wenn nicht angemeldet - `403 Forbidden` (`forbidden`), wenn deine Rolle oder dein Kundenbereich es nicht erlaubt - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und eine beteiligte Statusseite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `404 Not Found` (`incidentNotFound`), wenn der Vorfall in deiner Organisation nicht existiert - `404 Not Found` (`postmortemNotFound`), wenn der Vorfall keine veröffentlichte Nachbetrachtung hat (auch beim zweiten Aufruf)
### Vorfall aktualisieren
URL: https://docs.uptimeify.io/de/api/monitoring/update-incident
Description: Ändert Überschrift, Schweregrad, Status und die verknüpften Statusseiten und Komponenten eines Vorfalls.
Summary: `PATCH /api/incidents/:id` Ändert einen manuellen oder Monitor-Vorfall: Überschrift, Zusammenfassung, Schweregrad, Status und seit dem 27. Oktober 2026 die Statusseiten und Komponenten, mit denen er verknüpft ist. Weggelassene Felder bleiben unverändert. Beheben (`status: resolved`) oder Wiedereröffnen benachrichtigt die Abonnenten jeder Seite, auf der der Vorfall erscheint, auch der verknüpften. Seit dem 28. Oktober 2026 benachrichtigt das Verknüpfen eines offenen Vorfalls (auch eines Monitor-Vorfalls) mit einer Seite, auf der er noch nicht stand, die Abonnenten dieser Seite einmal, mit dem Text des letzten Updates; Seiten, auf denen er schon stand, werden nicht erneut benachrichtigt. Seit dem 28. Oktober 2026 hat ein Vorfall auf Statusseiten einen eigenen öffentlichen Titel und einen eigenen öffentlichen Status, getrennt vom Monitoring-Vorfall (wie bei Atlassian Statuspage). `publicTitle` setzt den Titel, den die Seiten zeigen; der interne `title` bleibt. Bei einem Monitor-Vorfall setzt ein Timeline-Update ([Vorfall-Update posten](/de/api/monitoring/post-incident-update), „Update posten“ im Statusseiten-Modul, `post_incident_update` über MCP) nur den öffentlichen Status: `resolved` behebt ihn auf den Seiten, jeder andere Status öffnet ihn dort wieder, während der Monitoring-Vorfall seinen eigenen `status` und `resolvedAt` behält. Erholt sich der Monitor, geht deshalb keine Entwarnung raus, solange der Vorfall auf den Seiten noch offen ist. `status` an diesem Endpunkt bleibt der interne Status; hat ein Monitor-Vorfall einen eigenen öffentlichen Status, benachrichtigt eine Änderung von `status` hier niemanden. [Vorfall-Details abrufen](/de/api/monitoring/get-incident-details) und [Ausfälle auflisten](/de/api/monitoring/list-incidents) liefern `publicTitle`, `publicStatus` und `publicResolvedAt`. ## Authentifizierung Im Kundenbereich des Vorfalls. Ist der Vorfall mit Statusseiten verknüpft, muss jede verknüpfte Seite es erlauben: organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor`; kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens brauchen `self_service`-Seiten oder `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein Vorfall ohne verknüpfte Seite folgt weiter der Rolle: `admin` oder `editor`. Neu genannte Seiten in `statusPageIds` werden genauso geprüft. Ein Vorfall ohne Kunden braucht eine organisationsweite Rolle oder einen solchen Token; für jede andere Organisation antwortet er mit `404 incidentNotFound`. - Header: `Authorization: Bearer ` ## Pfadparameter - `id` (Pflicht): numerische id oder `publicId` (UUID). ## Anfrage (Request Body) | Feld | Typ | Beschreibung | |-------|------|-------------| | `status` | string | `open`, `acknowledged` oder `resolved`. | | `severity` | string | `minor`, `major`, `critical` oder `maintenance`. | | `title` | string | 1 bis 200 Zeichen. | | `publicTitle` | string oder null | Titel auf Statusseiten, 1 bis 200 Zeichen; `null` zeigt wieder `title`. | | `summary` | string oder null | Bis zu 5.000 Zeichen, `null` leert sie. | | `statusPageIds` | Array | Ersetzt die verknüpften Seiten (id oder publicId). Gleiche Regeln wie bei [Manuellen Vorfall anlegen](/de/api/monitoring/create-manual-incident). `[]` entfernt jede Verknüpfung, was ein Vorfall ohne Kunden nicht kann (`400 incidentTargetRequired`). | | `componentIds` | Array | Ersetzt die verknüpften Komponenten, zusammen mit `statusPageIds`. | | `impact` | string | Mit `statusPageIds`: die Auswirkung der neuen Verknüpfungen. Allein: setzt die Auswirkung aller bestehenden Verknüpfungen. | | `componentImpacts` | array | Zusammen mit `componentIds`: Auswirkung einzelner Komponenten statt `impact`, wie beim Anlegen. Ohne `componentIds` antwortet es `400 invalidRequestBody`. | | `notifySubscribers` | boolean | Standard `true`. `false` hält Beheben, Wiedereröffnen oder neu verknüpfte Seiten fest, ohne E-Mail- oder Webhook-Benachrichtigung…
### Monitore
URL: https://docs.uptimeify.io/de/api/monitors
Description: Verwalte Protokoll-Monitore (ICMP, SMTP, SSH, TCP, FTP, IMAP/POP).
Summary: Detail-/Update-/Delete-/Check-Endpunkte für Protokoll-Monitore verwenden monitor-spezifische `publicId`-UUIDs im Pfad. ## Ressourcen - [ICMP Monitore](/de/api/monitors/icmp-monitors) - [SMTP Monitore](/de/api/monitors/smtp-monitors) - [SSH Monitore](/de/api/monitors/ssh-monitors) - [TCP Monitore](/de/api/monitors/tcp-monitors) - [FTP Monitore](/de/api/monitors/ftp-monitors) - [IMAP/POP Monitore](/de/api/monitors/imap-pop-monitors) - [DNS Monitore](/de/api/monitors/dns-monitors) - [DNSBL-Überwachung (Kunden-IPs)](/de/api/monitors/dnsbl-monitoring) - [Domain-Ablauf-Überwachung (Kunden-Domains)](/de/api/monitors/domain-expiry-monitoring)
### DNS Monitore
URL: https://docs.uptimeify.io/de/api/monitors/dns-monitors
Description: Verwalte DNS-Monitore, die DNS-Auflösung/Records für einen Hostnamen prüfen.
Summary: Pfadbasierte DNS-Monitor-Endpunkte verwenden `dnsMonitorPublicId`-UUIDs. ## Endpunkte - [DNS Monitore auflisten](/de/api/monitors/dns-monitors/list-dns-monitors) - [DNS Monitor erstellen](/de/api/monitors/dns-monitors/create-dns-monitor) - [DNS Monitor abrufen](/de/api/monitors/dns-monitors/get-dns-monitor) - [DNS Monitor aktualisieren](/de/api/monitors/dns-monitors/update-dns-monitor) - [DNS Monitor löschen](/de/api/monitors/dns-monitors/delete-dns-monitor) - [DNS Check triggern](/de/api/monitors/dns-monitors/trigger-check-dns-monitor) - [DNS Monitor Check-Historie abrufen](/de/api/monitors/dns-monitors/get-dns-monitor-check-history)
### DNS Monitor erstellen
URL: https://docs.uptimeify.io/de/api/monitors/dns-monitors/create-dns-monitor
Description: Erstellt einen neuen DNS-Monitor für einen Kunden.
Summary: `POST /api/dns-monitors` ## Anfrage (Request Body) ```json { "customerId": "6bfec6f6-245a-47ce-843b-157d97d56f88", "name": "Example DNS", "hostname": "deinkunde.com", "status": "active", "checkInterval": 30, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE", "FR"], "dnsConfig": { "rrtypes": ["A", "AAAA"], "matchMode": "exact", "expectedValues": { "A": ["93.184.216.34"], "AAAA": ["2606:2800:220:1:248:1893:25c8:1946"] }, "triggerOn": { "resolveError": true, "mismatch": true } } } ``` Hinweise: - `customerId`, `name`, `hostname`, `dnsConfig.rrtypes`, `dnsConfig.matchMode` und `dnsConfig.expectedValues` sind erforderlich. - `customerId` akzeptiert entweder die interne numerische ID oder die `publicId`-UUID des Kunden. - Global Supporter dürfen keine DNS-Monitore erstellen. Ein Readonly- oder kundengebundener Zugang darf innerhalb seines eigenen Kundenbereichs einen anlegen; der Monitor wird dann auf `self_service` gezwungen und mit `selfServiceNotAllowed` oder `selfServiceQuotaReached` abgelehnt, wenn das Paket es nicht erlaubt oder das Kontingent erschöpft ist. - `hostname` muss ein Hostname sein (kein Protokoll, kein Pfad). - `dnsConfig.expectedValues` muss für jeden RR-Type aus `dnsConfig.rrtypes` mindestens einen erwarteten Wert enthalten. - `allowedCheckCountryCodes` (string[], optional) - Beschränkt die Checks auf diese ISO-3166-1-alpha-2-Ländercodes. - Jeder Eintrag muss aus genau zwei Buchstaben bestehen; die Einträge werden vor dem Speichern getrimmt, in Grossbuchstaben gewandelt und dedupliziert. - Ohne den Schlüssel, mit `null` oder mit leerem Array fällt die Einschränkung des Monitors weg; eine Einschränkung am Kunden selbst gilt weiter. - Die Zweibuchstaben-Regel prüft nur die Form: ein Ländercode ohne aktiven Prüfstandort wird angenommen, und der Monitor läuft danach nie eine Prüfung. ### Duplikate Hat dieser Kunde schon einen Monitor mit derselbe `hostname` (Gross- und Kleinschreibung und ein Punkt am Ende zählen nicht) und dieselben Record-Typen in `dnsConfig.rrtypes`, wird die Anfrage mit `409` und `data.code` `monitorAlreadyExists` abgewiesen. `data.existingId` und `data.existingPublicId` nennen den vorhandenen Monitor. Mit `"allowDuplicate": true` wird der zweite Monitor trotzdem angelegt (zum Beispiel mit anderem Intervall oder anderen Alarmwegen). - `allowDuplicate` (boolean, optional, Standard `false`): Monitor auch als Duplikat anlegen. Wird nicht gespeichert. ```json { "statusCode": 409, "statusMessage": "A monitor for this target already exists for this customer. Send allowDuplicate: true to create it anyway.", "data": { "code": "monitorAlreadyExists", "existingId": 300, "existingPublicId": "44444444-4444-4444-8444-444444444444" } } ``` ### Grenze je Ziel-Host Eine Organisation kann höchstens 100 Monitore auf denselben Ziel-Host haben, gezählt über alle Monitortypen zusammen (Websites mit HTTP, Keyword, DNS-Website und Playwright mit echter URL, dazu TCP, ICMP, DNS, SSH, SMTP, FTP und IMAP/POP). Die Grenze schützt davor, dass die Checkflotte als Lastgenerator gegen fremde Hosts missbraucht wird. Verglichen wird der exakte Hostname: Gross- und Kleinschreibung, Port, Pfad und ein Punkt am Ende zählen nicht, `www.example.com` und `example.com` sind aber verschiedene Hosts. Ist die Grenze erreicht, wird die Anfrage mit `403` und `data.code` `targetHostMonitorLimitReached` abgewiesen. `data.host` nennt den normalisierten Host, `data.limit` die Grenze. `"allowDuplicate": true` hebt die Grenze nicht auf. Dieselbe Prüfung läuft, wenn ein PATCH den `hostname` ändert. Ein PATCH ohne Hostwechsel geht immer, vorhandene Monitore über der Grenze bleiben bestehen. Brauchst du eine höhere Grenze, wende dich an den Support. Unabhängig von deiner Organisation dürfen über alle Uptimeify-Kunden hinweg höchstens 300 Monitore auf denselben Host zeigen. Darüber wird die Anfrage mit `403` und `data.code` `targetHostPlatformLimitReached` abgewiesen; `data.host` und `data.limit` sind wie oben gesetzt, die Meldung verrät nicht…
### DNS Monitor löschen
URL: https://docs.uptimeify.io/de/api/monitors/dns-monitors/delete-dns-monitor
Description: Löscht einen DNS-Monitor.
Summary: `DELETE /api/dns-monitors/:dnsMonitorPublicId` ## Antwort (Response) Gibt `204 No Content` zurück. Siehe [Fehlerliste](/de/api/error-codes-and-known-pitfalls) für Fehlerantworten. ## Berechtigungen Für die Rolle `readonly` gesperrt. Ein Nur-Lese-Zugang löscht keinen Monitor, gleich welcher Besitzklasse, und ein von ihm ausgestellter API-Token ebenso wenig: Ein Token erbt die Rolle seines Erstellers. Das Bearbeiten eines Monitors mit `self_service` bleibt dieser Rolle erlaubt. Kunden-gescopte Aufrufer bindet zusätzlich die Besitzklasse: Ein `managed`-Monitor wird mit `managed_by_organization` abgelehnt, solange der Kunde kein `canEditManaged` trägt.
### DNS Monitor abrufen
URL: https://docs.uptimeify.io/de/api/monitors/dns-monitors/get-dns-monitor
Description: Gibt einen einzelnen DNS-Monitor zurück.
Summary: `GET /api/dns-monitors/:dnsMonitorPublicId` Die Response enthält nur den DNS-Monitor selbst und bettet keinen vollständigen Kunden-Datensatz ein. ## Beispiel-Response ```json { "id": 1, "publicId": "3c741f27-7015-4202-93ea-0f97cc6bc769", "organizationId": 2, "customerId": 2, "customerName": "Zaskoku & Haupt GbR", "name": "haupt.design", "hostname": "haupt.design", "checkInterval": 30, "timeoutSeconds": 30, "dnsConfig": { "rrtypes": ["A"], "matchMode": "exact", "triggerOn": { "mismatch": true, "resolveError": true }, "expectedValues": { "A": ["76.76.21.21"] } }, "status": "active", "notificationPhoneNumber": null, "notificationEmail": null, "lastCheckedAt": "2026-04-03T14:55:00.005Z", "createdAt": "2026-02-23T20:24:54.731Z", "updatedAt": "2026-04-03T14:55:01.193Z" } ```
### DNS Monitor Alert-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/dns-monitors/get-dns-monitor-alert-history
Description: Gibt die Benachrichtigungs-/Eskalationsversuche (Alert-Historie) für Vorfälle eines DNS Monitors zurück.
Summary: `GET /api/dns-monitors/:dnsMonitorPublicId/alert-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `dnsMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des DNS Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `sent` oder `failed`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `sentAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/dns-monitors/11111111-1111-4111-8111-111111111111/alert-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 987, "incidentId": 123, "type": "slack", "status": "sent", "channelName": "Ops Slack", "channelType": "slack", "channelConfig": null, "sentAt": "2026-02-26T12:11:00.000Z", "errorMessage": null } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Jeder Eintrag ist ein Zustellversuch an einen Benachrichtigungskanal. `status` ist `sent` oder `failed` (bei Fehler ist `errorMessage` gesetzt); `channelType` ist der Kanaltyp (z. B. `email`, `slack`, `opsgenie`). Bei `channelConfig` sind Secrets geschwärzt. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 DNS monitor public ID (UUID) required` wenn `:dnsMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### DNS Monitor Check-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/dns-monitors/get-dns-monitor-check-history
Description: Gibt die letzten DNS-Check-Ergebnisse zurück.
Summary: `GET /api/dns-monitors/:dnsMonitorPublicId/check-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `dnsMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des DNS Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). Eine Seite zählt Prüfzyklen, nicht Zeilen: ein Zyklus hat eine Zeile je Standort. - `limit` (number, optional): Zyklen pro Seite (Default: `10`; Max `100`). Bei `format=csv` oder `download=1` gelten die Export-Defaults (Default `10000`, Max `50000` Zeilen). - `status` (string, optional): `success` oder `failure` (`failure` matcht auch `timeout`). Bei Minutenzeilen: kein Standort fehlgeschlagen bzw. mindestens einer. - `minMs` / `maxMs` (number, optional): Filter nach Response-Time-Bereich (`timingTotal`; bei Minutenzeilen der Minutendurchschnitt). - `from` / `to` (ISO-Datumsstring, optional): Filter nach `checkedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. ## cURL ```bash curl "https://YOUR_DOMAIN/api/dns-monitors/44444444-4444-4444-8444-444444444444/check-history?page=1&limit=10" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "data": [ { "id": "33c53ac4-a2bc-475c-a904-8d3d6aab2979", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-10-01T05:40:55.690Z", "responseTimeMs": 29, "location": { "name": "Paris (FR)", "code": "par" }, "resolution": "raw" }, { "id": "1min-2026-09-30T15:55:00.000Z", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-09-30T15:55:00.000Z", "responseTimeMs": 54, "location": null, "resolution": "1min", "totalLocations": 2, "failedLocations": 0 } ], "total": 864, "page": 17, "pageCount": 87, "resolution": "mixed", "rawWindowFrom": "2026-09-30T16:00:00.000Z" } ``` - `resolution` je Zeile: `raw` ist eine einzelne Prüfung mit Standort und Fehlermeldung; `1min` ist eine Minute über alle Standorte, ohne Standort und Fehlermeldung, dafür mit `totalLocations` und `failedLocations`. - `resolution` der Seite: `raw`, `1min` oder `mixed` (die Seite liegt über der Grenze). - `rawWindowFrom`: ab hier gibt es einzelne Prüfungen; ältere Zeilen sind Minutenzeilen. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. CSV-Spalten: `checkedAt,status,responseTimeMs,location,errorMessage,resolution`. Der JSON-Export (`format=json&download=1`) enthält je einzelner Prüfung zusätzlich `diagnostics` (Resolver-Antworten). ## Aufbewahrung Einzelne Prüfungen mit Standort und Fehlermeldung bleiben 24 Stunden erhalten. Ältere Einträge kommen aus den Minutenwerten (30 Tage), eine Zeile je Minute ohne Standort und Fehlermeldung. Tageswerte (24 Monate) stehen in den Monitor-Details. ## Antwort (Response) Gibt eine Liste von Check-Einträgen zurück. Siehe [Fehlerliste](/de/api/error-codes-and-known-pitfalls) für Fehlerantworten. ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status`, `minMs` oder `maxMs` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist
### DNS Monitor Ausfall-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/dns-monitors/get-dns-monitor-incident-history
Description: Gibt die Vorfälle eines einzelnen DNS Monitors zurück (die letzten 100), inklusive berechneter Dauer.
Summary: `GET /api/dns-monitors/:dnsMonitorPublicId/incident-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `dnsMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des DNS Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `open`, `acknowledged` oder `resolved`. - `type` (string, optional): `downtime`, `http_status`, `ssl_expiry`, `ssl_critical`, `ssl_warning`, `response_time`, `dnsbl`, `domain_expiry_warning`, `critical` oder `inconclusive`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `startedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/dns-monitors/11111111-1111-4111-8111-111111111111/incident-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 123, "publicId": "55555555-5555-4555-8555-555555555555", "type": "downtime", "status": "resolved", "startedAt": "2026-02-26T12:10:00.000Z", "endedAt": "2026-02-26T12:12:30.000Z", "durationMs": 150000, "statusCode": null, "errorMessage": "connect ETIMEDOUT", "details": "connect ETIMEDOUT", "isOngoing": false } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. **Abgelöstes Feld:** `duration` (Text, z. B. `2m 30s`) wird bis zum Entfall am 18.01.2027 weiter neben `durationMs` geliefert. Lies `durationMs`. `status` ist `open`, `acknowledged` oder `resolved`. Laufende Vorfälle haben ein `null` bei `endedAt` und `isOngoing: true`. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 DNS monitor public ID (UUID) required` wenn `:dnsMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` oder `type` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### DNS Monitore auflisten
URL: https://docs.uptimeify.io/de/api/monitors/dns-monitors/list-dns-monitors
Description: Listet DNS-Monitore einer Organisation (mit Pagination) auf.
Summary: `GET /api/dns-monitors` Jedes Item enthält nur den DNS-Monitor selbst und bettet keinen vollständigen Kunden-Datensatz ein. ## Query Parameter - `organizationId` (optional): Standard ist deine Session-Organisation - `customerId` (optional) - `search` (optional) - `page` (optional, Default `1`) - `perPage` (optional, Default `50`, max `200`) ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET \ "$BASE_URL/api/dns-monitors?organizationId=1&page=1&perPage=50" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 5, "publicId": "79fbe9b0-f9c6-4026-86de-1dbebc84d9bb", "organizationId": 2, "customerId": 2, "customerName": "Zaskoku & Haupt GbR", "name": "Primary DNS Monitor", "hostname": "claas.sh", "checkInterval": 30, "timeoutSeconds": 30, "dnsConfig": {}, "allowedCheckCountryCodes": null, "status": "active", "notificationPhoneNumber": null, "notificationEmail": null, "lastCheckedAt": "2026-04-03T14:54:56.561Z", "createdAt": "2026-04-03T14:54:56.383Z", "updatedAt": "2026-04-03T14:54:56.740Z", "uptimeDay": "100.00", "uptimeMonth": "99.87", "uptimeYear": "99.94", "avgResponseDay": 24, "avgResponseMonth": 27, "avgResponseYear": 26, "responseGraph": { "values": [24, 25, null], "avg": 24 }, "upSinceAt": "2026-04-01T08:12:03.000Z", "isDown": false, "tags": [] } ], "total": 0, "page": 1, "perPage": 50 } ``` "total": 0, "page": 1, "perPage": 50 } ``` ## Inline-Metriken Jeder Eintrag traegt dieselben verdichteten Kennzahlen, die auch die uebrigen Monitor-Listen liefern. Sie werden je Monitor ueber den Kalendertag, den Monat und das Jahr in UTC gebildet. | Feld | Typ | Bedeutung | |------|-----|-----------| | `uptimeDay` / `uptimeMonth` / `uptimeYear` | string | Verfuegbarkeit in Prozent mit zwei Nachkommastellen, z. B. `"99.94"` | | `avgResponseDay` / `avgResponseMonth` / `avgResponseYear` | number \| null | Mittlere Antwortzeit in Millisekunden; `null`, wenn in dem Fenster nichts gemessen wurde | | `responseGraph` | object | `{ values, avg }` fuer die letzten 24 Stunden, ein Eintrag je Stunde; eine Stunde ohne erfolgreiche Pruefung ist `null` | | `upSinceAt` | string \| null | ISO-Zeitpunkt, seit dem der Monitor laeuft, `null` solange er ausgefallen ist | | `isDown` | boolean | Ob der Monitor gerade in einem unaufgeloesten Vorfall steckt | Die Tageswerte kommen aus den Rohdaten, Monat und Jahr aus fortlaufenden Aggregaten -- in diesen beiden Fenstern kann ein Wert der neuesten Pruefung daher um einige Minuten hinterherhinken. ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `page` oder `perPage` keine positive Ganzzahl ist, `sortOrder` weder `asc` noch `desc` oder `tags` keine kommagetrennte Liste von Tag-IDs
### DNS Check triggern
URL: https://docs.uptimeify.io/de/api/monitors/dns-monitors/trigger-check-dns-monitor
Description: Triggert einen sofortigen DNS-Check über alle eligible Monitoring-Locations.
Summary: `POST /api/dns-monitors/:dnsMonitorPublicId/trigger-check` ## Antwort (Response) Gibt `202 Accepted` zurück, wenn der Check erfolgreich angestoßen wurde. Siehe [Fehlerliste](/de/api/error-codes-and-known-pitfalls) für Fehlerantworten. ## Häufige Fehler - `400 DNS monitor public ID (UUID) required` - `401 Unauthorized` - `403 Forbidden` (Schreibzugriff nötig) - `429 Check recently triggered` (`data.retryAfterMs`) wenn derselbe Monitor in den letzten 10 Sekunden schon angestoßen wurde - `503 No active monitoring locations available`
### DNS Monitor aktualisieren
URL: https://docs.uptimeify.io/de/api/monitors/dns-monitors/update-dns-monitor
Description: Aktualisiert einen DNS-Monitor.
Summary: `PATCH /api/dns-monitors/:dnsMonitorPublicId` Hinweise: - Readonly-User dürfen nur `status` ändern. - Global Supporter dürfen nicht mutieren. - Wenn du `customerId` mitsendest, akzeptiert das Feld entweder die interne numerische ID oder die `publicId`-UUID des Kunden. ## Request Body (Beispiel) ```json { "customerId": "6764e84f-f02a-43e6-a46d-cecaec556723", "status": "maintenance", "name": "Primary DNS Monitor", "hostname": "claas.sh", "checkInterval": 30, "timeoutSeconds": 30, "dnsConfig": { "rrtypes": ["A"], "matchMode": "exact", "expectedValues": { "A": ["76.76.21.21"] }, "triggerOn": { "resolveError": true, "mismatch": true } } } ``` Wenn du `dnsConfig` mitsendest, muss es `rrtypes`, `matchMode` und für jeden RR-Type in `rrtypes` mindestens einen Eintrag in `expectedValues` enthalten. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X PATCH \ "$BASE_URL/api/dns-monitors/11111111-1111-4111-8111-111111111111" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"customerId":"6764e84f-f02a-43e6-a46d-cecaec556723","status":"maintenance","name":"Primary DNS Monitor","hostname":"claas.sh","checkInterval":30,"timeoutSeconds":30,"dnsConfig":{"rrtypes":["A"],"matchMode":"exact","expectedValues":{"A":["76.76.21.21"]},"triggerOn":{"resolveError":true,"mismatch":true}}}' ``` ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `name` kein nicht-leerer String mit höchstens 255 Zeichen ist oder `allowedCheckCountryCodes` weder ein Array von Ländercodes noch `null` - `400 Bad Request` (`invalidTimeoutSeconds`) wenn `timeoutSeconds` keine Ganzzahl zwischen 1 und 60 ist - `400 Bad Request` (`invalidConfig`) wenn ein Config-Feld (`config` oder das typspezifische) kein Objekt ist - `400 DNS monitor ID is required` - `400 Invalid status` - `400 Invalid Customer identifier` - `400 Expected values are required for RR type ` - `401 Unauthorized` - `403 Forbidden` - `404 Customer not found` ## Antwort (Response) Gibt das aktualisierte DNS-Monitor-Objekt zurück. Siehe [Fehlerliste](/de/api/error-codes-and-known-pitfalls) für Fehlerantworten.
### DNSBL-Überwachung (Kunden-IPs)
URL: https://docs.uptimeify.io/de/api/monitors/dnsbl-monitoring
Description: DNSBL-Überwachung wird über Kunden-IPs konfiguriert. Diese IPs werden periodisch gegen DNS-basierte Blacklists geprüft.
Summary: ## Endpunkte - [Kunden-IPs (Organisation) auflisten](/de/api/monitors/dnsbl-monitoring/list-customer-ips) - [Kunden-IP abrufen](/de/api/monitors/dnsbl-monitoring/get-customer-ip) - [Kunden-IP aktualisieren](/de/api/monitors/dnsbl-monitoring/update-customer-ip) - [Kunden-IP löschen](/de/api/monitors/dnsbl-monitoring/delete-customer-ip) - [Kunden-IPs (Kunde) auflisten](/de/api/monitors/dnsbl-monitoring/list-customer-ips-for-customer) - [Kunden-IP (für Kunde) erstellen](/de/api/monitors/dnsbl-monitoring/create-customer-ip-for-customer)
### Create Customer Ip For Customer
URL: https://docs.uptimeify.io/de/api/monitors/dnsbl-monitoring/create-customer-ip-for-customer
Summary: title: Kunden-IP (für Kunde) erstellen description: POST /api/customers/:customerPublicId/ips --- # Kunden-IP (für Kunde) erstellen `POST /api/customers/:customerPublicId/ips` Erstellt eine neue Kunden-IP für DNSBL-Überwachung. ## Anfrage (Request Body) ```json { "ipAddress": "203.0.113.10", "label": "Mail Server", "ipFamily": "v4", "status": "active" } ``` Hinweise: - `customerPublicId` sollte die Public-ID des Kunden als UUID sein. Legacy-numerische Kunden-IDs bleiben aus Kompatibilitätsgründen weiter unterstützt. - `ipFamily` ist optional (wird sonst aus der IP abgeleitet). - Wenn `ipFamily` gesetzt ist, muss es zur IP-Version passen. - Das Erstellen einer `active` IP kann wegen Quota-Limits abgelehnt werden. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/customers/6bfec6f6-245a-47ce-843b-157d97d56f88/ips" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"ipAddress":"203.0.113.10","label":"Mail Server","status":"active"}' ``` ## Häufige Fehler - `400 Invalid Customer identifier` wenn `:customerPublicId` fehlt/ungültig ist - `400 Invalid IP address` wenn `ipAddress` ungültig ist - `400 IP family mismatch...` wenn `ipFamily` nicht zur IP passt - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` für Readonly/Global-Supporter oder bei fehlendem Zugriff - `403 Active IP limit reached...` wenn Erstellung/Aktivierung dein Quota überschreitet - `404 Customer not found` wenn der Kunde nicht existiert - Es gibt auf dieser Route KEINE `409`: eine Adresse, die bei diesem Kunden schon steht, kommt bei exakt demselben Body als erkannte Wiederholung zurück (siehe Antwort), bei abweichendem Body wird sie ein zweiter Eintrag ## Antwort (Response) `200` mit dem Kunden-IP-Record, der jetzt zusätzlich das Feld `deduplicated` trägt. Eine Wiederholung mit exakt demselben Body legt KEINEN zweiten, separat abgerechneten Monitor an: Es wird der bereits vorhandene Eintrag erneut zurückgegeben, und die Antwort trägt `"deduplicated": true`; eine erste Erstellung trägt `"deduplicated": false`. Beide Fälle antworten mit `200`. Verglichen wird die vollständige Anfrage und nicht nur `ipAddress` -- dieselbe Adresse mit einem anderen `label` oder `status` ist eine andere Anfrage und legt sehr wohl einen zweiten Eintrag an, denn auf die Adresse selbst gibt es keine Eindeutigkeitsprüfung. Eine erkannte Wiederholung zählt nicht gegen die Grenze aktiver Adressen. Siehe [Fehlerliste](/de/api/error-codes-and-known-pitfalls) für Fehlerantworten.
### Kunden-IP löschen
URL: https://docs.uptimeify.io/de/api/monitors/dnsbl-monitoring/delete-customer-ip
Description: Löscht eine Kunden-IP.
Summary: `DELETE /api/customer-ips/:customerIpPublicId` Hinweis: - Readonly-User und Global Supporter dürfen nicht löschen. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X DELETE "$BASE_URL/api/customer-ips/11111111-1111-4111-8111-111111111111" \ -H "Authorization: Bearer $TOKEN" ``` ## Beispiel-Antwort ```json { "success": true } ``` ## Häufige Fehler - `400 Invalid IP identifier` wenn `:customerIpPublicId` weder UUID noch Legacy-ID ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` für Readonly/Global-Supporter oder bei fehlendem Zugriff - `404 IP not found` wenn die IP nicht existiert ## Berechtigungen Für die Rolle `readonly` gesperrt. Ein Nur-Lese-Zugang löscht keine IP, gleich welcher Besitzklasse, und ein von ihm ausgestellter API-Token ebenso wenig: Ein Token erbt die Rolle seines Erstellers. Das Bearbeiten einer IP mit `self_service` bleibt dieser Rolle erlaubt. Kunden-gescopte Aufrufer bindet zusätzlich die Besitzklasse: Eine `managed`-IP wird mit `managed_by_organization` abgelehnt, solange der Kunde kein `canEditManaged` trägt.
### Kunden-IP abrufen
URL: https://docs.uptimeify.io/de/api/monitors/dnsbl-monitoring/get-customer-ip
Description: Gibt eine Kunden-IP inkl. DNSBL-Status zurück (falls vorhanden).
Summary: `GET /api/customer-ips/:customerIpPublicId` Die Response enthält die Kunden-IP selbst und, falls vorhanden, ein `dnsbl`-Objekt. Ein vollständiger Kunden-Datensatz wird nicht eingebettet. ## Beispiel-Response ```json { "id": 1, "publicId": "a19effb9-eb5f-459b-b5d6-2f615b574651", "customerId": 2, "customerName": "Zaskoku & Haupt GbR", "label": "Kurbelix Adminserver", "ipAddress": "77.75.254.185", "ipFamily": "v4", "status": "active", "createdAt": "2026-02-03T15:06:46.469Z", "updatedAt": "2026-02-03T15:06:46.469Z", "dnsbl": { "isListed": true, "listedCount": 1, "listings": [ { "name": "all.s5h.net", "reason": "Listed in all.s5h.net", "listKey": "all.s5h.net", "delistUrl": "http://s5h.net", "resultCode": "127.0.0.2" } ], "lastError": null, "lastCheckedAt": "2026-04-03T15:13:00.083Z", "lastChangedAt": "2026-02-04T10:00:00.121Z", "lastListedAt": "2026-04-03T15:13:00.083Z", "lastCleanAt": null, "lastNotifiedListedAt": "2026-04-02T20:55:04.969Z", "lastNotifiedCleanAt": null } } ``` ## Pfadparameter - `customerIpPublicId` (empfohlen): Public-ID der Kunden-IP als UUID - Legacy-Kompatibilität: numerische IDs werden weiterhin akzeptiert ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/customer-ips/11111111-1111-4111-8111-111111111111" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Häufige Fehler - `400 Invalid IP identifier` wenn `:customerIpPublicId` weder UUID noch Legacy-ID ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Kunden hast - `404 IP not found` wenn die IP nicht existiert
### Kunden-IPs (Organisation) auflisten
URL: https://docs.uptimeify.io/de/api/monitors/dnsbl-monitoring/list-customer-ips
Description: Listet Kunden-IPs innerhalb einer Organisation auf (Pagination + Suche). Das ist die primäre Konfiguration für DNSBL-Überwachung.
Summary: `GET /api/customer-ips` ## Query Parameter - `organizationId` (optional): Standard ist deine Session-Organisation - `customerId` (optional): akzeptiert die Public-ID des Kunden als UUID (empfohlen) oder eine Legacy-numerische Kunden-ID - `search` (optional) - `page` (optional, Default `1`) - `perPage` (optional, Default `50`, max `200`) Optional bedeutet hier: Parameter komplett weglassen, wenn du sie nicht nutzt. Sende keine leeren Strings wie `page=` oder `perPage=`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/customer-ips?organizationId=1&page=1&perPage=50" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [], "total": 0, "page": 1, "perPage": 50 } ``` ## Häufige Fehler - `400 Organization ID required` wenn keine Organisation abgeleitet werden kann - `400` Query-Validierungsfehler (z.B. ungültige `organizationId`, `customerId`, `page`, `perPage`) - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Organisation hast
### List Customer Ips For Customer
URL: https://docs.uptimeify.io/de/api/monitors/dnsbl-monitoring/list-customer-ips-for-customer
Summary: title: Kunden-IPs (Kunde) auflisten description: GET /api/customers/:customerPublicId/ips --- # Kunden-IPs (Kunde) auflisten `GET /api/customers/:customerPublicId/ips` Listet IPs eines Kunden inkl. DNSBL-Status auf. ## Pfadparameter - `customerPublicId` (empfohlen): Public-ID des Kunden als UUID - Legacy-Kompatibilität: numerische Kunden-IDs werden weiterhin akzeptiert ## Query-Parameter | Parameter | Typ | Standard | Beschreibung | |---|---|---|---| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/customers/6bfec6f6-245a-47ce-843b-157d97d56f88/ips?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Häufige Fehler - `400 Invalid Customer identifier` wenn `:customerPublicId` fehlt/ungültig ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Kunden hast - `404 Customer not found` wenn der Kunde nicht existiert ## Antwort (Response) Gibt die IP-Objekte des Kunden zurück; jeder Eintrag kann ein `dnsbl`-Objekt enthalten. **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Einträge); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Siehe [Fehlerliste](/de/api/error-codes-and-known-pitfalls) für Fehlerantworten.
### Kunden-IP aktualisieren
URL: https://docs.uptimeify.io/de/api/monitors/dnsbl-monitoring/update-customer-ip
Description: Aktualisiert eine Kunden-IP (z.B. Label oder Status).
Summary: `PATCH /api/customer-ips/:customerIpPublicId` Hinweise: - Readonly-User und Global Supporter dürfen nicht mutieren. - Aktivieren kann wegen Quota-Limits abgelehnt werden. ## Anfrage (Request Body) ```json { "label": "Mail Server", "status": "active" } ``` ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X PATCH "$BASE_URL/api/customer-ips/11111111-1111-4111-8111-111111111111" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"label":"Mail Server","status":"active"}' ``` ## Häufige Fehler - `400 Invalid IP identifier` wenn `:customerIpPublicId` weder UUID noch Legacy-ID ist - `400` Body-Validierungsfehler (z.B. ungültiger `status`) - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` für Readonly/Global-Supporter oder bei fehlendem Zugriff - `403 Active IP limit reached...` wenn Aktivierung dein Quota überschreitet - `404 IP not found` wenn die IP nicht existiert ## Antwort (Response) Gibt das aktualisierte Kunden-IP-Objekt zurück. Siehe [Fehlerliste](/de/api/error-codes-and-known-pitfalls) für Fehlerantworten.
### Domain-Ablauf-Überwachung (Kunden-Domains)
URL: https://docs.uptimeify.io/de/api/monitors/domain-expiry-monitoring
Description: Die Domain-Ablauf-Überwachung wird über Kunden-Domains konfiguriert.
Summary: ## Endpunkte - [Kunden-Domain (für Kunde) erstellen](/de/api/monitors/domain-expiry-monitoring/create-customer-domain) - [Kunden-Domains (Organisation) auflisten](/de/api/monitors/domain-expiry-monitoring/list-customer-domains) - [Kunden-Domain abrufen](/de/api/monitors/domain-expiry-monitoring/get-customer-domain) - [Kunden-Domain aktualisieren](/de/api/monitors/domain-expiry-monitoring/update-customer-domain) - [Kunden-Domain löschen](/de/api/monitors/domain-expiry-monitoring/delete-customer-domain) - [Domain-Ablauf (Websites) auflisten](/de/api/monitors/domain-expiry-monitoring/list-domain-expiry-websites)
### Create Customer Domain
URL: https://docs.uptimeify.io/de/api/monitors/domain-expiry-monitoring/create-customer-domain
Summary: title: Kunden-Domain erstellen (Kunde) description: POST /api/customers/:customerPublicId/domains --- # Kunden-Domain erstellen (Kunde) `POST /api/customers/:customerPublicId/domains` Erstellt eine Kunden-Domain für die Ablauf-Überwachung. ## Request Body ```json { "domainName": "deinkunde.com", "label": "Main Domain", "status": "active", "expiryWarningDays": 30, "expiryErrorDays": 7 } ``` Hinweise: - `customerPublicId` sollte die Public-ID des Kunden als UUID sein. Legacy-numerische Kunden-IDs bleiben aus Kompatibilitätsgründen weiter unterstützt. - `domainName` muss eine gültige Domain wie `deinkunde.com` sein (kein Protokoll, kein Pfad). - Das Erstellen einer `active` Domain kann durch Quota-Limits blockiert werden. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/customers/6bfec6f6-245a-47ce-843b-157d97d56f88/domains" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"domainName":"deinkunde.com","label":"Main Domain","status":"active","expiryWarningDays":30,"expiryErrorDays":7}' ``` ## Antwort `200` mit dem Kunden-Domain-Record, der jetzt zusätzlich das Feld `deduplicated` trägt. Eine Wiederholung mit exakt demselben Body legt KEINEN zweiten, separat abgerechneten Monitor an: Es wird der bereits vorhandene Eintrag erneut zurückgegeben, und die Antwort trägt `"deduplicated": true`; eine erste Erstellung trägt `"deduplicated": false`. Beide Fälle antworten mit `200`. Verglichen wird die vollständige Anfrage und nicht nur `domainName` -- dieselbe Domain mit einem anderen `label`, `status` oder anderen Schwellwerten ist eine andere Anfrage und legt sehr wohl einen zweiten Eintrag an, denn auf den Domainnamen selbst gibt es keine Eindeutigkeitsprüfung. Eine erkannte Wiederholung verbraucht kein Kontingent und stuft die Organisation nie eine Preisstufe hoch. ## Häufige Fehler - `400 Invalid Customer identifier` wenn `:customerPublicId` fehlt/ungültig ist - `400 Invalid domain name...` wenn `domainName` ungültig ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` für Readonly/Global-Supporter-User, oder wenn du keinen Zugriff auf den Kunden hast - `403 Active domain limit reached...` wenn das Erstellen/Aktivieren dein Quota-Limit überschreiten würde - `404 Customer not found` wenn der Kunde nicht existiert
### Kunden-Domain löschen
URL: https://docs.uptimeify.io/de/api/monitors/domain-expiry-monitoring/delete-customer-domain
Description: Löscht eine Kunden-Domain.
Summary: `DELETE /api/customer-domains/:customerDomainPublicId` Hinweise: - Readonly-User und Global-Supporter können Kunden-Domains nicht löschen. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X DELETE "$BASE_URL/api/customer-domains/22222222-2222-4222-8222-222222222222" \ -H "Authorization: Bearer $TOKEN" ``` ## Beispiel-Antwort ```json { "success": true } ``` ## Häufige Fehler - `400 Invalid Domain identifier` wenn `:customerDomainPublicId` weder UUID noch Legacy-ID ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` für Readonly/Global-Supporter-User, oder wenn du keinen Zugriff auf die Domain/den Kunden hast - `404 Domain not found` wenn die Domain nicht existiert ## Berechtigungen Für die Rolle `readonly` gesperrt. Ein Nur-Lese-Zugang löscht keine Domain, gleich welcher Besitzklasse, und ein von ihm ausgestellter API-Token ebenso wenig: Ein Token erbt die Rolle seines Erstellers. Das Bearbeiten einer Domain mit `self_service` bleibt dieser Rolle erlaubt. Kunden-gescopte Aufrufer bindet zusätzlich die Besitzklasse: Eine `managed`-Domain wird mit `managed_by_organization` abgelehnt, solange der Kunde kein `canEditManaged` trägt.
### Kunden-Domain abrufen
URL: https://docs.uptimeify.io/de/api/monitors/domain-expiry-monitoring/get-customer-domain
Description: Gibt eine einzelne Kunden-Domain zurück.
Summary: `GET /api/customer-domains/:customerDomainPublicId` Die Response enthält die Kunden-Domain selbst und bettet keinen vollständigen Kunden-Datensatz ein. ## Pfadparameter - `customerDomainPublicId` (empfohlen): Public-ID der Kunden-Domain als UUID - Legacy-Kompatibilität: numerische IDs werden weiterhin akzeptiert Hinweise: - Einige Registries/TLDs (z.B. `.de`) veröffentlichen kein Ablaufdatum via RDAP. In diesem Fall kann `expiry.domainExpiresAt` `null` sein und `expiry.lastError` enthält ggf. eine erklärende Fehlermeldung. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/customer-domains/22222222-2222-4222-8222-222222222222" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Response ```json { "id": 20, "publicId": "d70884d9-4cef-4fe5-9b15-341b7dd9e196", "customerId": 2, "customerName": "Zaskoku & Haupt GbR", "label": "Primary Domain", "domainName": "cacheassist.io", "status": "active", "expiryWarningDays": 30, "expiryErrorDays": 7, "createdAt": "2026-04-03T15:28:40.602Z", "updatedAt": "2026-04-03T15:28:40.602Z", "expiry": { "domainExpiresAt": null, "domainRegistrar": null, "isExpired": false, "lastError": "RDAP query error for cacheassist.io: fetch failed", "lastCheckedAt": "2026-04-03T15:29:00.200Z", "lastChangedAt": null, "lastNotifiedWarningAt": null, "lastNotifiedErrorAt": null, "lastNotifiedExpiredAt": null } } ``` ## Häufige Fehler - `400 Invalid Domain identifier` wenn `:customerDomainPublicId` fehlt/ungültig ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Domain/den Kunden hast - `404 Domain not found` wenn die Domain nicht existiert
### Kunden-Domains (Organisation) auflisten
URL: https://docs.uptimeify.io/de/api/monitors/domain-expiry-monitoring/list-customer-domains
Description: Listet Kunden-Domains innerhalb einer Organisation auf (Pagination + Suche).
Summary: `GET /api/customer-domains` ## Query Parameter - `organizationId` (optional): Standard ist deine Session-Organisation - `customerId` (optional): akzeptiert die Public-ID des Kunden als UUID (empfohlen) oder eine Legacy-numerische Kunden-ID - `search` (optional) - `page` (optional, Default `1`) - `perPage` (optional, Default `50`, max `200`) Optional bedeutet hier: Parameter komplett weglassen, wenn du sie nicht nutzt. Sende keine leeren Strings wie `page=` oder `perPage=`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/customer-domains?organizationId=1&page=1&perPage=50" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort Gibt eine paginierte Antwort zurück: ```json { "items": [ { "id": 1, "publicId": "34eb0ec1-315d-45c4-aefe-0e5d12b11183", "customerId": 2, "customerName": "Zaskoku & Haupt GbR", "customerPublicId": "6764e84f-f02a-43e6-a46d-cecaec556723", "label": null, "domainName": "digitalduett.com", "status": "active", "expiryWarningDays": 30, "expiryErrorDays": 7, "createdAt": "2026-02-13T21:21:03.001Z", "updatedAt": "2026-02-13T21:21:03.001Z", "expiry": { "domainExpiresAt": "2026-12-20T20:44:45.000Z", "domainRegistrar": "NameCheap, Inc.", "isExpired": false, "lastError": null, "lastCheckedAt": "2026-04-03T10:59:00.321Z", "lastChangedAt": "2026-04-03T10:59:00.321Z", "lastNotifiedWarningAt": null, "lastNotifiedErrorAt": null, "lastNotifiedExpiredAt": null } } ], "total": 0, "page": 1, "perPage": 50 } ``` Jedes Item enthält flache Kundenfelder plus ein `expiry`-Objekt (oder `null`). ## Häufige Fehler - `400 Organization ID required` wenn keine Organisation abgeleitet werden kann - `400` Query-Validierungsfehler (z.B. ungültige `organizationId`, `customerId`, `page`, `perPage`) - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Organisation hast
### Domain-Ablauf (Websites) auflisten
URL: https://docs.uptimeify.io/de/api/monitors/domain-expiry-monitoring/list-domain-expiry-websites
Description: Listet Websites mit den zuletzt bekannten Informationen zum Domain-Ablaufdatum auf.
Summary: `GET /api/domains` ## Query Parameter - `organizationId` (optional): Standard ist deine Session-Organisation - `customerId` (optional) - `search` (optional) - `page` (optional, Default `1`) - `perPage` (optional, Default `50`, max `200`) ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/domains?organizationId=1&page=1&perPage=50" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort ```json { "items": [ { "id": 101, "name": "Example Website", "url": "https://deinkunde.com", "status": "active", "customerId": 10, "customerName": "Example Customer", "checkDomainExpiryEnabled": true, "domainExpiryNoticeDays": 30, "domainExpiryErrorDays": 7, "domainExpiresAt": "2026-12-31T00:00:00.000Z", "domainRegistrar": "Example Registrar", "lastDomainCheckAt": "2026-03-03T10:00:00.000Z", "daysUntilExpiry": 303, "expiryStatus": "ok" } ], "total": 1, "page": 1, "perPage": 50 } ``` ## Feldnotizen - `expiryStatus` kann sein: `ok`, `warning`, `critical`, `expired`, `unknown`, `disabled`. - `daysUntilExpiry` ist `null`, wenn kein Ablaufdatum verfügbar ist. ## Häufige Fehler - `400 Organization ID required` wenn keine Organisation abgeleitet werden kann - `400 Invalid customerId` wenn `customerId` ungültig ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Organisation hast
### Kunden-Domain aktualisieren
URL: https://docs.uptimeify.io/de/api/monitors/domain-expiry-monitoring/update-customer-domain
Description: Aktualisiert eine Kunden-Domain (z.B. Label, Status, Ablauf-Schwellenwerte).
Summary: `PATCH /api/customer-domains/:customerDomainPublicId` Hinweise: - Global-Supporter können Kunden-Domains nicht aktualisieren. Ein Readonly- oder kundengebundener Zugang darf seine eigenen `self_service`-Domains ändern; eine `managed`-Domain bleibt gesperrt, solange die Organisation `canEditManaged` nicht erteilt hat. - Der Domainname steht seit dem Anlegen fest und lässt sich hier nicht ändern. Deshalb prüft der Endpunkt nicht mehr nach, ob die TLD RDAP-Ablaufabfragen unterstützt (bis zum 06.09.2026 tat er das): eine gespeicherte Domain auf einer TLD ohne RDAP lässt sich weiterhin umbenennen, mit anderen Schwellen versehen und vor allem abschalten. - Das Aktivieren einer deaktivierten Domain kann abgelehnt werden, wenn Quota-Limits erreicht sind. ## Request Body ```json { "label": "Main Domain", "status": "active", "expiryWarningDays": 30, "expiryErrorDays": 7 } ``` ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X PATCH "$BASE_URL/api/customer-domains/22222222-2222-4222-8222-222222222222" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"status":"active"}' ``` ## Antwort Gibt den aktualisierten Kunden-Domain-Record zurück. ## Häufige Fehler - `400` Body-Validierungsfehler (z.B. ungültige Thresholds) - `400 Invalid Domain identifier` wenn `:customerDomainPublicId` weder UUID noch Legacy-ID ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` für Global-Supporter, für eine `managed`-Domain ohne `canEditManaged`, oder wenn du keinen Zugriff auf die Domain/den Kunden hast - `403 Active domain limit reached...` wenn das Aktivieren dein Quota-Limit überschreiten würde - `404 Domain not found` wenn die Domain nicht existiert
### FTP Monitore
URL: https://docs.uptimeify.io/de/api/monitors/ftp-monitors
Description: Verwalte FTP Monitore.
Summary: Pfadbasierte FTP-Monitor-Endpunkte verwenden `ftpMonitorPublicId`-UUIDs. ## Endpunkte - [FTP Monitore auflisten](/de/api/monitors/ftp-monitors/list-ftp-monitors) - [FTP Monitor erstellen](/de/api/monitors/ftp-monitors/create-ftp-monitor) - [FTP Monitor abrufen](/de/api/monitors/ftp-monitors/get-ftp-monitor) - [FTP Monitor Details abrufen](/de/api/monitors/ftp-monitors/get-ftp-monitor-details) - [FTP Monitor Check-Historie abrufen](/de/api/monitors/ftp-monitors/get-ftp-monitor-check-history) - [FTP Monitor aktualisieren (Status ändern)](/de/api/monitors/ftp-monitors/update-ftp-monitor) - [FTP Monitor löschen](/de/api/monitors/ftp-monitors/delete-ftp-monitor) - [FTP Check triggern](/de/api/monitors/ftp-monitors/trigger-check-ftp-monitor)
### FTP Monitor erstellen
URL: https://docs.uptimeify.io/de/api/monitors/ftp-monitors/create-ftp-monitor
Description: Erstellt einen neuen FTP Monitor.
Summary: `POST /api/ftp-monitors` ## Authentifizierung Dieser Endpoint benötigt ein API-Token: `Authorization: Bearer ` ## Request Body - `customerId` (required, number | string): interne numerische Kunden-ID oder Customer-`publicId`-UUID - `name` (required, string) - `hostname` (required, string): Muss ein Hostname sein (kein Protokoll, kein Pfad). - `port` (optional, number | null): Wenn weggelassen/null, nutzt der Worker einen Default-Port. - `status` (optional): `active`, `maintenance`, `disabled` (akzeptiert auch `inactive` und normalisiert zu `disabled`) - `checkInterval` (optional, number): Minuten (min: 1, max: 60) - `timeoutSeconds` (optional, number): Sekunden (min: 1, max: 60) - `checkMode` (optional, string): `protocol` | `tcp`. Standard: `protocol`. - Im Modus `tcp` führt der Monitor nur eine reine TCP-Port-Erreichbarkeitsprüfung durch: `ftpConfig` ist nicht erforderlich und wird nicht gespeichert. Im Modus `protocol` läuft die vollständige FTP-Login-Prüfung (bisheriges Verhalten). - `ftpConfig` (optional, object): FTP-Verbindungsoptionen (als JSON gespeichert) - Erforderlich (`user` + `password`), außer `checkMode` ist `tcp`. ### `ftpConfig` Der Monitoring-Worker liest diese Keys: - `user` (optional, string): Default `anonymous` - `password` (optional, string): Default `anonymous@` - `secure` (optional, boolean | `"implicit"`): - `false` (Default): plain FTP - `true`: explicit TLS - `"implicit"`: implicit TLS (Worker nutzt default Port `990`, wenn `port` nicht gesetzt ist) ```json { "customerId": "6764e84f-f02a-43e6-a46d-cecaec556723", "name": "FTP Availability", "hostname": "claas.sh", "port": 21, "status": "active", "checkInterval": 5, "timeoutSeconds": 30, "ftpConfig": { "user": "root", "password": "exampleRoot", "secure": "explicit" } } ``` ### Duplikate Hat dieser Kunde schon einen Monitor mit derselbe `hostname` (Gross- und Kleinschreibung und ein Punkt am Ende zählen nicht), `port` und `checkMode`, wird die Anfrage mit `409` und `data.code` `monitorAlreadyExists` abgewiesen. `data.existingId` und `data.existingPublicId` nennen den vorhandenen Monitor. Mit `"allowDuplicate": true` wird der zweite Monitor trotzdem angelegt (zum Beispiel mit anderem Intervall oder anderen Alarmwegen). - `allowDuplicate` (boolean, optional, Standard `false`): Monitor auch als Duplikat anlegen. Wird nicht gespeichert. ```json { "statusCode": 409, "statusMessage": "A monitor for this target already exists for this customer. Send allowDuplicate: true to create it anyway.", "data": { "code": "monitorAlreadyExists", "existingId": 300, "existingPublicId": "44444444-4444-4444-8444-444444444444" } } ``` ### Grenze je Ziel-Host Eine Organisation kann höchstens 100 Monitore auf denselben Ziel-Host haben, gezählt über alle Monitortypen zusammen (Websites mit HTTP, Keyword, DNS-Website und Playwright mit echter URL, dazu TCP, ICMP, DNS, SSH, SMTP, FTP und IMAP/POP). Die Grenze schützt davor, dass die Checkflotte als Lastgenerator gegen fremde Hosts missbraucht wird. Verglichen wird der exakte Hostname: Gross- und Kleinschreibung, Port, Pfad und ein Punkt am Ende zählen nicht, `www.example.com` und `example.com` sind aber verschiedene Hosts. Ist die Grenze erreicht, wird die Anfrage mit `403` und `data.code` `targetHostMonitorLimitReached` abgewiesen. `data.host` nennt den normalisierten Host, `data.limit` die Grenze. `"allowDuplicate": true` hebt die Grenze nicht auf. Dieselbe Prüfung läuft, wenn ein PATCH den `hostname` ändert. Ein PATCH ohne Hostwechsel geht immer, vorhandene Monitore über der Grenze bleiben bestehen. Brauchst du eine höhere Grenze, wende dich an den Support. Unabhängig von deiner Organisation dürfen über alle Uptimeify-Kunden hinweg höchstens 300 Monitore auf denselben Host zeigen. Darüber wird die Anfrage mit `403` und `data.code` `targetHostPlatformLimitReached` abgewiesen; `data.host` und `data.limit` sind wie oben gesetzt, die Meldung verrät nicht, wie viele Monitore andere Organisationen haben. ```json { "statusCode…
### FTP Monitor löschen
URL: https://docs.uptimeify.io/de/api/monitors/ftp-monitors/delete-ftp-monitor
Description: Löscht einen FTP Monitor.
Summary: `DELETE /api/ftp-monitors/:ftpMonitorPublicId` ## Authentifizierung `Authorization: Bearer ` ## Parameter - `ftpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des FTP Monitors. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X DELETE \ "$BASE_URL/api/ftp-monitors/55555555-5555-4555-8555-555555555555" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "success": true } ``` ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` wenn du keine Schreibrechte hast (z.B. Global Supporter oder Read-only) - `404 FTP monitor not found` wenn der Monitor nicht existiert ## Berechtigungen Für die Rolle `readonly` gesperrt. Ein Nur-Lese-Zugang löscht keinen Monitor, gleich welcher Besitzklasse, und ein von ihm ausgestellter API-Token ebenso wenig: Ein Token erbt die Rolle seines Erstellers. Das Bearbeiten eines Monitors mit `self_service` bleibt dieser Rolle erlaubt. Kunden-gescopte Aufrufer bindet zusätzlich die Besitzklasse: Ein `managed`-Monitor wird mit `managed_by_organization` abgelehnt, solange der Kunde kein `canEditManaged` trägt.
### FTP Monitor abrufen
URL: https://docs.uptimeify.io/de/api/monitors/ftp-monitors/get-ftp-monitor
Description: Gibt Details zu einem FTP Monitor zurück.
Summary: `GET /api/ftp-monitors/:ftpMonitorPublicId` Die Response enthält nur den FTP-Monitor selbst und bettet keinen vollständigen Kunden-Datensatz ein. ## Authentifizierung `Authorization: Bearer ` ## Parameter - `ftpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des FTP Monitors. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET \ "$BASE_URL/api/ftp-monitors/55555555-5555-4555-8555-555555555555" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "id": 400, "organizationId": 1, "customerId": 10, "name": "Partner FTP", "hostname": "ftp.deinkunde.com", "port": 21, "status": "active", "checkInterval": 30, "timeoutSeconds": 30, "allowedCheckCountryCodes": null, "notificationPhoneNumber": null, "notificationEmail": null, "lastCheckedAt": null, "createdAt": "2026-02-25T10:00:00.000Z", "updatedAt": "2026-02-25T10:00:00.000Z", "config": { "user": "monitor", "password": "", "secure": false }, "ftpConfig": { "user": "monitor", "password": "", "secure": false } } ``` ## Häufige Fehler - `400 FTP monitor public ID (UUID) required` wenn `ftpMonitorPublicId` fehlt oder ungültig ist - `401 Unauthorized` wenn du nicht authentifiziert bist - `404 FTP monitor not found` wenn der Monitor nicht existiert **oder zu einem anderen Kunden oder einer anderen Organisation gehört** (beide Fälle sind absichtlich nicht unterscheidbar)
### FTP Monitor Alert-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/ftp-monitors/get-ftp-monitor-alert-history
Description: Gibt die Benachrichtigungs-/Eskalationsversuche (Alert-Historie) für Vorfälle eines FTP Monitors zurück.
Summary: `GET /api/ftp-monitors/:ftpMonitorPublicId/alert-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `ftpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des FTP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `sent` oder `failed`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `sentAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/ftp-monitors/11111111-1111-4111-8111-111111111111/alert-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 987, "incidentId": 123, "type": "slack", "status": "sent", "channelName": "Ops Slack", "channelType": "slack", "channelConfig": null, "sentAt": "2026-02-26T12:11:00.000Z", "errorMessage": null } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Jeder Eintrag ist ein Zustellversuch an einen Benachrichtigungskanal. `status` ist `sent` oder `failed` (bei Fehler ist `errorMessage` gesetzt); `channelType` ist der Kanaltyp (z. B. `email`, `slack`, `opsgenie`). Bei `channelConfig` sind Secrets geschwärzt. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 FTP monitor public ID (UUID) required` wenn `:ftpMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### FTP Monitor Check-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/ftp-monitors/get-ftp-monitor-check-history
Description: Gibt die letzten FTP-Check-Ergebnisse für einen Monitor zurück.
Summary: `GET /api/ftp-monitors/:ftpMonitorPublicId/check-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `ftpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des FTP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). Eine Seite zählt Prüfzyklen, nicht Zeilen: ein Zyklus hat eine Zeile je Standort. - `limit` (number, optional): Zyklen pro Seite (Default: `10`; Max `100`). Bei `format=csv` oder `download=1` gelten die Export-Defaults (Default `10000`, Max `50000` Zeilen). - `status` (string, optional): `success` oder `failure` (`failure` matcht auch `timeout`). Bei Minutenzeilen: kein Standort fehlgeschlagen bzw. mindestens einer. - `minMs` / `maxMs` (number, optional): Filter nach Response-Time-Bereich (`timingTotal`; bei Minutenzeilen der Minutendurchschnitt). - `from` / `to` (ISO-Datumsstring, optional): Filter nach `checkedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. ## cURL ```bash curl "https://YOUR_DOMAIN/api/ftp-monitors/44444444-4444-4444-8444-444444444444/check-history?page=1&limit=10" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "data": [ { "id": "33c53ac4-a2bc-475c-a904-8d3d6aab2979", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-10-01T05:40:55.690Z", "responseTimeMs": 29, "location": { "name": "Paris (FR)", "code": "par" }, "resolution": "raw" }, { "id": "1min-2026-09-30T15:55:00.000Z", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-09-30T15:55:00.000Z", "responseTimeMs": 54, "location": null, "resolution": "1min", "totalLocations": 2, "failedLocations": 0 } ], "total": 864, "page": 17, "pageCount": 87, "resolution": "mixed", "rawWindowFrom": "2026-09-30T16:00:00.000Z" } ``` - `resolution` je Zeile: `raw` ist eine einzelne Prüfung mit Standort und Fehlermeldung; `1min` ist eine Minute über alle Standorte, ohne Standort und Fehlermeldung, dafür mit `totalLocations` und `failedLocations`. - `resolution` der Seite: `raw`, `1min` oder `mixed` (die Seite liegt über der Grenze). - `rawWindowFrom`: ab hier gibt es einzelne Prüfungen; ältere Zeilen sind Minutenzeilen. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. CSV-Spalten: `checkedAt,status,responseTimeMs,location,errorMessage,resolution`. ## Aufbewahrung Einzelne Prüfungen mit Standort und Fehlermeldung bleiben 24 Stunden erhalten. Ältere Einträge kommen aus den Minutenwerten (30 Tage), eine Zeile je Minute ohne Standort und Fehlermeldung. Tageswerte (24 Monate) stehen in den Monitor-Details. ## Häufige Fehler - `400 FTP monitor public ID (UUID) required` wenn `ftpMonitorPublicId` fehlt oder ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status`, `minMs` oder `maxMs` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` wenn du keinen Zugriff hast - `404 FTP monitor not found` wenn der Monitor nicht existiert
### FTP Monitor Details abrufen
URL: https://docs.uptimeify.io/de/api/monitors/ftp-monitors/get-ftp-monitor-details
Description: Gibt die FTP-Monitor-Detailseiten-Daten in einem Call zurück (Mega-Endpoint).
Summary: `GET /api/ftp-monitors/:ftpMonitorPublicId/details` ## Authentifizierung `Authorization: Bearer ` ## Parameter - `ftpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des FTP Monitors. ## Query Parameter - `range` (optional): `day` (default), `week`, `month`, `year` - `date` (optional): Referenzdatum (ISO String) - `startDate` / `endDate` (optional): Überschreibt das Zeitfenster (ISO Strings) - `granularity` (optional): Wenn weggelassen, kann der Server bei großen Zeiträumen automatisch aggregieren. Nutze `granularity=raw`, um Raw-Daten zu erzwingen. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET \ "$BASE_URL/api/ftp-monitors/55555555-5555-4555-8555-555555555555/details?range=day" \ -H "Authorization: Bearer $TOKEN" ``` ## Beispiel Response (Shape) Die Response ist ein einzelnes Objekt mit diesen Top-Level Keys: ```json { "ftpMonitorId": 400, "monitor": {}, "latestCheck": {}, "uptimeStats": { "day": "100.00", "month": "100.00", "year": "100.00", "dayAvgResponse": 120, "monthAvgResponse": 130, "yearAvgResponse": 140 }, "uptimeStatsMeta": {}, "monitoringData": { "responseTimeData": [], "statusData": [], "uptimePercentage": "100.00", "checkSuccessRatePercentage": "100.00", "totalChecks": 10, "successfulChecks": 10 }, "incidents": { "history": [], "total": 0, "ongoing": 0, "totalDowntime": "0s" }, "alerts": { "history": [], "total": 0, "notificationContext": {} }, "testResultLog": null, "maintenance": { "inMaintenance": false, "activeWindows": [], "allWindows": [] } } ``` ## Aufbewahrung Einzelne Prüfungen bleiben 24 Stunden erhalten, Minutenwerte 30 Tage und Tageswerte 24 Monate; ein Zeitraum, der älter als 30 Tage ist, liefert einen Punkt pro Tag. Hat der Monitor in den letzten 24 Stunden nicht geprüft, beschreibt `latestCheck` seine letzte Minute aus dem Aggregat: `id` beginnt mit `1min-`, `resolution` ist `1min`, `locationId` und `errorMessage` sind `null`. ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `range` nicht `day`/`week`/`month`/`year` ist, `date`/`startDate`/`endDate` kein Datum ist, nur eines von `startDate`/`endDate` kommt, `tz` keine Ganzzahl ist oder `granularity` weder `raw` noch `aggregated` - `400 Invalid FTP monitor public ID (UUID)` wenn `ftpMonitorPublicId` ungültig ist - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` wenn du keinen Zugriff hast - `500 Failed to fetch FTP monitor details` bei Serverfehlern
### FTP Monitor Ausfall-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/ftp-monitors/get-ftp-monitor-incident-history
Description: Gibt die Vorfälle eines einzelnen FTP Monitors zurück (die letzten 100), inklusive berechneter Dauer.
Summary: `GET /api/ftp-monitors/:ftpMonitorPublicId/incident-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `ftpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des FTP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `open`, `acknowledged` oder `resolved`. - `type` (string, optional): `downtime`, `http_status`, `ssl_expiry`, `ssl_critical`, `ssl_warning`, `response_time`, `dnsbl`, `domain_expiry_warning`, `critical` oder `inconclusive`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `startedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/ftp-monitors/11111111-1111-4111-8111-111111111111/incident-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 123, "publicId": "55555555-5555-4555-8555-555555555555", "type": "downtime", "status": "resolved", "startedAt": "2026-02-26T12:10:00.000Z", "endedAt": "2026-02-26T12:12:30.000Z", "durationMs": 150000, "statusCode": null, "errorMessage": "connect ETIMEDOUT", "details": "connect ETIMEDOUT", "isOngoing": false } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. **Abgelöstes Feld:** `duration` (Text, z. B. `2m 30s`) wird bis zum Entfall am 18.01.2027 weiter neben `durationMs` geliefert. Lies `durationMs`. `status` ist `open`, `acknowledged` oder `resolved`. Laufende Vorfälle haben ein `null` bei `endedAt` und `isOngoing: true`. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 FTP monitor public ID (UUID) required` wenn `:ftpMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` oder `type` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### FTP Monitore auflisten
URL: https://docs.uptimeify.io/de/api/monitors/ftp-monitors/list-ftp-monitors
Description: Listet FTP Monitore einer Organisation auf.
Summary: `GET /api/ftp-monitors` ## Authentifizierung `Authorization: Bearer ` ## Parameter - `organizationId` (Query, optional): Organisations-ID. Default ist die Organisation des aktuellen Nutzers. - `customerId` (Query, optional): Nach Kunden-ID filtern. - `search` (Query, optional): Suche nach Name, Hostname oder Kunde. - `page` (Query, optional): Seite (Default: 1). - `perPage` (Query, optional): Einträge pro Seite (Default: 50, Max: 200). Hinweis: Die Ergebnisse sind zusätzlich durch deinen Customer-Scope begrenzt (falls dein Account auf eine Teilmenge von Kunden eingeschränkt ist). ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET \ "$BASE_URL/api/ftp-monitors?page=1&perPage=50&search=ftp" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "items": [ { "id": 400, "organizationId": 1, "customerId": 10, "customerName": "Example Customer", "name": "Partner FTP", "hostname": "ftp.deinkunde.com", "port": 21, "status": "active", "checkInterval": 30, "timeoutSeconds": 30, "allowedCheckCountryCodes": null, "config": { "user": "monitor", "password": "", "secure": false }, "notificationPhoneNumber": null, "notificationEmail": null, "lastCheckedAt": null, "createdAt": "2026-02-25T10:00:00.000Z", "updatedAt": "2026-02-25T10:00:00.000Z" } ], "total": 1, "page": 1, "perPage": 50 } ``` Jedes Item enthält den FTP-Monitor selbst und ein flaches `customerName`, aber keinen vollständig eingebetteten Kunden-Datensatz. ## Inline-Metriken Jeder Eintrag traegt dieselben verdichteten Kennzahlen, die auch die uebrigen Monitor-Listen liefern. Sie werden je Monitor ueber den Kalendertag, den Monat und das Jahr in UTC gebildet. | Feld | Typ | Bedeutung | |------|-----|-----------| | `uptimeDay` / `uptimeMonth` / `uptimeYear` | string | Verfuegbarkeit in Prozent mit zwei Nachkommastellen, z. B. `"99.94"` | | `avgResponseDay` / `avgResponseMonth` / `avgResponseYear` | number \| null | Mittlere Antwortzeit in Millisekunden; `null`, wenn in dem Fenster nichts gemessen wurde | | `responseGraph` | object | `{ values, avg }` fuer die letzten 24 Stunden, ein Eintrag je Stunde; eine Stunde ohne erfolgreiche Pruefung ist `null` | | `upSinceAt` | string \| null | ISO-Zeitpunkt, seit dem der Monitor laeuft, `null` solange er ausgefallen ist | | `isDown` | boolean | Ob der Monitor gerade in einem unaufgeloesten Vorfall steckt | Die Tageswerte kommen aus den Rohdaten, Monat und Jahr aus fortlaufenden Aggregaten -- in diesen beiden Fenstern kann ein Wert der neuesten Pruefung daher um einige Minuten hinterherhinken. ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `page` oder `perPage` keine positive Ganzzahl ist, `sortOrder` weder `asc` noch `desc` oder `tags` keine kommagetrennte Liste von Tag-IDs - `400 Invalid organizationId` wenn `organizationId` keine gültige Zahl ist - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` wenn du keinen Zugriff auf die Organisation hast
### FTP Check triggern
URL: https://docs.uptimeify.io/de/api/monitors/ftp-monitors/trigger-check-ftp-monitor
Description: Startet einen sofortigen Check von allen zulässigen Monitoring-Standorten.
Summary: `POST /api/ftp-monitors/:ftpMonitorPublicId/trigger-check` ## Authentifizierung `Authorization: Bearer ` ## Parameter - `ftpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des FTP Monitors. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST \ "$BASE_URL/api/ftp-monitors/55555555-5555-4555-8555-555555555555/trigger-check" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "success": true, "message": "Checks triggered successfully", "ftpMonitorId": 400, "locationCodes": ["de-nbg", "fi-hel"], "queueNames": ["ftp-monitor-checks-de-nbg", "ftp-monitor-checks-fi-hel"] } ``` ## Häufige Fehler - `400 FTP monitor public ID (UUID) required` wenn `ftpMonitorPublicId` fehlt oder ungültig ist - `400 No eligible monitoring locations for the selected allowed countries` wenn deine Country-Restriction keine aktiven Locations matched - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` wenn du keine Schreibrechte hast - `503 No active monitoring locations available` wenn keine Worker-Locations aktiv sind
### FTP Monitor aktualisieren (Status ändern)
URL: https://docs.uptimeify.io/de/api/monitors/ftp-monitors/update-ftp-monitor
Description: Aktualisiert einen FTP Monitor und/oder ändert den Status.
Summary: `PATCH /api/ftp-monitors/:ftpMonitorPublicId` ## Authentifizierung `Authorization: Bearer ` ## Parameter - `ftpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des FTP Monitors. ## Request Body - `status` (optional): `active`, `maintenance`, `disabled` (akzeptiert auch `inactive`/`paused` und normalisiert zu `disabled`) - `customerId` (optional, number): Muss zur selben Organisation gehören - `name` (optional, string) - `hostname` (optional, string): Muss ein Hostname sein (kein Protokoll, kein Pfad) - `port` (optional, number | null) - `checkInterval` (optional, number) - `timeoutSeconds` (optional, number) - `allowedCheckCountryCodes` (optional, string[] | null): ISO-3166-1 alpha-2, z.B. `"DE"`, `"ES"` - `checkMode` (optional, string): `protocol` (Standard) | `tcp`. Beim Wechsel zu `tcp` werden gespeicherte Zugangsdaten gelöscht: der Monitor führt nur eine reine TCP-Port-Erreichbarkeitsprüfung durch und `ftpConfig` wird nicht gespeichert. Beim Zurückwechseln zu `protocol` läuft wieder die vollständige FTP-Login-Prüfung; neue Zugangsdaten über `ftpConfig`/`config` mitschicken. - `ftpConfig` (optional, object): Ersetzt die gespeicherte FTP-Config (JSON) - `config` (optional, object): Alias von `ftpConfig` Hinweis: Read-only Nutzer dürfen nur `status` ändern. Hinweis: Wenn du `ftpConfig`/`config` weglässt, bleibt die bestehende Config unverändert. ```json { "status": "maintenance" } ``` ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X PATCH \ "$BASE_URL/api/ftp-monitors/55555555-5555-4555-8555-555555555555" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"status":"active","allowedCheckCountryCodes":["DE","ES"],"ftpConfig":{"user":"monitor","password":"","secure":false}}' ``` ## Response ```json { "id": 400, "status": "maintenance", "config": {}, "ftpConfig": {} } ``` ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `name` kein nicht-leerer String mit höchstens 255 Zeichen ist oder `allowedCheckCountryCodes` weder ein Array von Ländercodes noch `null` - `400 Bad Request` (`invalidTimeoutSeconds`) wenn `timeoutSeconds` keine Ganzzahl zwischen 1 und 60 ist - `400 Bad Request` (`invalidConfig`) wenn ein Config-Feld (`config` oder das typspezifische) kein Objekt ist - `400 Invalid status` wenn `status` ungültig ist - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` wenn du keine Schreibrechte hast (z.B. Read-only versucht andere Felder zu ändern, oder Global Supporter) - `404 FTP monitor not found` wenn der Monitor nicht existiert
### ICMP Monitore
URL: https://docs.uptimeify.io/de/api/monitors/icmp-monitors
Description: Verwalte ICMP (Ping) Monitore.
Summary: Pfadbasierte ICMP-Monitor-Endpunkte verwenden `icmpMonitorPublicId`-UUIDs. ## Endpunkte - [ICMP Monitore auflisten](/de/api/monitors/icmp-monitors/list-icmp-monitors) - [ICMP Monitor erstellen](/de/api/monitors/icmp-monitors/create-icmp-monitor) - [ICMP Monitor abrufen](/de/api/monitors/icmp-monitors/get-icmp-monitor) - [ICMP Monitor Details abrufen](/de/api/monitors/icmp-monitors/get-icmp-monitor-details) - [ICMP Monitor Check-Historie abrufen](/de/api/monitors/icmp-monitors/get-icmp-monitor-check-history) - [ICMP Monitor aktualisieren](/de/api/monitors/icmp-monitors/update-icmp-monitor) - [ICMP Monitor löschen](/de/api/monitors/icmp-monitors/delete-icmp-monitor) - [ICMP Check triggern](/de/api/monitors/icmp-monitors/trigger-check-icmp-monitor)
### ICMP Monitor erstellen
URL: https://docs.uptimeify.io/de/api/monitors/icmp-monitors/create-icmp-monitor
Description: Erstellt einen neuen ICMP Monitor.
Summary: `POST /api/icmp-monitors` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Request Body ```json { "customerId": "6764e84f-f02a-43e6-a46d-cecaec556723", "name": "Ping Gateway", "hostname": "claas.sh", "status": "active", "checkInterval": 5, "timeoutSeconds": 10, "icmpConfig": { "packetSize": 56, "count": 4 } } ``` ### Felder - `customerId` (number | string, required) - Akzeptiert die interne numerische Kunden-ID oder die Customer-`publicId`-UUID. - `name` (string, required) - `hostname` (string, required) - Muss nur Hostname oder IP sein (kein Protokoll wie `https://`, kein Pfad wie `/ping`). - `status` (string, optional) - Erlaubt: `active`, `maintenance`, `disabled`, `paused`, `inactive` - Hinweis: `paused` / `inactive` werden zu `disabled` normalisiert. - `checkInterval` (number, optional) - `timeoutSeconds` (number, optional) - `icmpConfig` (object, optional) - Wird als `config` JSON am Monitor gespeichert. ### `icmpConfig` (vom Worker unterstützte Keys) - `packetSize` (number) - Default: `56` - `count` (number) - Default: `3` ### Duplikate Hat dieser Kunde schon einen Monitor mit derselbe `hostname` (Gross- und Kleinschreibung und ein Punkt am Ende zählen nicht), wird die Anfrage mit `409` und `data.code` `monitorAlreadyExists` abgewiesen. `data.existingId` und `data.existingPublicId` nennen den vorhandenen Monitor. Mit `"allowDuplicate": true` wird der zweite Monitor trotzdem angelegt (zum Beispiel mit anderem Intervall oder anderen Alarmwegen). - `allowDuplicate` (boolean, optional, Standard `false`): Monitor auch als Duplikat anlegen. Wird nicht gespeichert. ```json { "statusCode": 409, "statusMessage": "A monitor for this target already exists for this customer. Send allowDuplicate: true to create it anyway.", "data": { "code": "monitorAlreadyExists", "existingId": 300, "existingPublicId": "44444444-4444-4444-8444-444444444444" } } ``` ### Grenze je Ziel-Host Eine Organisation kann höchstens 100 Monitore auf denselben Ziel-Host haben, gezählt über alle Monitortypen zusammen (Websites mit HTTP, Keyword, DNS-Website und Playwright mit echter URL, dazu TCP, ICMP, DNS, SSH, SMTP, FTP und IMAP/POP). Die Grenze schützt davor, dass die Checkflotte als Lastgenerator gegen fremde Hosts missbraucht wird. Verglichen wird der exakte Hostname: Gross- und Kleinschreibung, Port, Pfad und ein Punkt am Ende zählen nicht, `www.example.com` und `example.com` sind aber verschiedene Hosts. Ist die Grenze erreicht, wird die Anfrage mit `403` und `data.code` `targetHostMonitorLimitReached` abgewiesen. `data.host` nennt den normalisierten Host, `data.limit` die Grenze. `"allowDuplicate": true` hebt die Grenze nicht auf. Dieselbe Prüfung läuft, wenn ein PATCH den `hostname` ändert. Ein PATCH ohne Hostwechsel geht immer, vorhandene Monitore über der Grenze bleiben bestehen. Brauchst du eine höhere Grenze, wende dich an den Support. Unabhängig von deiner Organisation dürfen über alle Uptimeify-Kunden hinweg höchstens 300 Monitore auf denselben Host zeigen. Darüber wird die Anfrage mit `403` und `data.code` `targetHostPlatformLimitReached` abgewiesen; `data.host` und `data.limit` sind wie oben gesetzt, die Meldung verrät nicht, wie viele Monitore andere Organisationen haben. ```json { "statusCode": 403, "statusMessage": "Target host monitor limit reached: your organization already has 100 monitors for example.com (maximum 100 per host). Remove monitors for this host or contact support to raise the limit.", "data": { "code": "targetHostMonitorLimitReached", "host": "example.com", "limit": 100 } } ``` ## cURL ```bash curl -X POST "https://YOUR_DOMAIN/api/icmp-monitors" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "customerId": "6764e84f-f02a-43e6-a46d-cecaec556723", "name": "Ping Gateway", "hostname": "claas.sh", "status": "active", "checkInterval": 5, "timeoutSeconds": 10, "icmpConfig": { "packetSize": 56, "count": 4 } }' ``` ## Response ```json { "id": 123, "org…
### ICMP Monitor löschen
URL: https://docs.uptimeify.io/de/api/monitors/icmp-monitors/delete-icmp-monitor
Description: Löscht einen ICMP Monitor.
Summary: `DELETE /api/icmp-monitors/:icmpMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `icmpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des ICMP Monitors. ## cURL ```bash curl -X DELETE "https://YOUR_DOMAIN/api/icmp-monitors/22222222-2222-4222-8222-222222222222" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "success": true } ``` ## Fehler - `400` ICMP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden (`readonlyMayNotDelete` bei einem Nur-Lese-Zugang, `managed_by_organization` bei einer verwalteten Ressource ohne `canEditManaged`) - `404` ICMP Monitor nicht gefunden ## Berechtigungen Für die Rolle `readonly` gesperrt. Ein Nur-Lese-Zugang löscht keinen Monitor, gleich welcher Besitzklasse, und ein von ihm ausgestellter API-Token ebenso wenig: Ein Token erbt die Rolle seines Erstellers. Das Bearbeiten eines Monitors mit `self_service` bleibt dieser Rolle erlaubt. Kunden-gescopte Aufrufer bindet zusätzlich die Besitzklasse: Ein `managed`-Monitor wird mit `managed_by_organization` abgelehnt, solange der Kunde kein `canEditManaged` trägt.
### ICMP Monitor abrufen
URL: https://docs.uptimeify.io/de/api/monitors/icmp-monitors/get-icmp-monitor
Description: Gibt Details zu einem ICMP Monitor zurück.
Summary: `GET /api/icmp-monitors/:icmpMonitorPublicId` Die Response enthält nur den ICMP-Monitor selbst und bettet keinen vollständigen Kunden-Datensatz ein. ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `icmpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des ICMP-Monitors. ## cURL ```bash curl "https://YOUR_DOMAIN/api/icmp-monitors/22222222-2222-4222-8222-222222222222" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "id": 123, "organizationId": 1, "customerId": 10, "name": "Core Router", "hostname": "10.0.0.1", "port": null, "status": "active", "checkInterval": 30, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "config": { "packetSize": 56, "count": 3 }, "notificationPhoneNumber": null, "notificationEmail": null, "lastCheckedAt": null, "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:00:00.000Z", "icmpConfig": { "packetSize": 56, "count": 3 } } ``` ## Fehler - `400` ICMP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `404` ICMP Monitor nicht gefunden wenn der Monitor nicht existiert **oder zu einem anderen Kunden oder einer anderen Organisation gehört** (beide Fälle sind absichtlich nicht unterscheidbar)
### ICMP Monitor Alert-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/icmp-monitors/get-icmp-monitor-alert-history
Description: Gibt die Benachrichtigungs-/Eskalationsversuche (Alert-Historie) für Vorfälle eines ICMP Monitors zurück.
Summary: `GET /api/icmp-monitors/:icmpMonitorPublicId/alert-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `icmpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des ICMP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `sent` oder `failed`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `sentAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/icmp-monitors/11111111-1111-4111-8111-111111111111/alert-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 987, "incidentId": 123, "type": "slack", "status": "sent", "channelName": "Ops Slack", "channelType": "slack", "channelConfig": null, "sentAt": "2026-02-26T12:11:00.000Z", "errorMessage": null } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Jeder Eintrag ist ein Zustellversuch an einen Benachrichtigungskanal. `status` ist `sent` oder `failed` (bei Fehler ist `errorMessage` gesetzt); `channelType` ist der Kanaltyp (z. B. `email`, `slack`, `opsgenie`). Bei `channelConfig` sind Secrets geschwärzt. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 ICMP monitor public ID (UUID) required` wenn `:icmpMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### ICMP Monitor Check-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/icmp-monitors/get-icmp-monitor-check-history
Description: Gibt die letzten Check-Ergebnisse für den ICMP Monitor zurück.
Summary: `GET /api/icmp-monitors/:icmpMonitorPublicId/check-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `icmpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des ICMP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). Eine Seite zählt Prüfzyklen, nicht Zeilen: ein Zyklus hat eine Zeile je Standort. - `limit` (number, optional): Zyklen pro Seite (Default: `10`; Max `100`). Bei `format=csv` oder `download=1` gelten die Export-Defaults (Default `10000`, Max `50000` Zeilen). - `status` (string, optional): `success` oder `failure` (`failure` matcht auch `timeout`). Bei Minutenzeilen: kein Standort fehlgeschlagen bzw. mindestens einer. - `minMs` / `maxMs` (number, optional): Filter nach Response-Time-Bereich (`timingTotal`; bei Minutenzeilen der Minutendurchschnitt). - `from` / `to` (ISO-Datumsstring, optional): Filter nach `checkedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. ## cURL ```bash curl "https://YOUR_DOMAIN/api/icmp-monitors/44444444-4444-4444-8444-444444444444/check-history?page=1&limit=10" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "data": [ { "id": "33c53ac4-a2bc-475c-a904-8d3d6aab2979", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-10-01T05:40:55.690Z", "responseTimeMs": 29, "location": { "name": "Paris (FR)", "code": "par" }, "resolution": "raw" }, { "id": "1min-2026-09-30T15:55:00.000Z", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-09-30T15:55:00.000Z", "responseTimeMs": 54, "location": null, "resolution": "1min", "totalLocations": 2, "failedLocations": 0 } ], "total": 864, "page": 17, "pageCount": 87, "resolution": "mixed", "rawWindowFrom": "2026-09-30T16:00:00.000Z" } ``` - `resolution` je Zeile: `raw` ist eine einzelne Prüfung mit Standort und Fehlermeldung; `1min` ist eine Minute über alle Standorte, ohne Standort und Fehlermeldung, dafür mit `totalLocations` und `failedLocations`. - `resolution` der Seite: `raw`, `1min` oder `mixed` (die Seite liegt über der Grenze). - `rawWindowFrom`: ab hier gibt es einzelne Prüfungen; ältere Zeilen sind Minutenzeilen. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. CSV-Spalten: `checkedAt,status,responseTimeMs,location,errorMessage,resolution`. ## Aufbewahrung Einzelne Prüfungen mit Standort und Fehlermeldung bleiben 24 Stunden erhalten. Ältere Einträge kommen aus den Minutenwerten (30 Tage), eine Zeile je Minute ohne Standort und Fehlermeldung. Tageswerte (24 Monate) stehen in den Monitor-Details. ## Fehler - `400` ICMP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden - `404` ICMP Monitor nicht gefunden ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status`, `minMs` oder `maxMs` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist
### ICMP Monitor Details abrufen
URL: https://docs.uptimeify.io/de/api/monitors/icmp-monitors/get-icmp-monitor-details
Description: Gibt ein konsolidiertes Payload zurück, das in der Monitor-Detailseite verwendet wird (u. a. Monitor, letzter Check, aggregierte Daten im Zeitbereich).
Summary: `GET /api/icmp-monitors/:icmpMonitorPublicId/details` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `icmpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des ICMP Monitors. ### Time-Range Query-Parameter Der Zeitbereich kann auf mehrere Arten definiert werden. Nutze die einfachste Option für deinen Use-Case: - `range` (Query, optional): Preset-Zeitraum. - Erlaubt: `day` (Default), `week`, `month`, `year` - `date` (Query, optional): Referenzdatum, das als Default-Ende verwendet wird. - Beispiel: `2026-02-26` - `startDate` (Query, optional): Startdatum/-zeit. - `endDate` (Query, optional): Enddatum/-zeit. - `granularity` (Query, optional): Steuert Aggregation. - Nutze `raw`, um Aggregation zu deaktivieren. - Jeder andere Wert aktiviert Aggregation. - Wenn nicht gesetzt, aggregiert der Server ggf. automatisch bei größeren Zeitbereichen. ## cURL ```bash curl -X GET "https://YOUR_DOMAIN/api/icmp-monitors/22222222-2222-4222-8222-222222222222/details?range=day&granularity=raw" \ -H "Authorization: Bearer $TOKEN" ``` ## Response Top-Level Felder (aktueller Stand): - `icmpMonitorId` - `monitor` - `latestCheck` - `uptimeStats`, `uptimeStatsMeta` - `monitoringData` - `incidents` - `alerts` - `testResultLog` - `maintenance` Beispiel: ```json { "icmpMonitorId": 123, "monitor": { "id": 123, "customerId": 10, "organizationId": 1, "name": "Core Router", "hostname": "10.0.0.1", "status": "active", "checkInterval": 30, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "port": null, "config": { "packetSize": 56, "count": 3 }, "notificationPhoneNumber": null, "notificationEmail": null, "lastCheckedAt": null, "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:00:00.000Z" }, "latestCheck": null, "uptimeStats": { "day": "100.00", "month": "100.00", "year": "100.00", "dayAvgResponse": 22, "monthAvgResponse": 22, "yearAvgResponse": 22 }, "uptimeStatsMeta": { "day": { "window": "24h", "downtimeMinutes": 0, "incidents": 0, "checksTotal": 24, "checksFailed": 0 }, "month": { "window": "30d", "downtimeMinutes": 0, "incidents": 0, "checksTotal": 720, "checksFailed": 0 }, "year": { "window": "YTD", "downtimeMinutes": 0, "incidents": 0, "checksTotal": 1000, "checksFailed": 0 } }, "monitoringData": { "responseTimeData": [ { "timestamp": "2026-02-26T12:00:00.000Z", "responseTime": 22, "status": "success", "success": true, "timingDns": 0, "timingTcp": 22, "timingTls": 0, "timingTtfb": 0, "timingTransfer": 0 } ], "statusData": [{ "date": "26.02", "status": "online" }], "uptimePercentage": "100.00", "checkSuccessRatePercentage": "100.00", "totalChecks": 100, "successfulChecks": 100 }, "incidents": { "history": [], "total": 0, "ongoing": 0, "totalDowntime": "0s" }, "alerts": { "history": [], "total": 0, "notificationContext": { "orgDefaultEmail": null, "orgDefaultPhoneNumber": null, "customerEmail": null, "notificationTargets": [] } }, "testResultLog": [], "maintenance": { "inMaintenance": false, "activeWindows": [], "allWindows": [] } } ``` ## Aufbewahrung Einzelne Prüfungen bleiben 24 Stunden erhalten, Minutenwerte 30 Tage und Tageswerte 24 Monate; ein Zeitraum, der älter als 30 Tage ist, liefert einen Punkt pro Tag. Hat der Monitor in den letzten 24 Stunden nicht geprüft, beschreibt `latestCheck` seine letzte Minute aus dem Aggregat: `id` beginnt mit `1min-`, `resolution` ist `1min`, `locationId` und `errorMessage` sind `null`. ## Fehler - `400` Ungültige ICMP Monitor Public ID (UUID) - `401` Unauthorized - `403` Forbidden - `404` ICMP Monitor nicht gefunden - `500` Failed to fetch ICMP monitor details ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `range` nicht `day`/`week`/`month`/`year` ist, `date`/`startDate`/`endDate` kein Datum ist, nur eines von `startDate`/`endDate` kommt, `tz` keine Ganzzahl ist oder `granularity` weder `raw` noch `aggregated`
### ICMP Monitor Ausfall-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/icmp-monitors/get-icmp-monitor-incident-history
Description: Gibt die Vorfälle eines einzelnen ICMP Monitors zurück (die letzten 100), inklusive berechneter Dauer.
Summary: `GET /api/icmp-monitors/:icmpMonitorPublicId/incident-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `icmpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des ICMP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `open`, `acknowledged` oder `resolved`. - `type` (string, optional): `downtime`, `http_status`, `ssl_expiry`, `ssl_critical`, `ssl_warning`, `response_time`, `dnsbl`, `domain_expiry_warning`, `critical` oder `inconclusive`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `startedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/icmp-monitors/11111111-1111-4111-8111-111111111111/incident-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 123, "publicId": "55555555-5555-4555-8555-555555555555", "type": "downtime", "status": "resolved", "startedAt": "2026-02-26T12:10:00.000Z", "endedAt": "2026-02-26T12:12:30.000Z", "durationMs": 150000, "statusCode": null, "errorMessage": "connect ETIMEDOUT", "details": "connect ETIMEDOUT", "isOngoing": false } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. **Abgelöstes Feld:** `duration` (Text, z. B. `2m 30s`) wird bis zum Entfall am 18.01.2027 weiter neben `durationMs` geliefert. Lies `durationMs`. `status` ist `open`, `acknowledged` oder `resolved`. Laufende Vorfälle haben ein `null` bei `endedAt` und `isOngoing: true`. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 ICMP monitor public ID (UUID) required` wenn `:icmpMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` oder `type` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### ICMP Monitore auflisten
URL: https://docs.uptimeify.io/de/api/monitors/icmp-monitors/list-icmp-monitors
Description: Listet ICMP Monitore einer Organisation auf.
Summary: `GET /api/icmp-monitors` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `organizationId` (Query, optional): Organisations-ID. Default ist die Organisation des aktuellen Nutzers. - `customerId` (Query, optional): Nach Kunden-ID filtern. - `search` (Query, optional): Suche nach Name, Hostname oder Kunde. - `page` (Query, optional): Seite (Default: 1). - `perPage` (Query, optional): Einträge pro Seite (Default: 50, Max: 200). ## cURL ```bash curl "https://YOUR_DOMAIN/api/icmp-monitors?page=1&perPage=50" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "items": [ { "id": 123, "organizationId": 1, "customerId": 10, "customerName": "Example Customer", "name": "Core Router", "hostname": "10.0.0.1", "status": "active", "checkInterval": 30, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "port": null, "config": { "packetSize": 56, "count": 3 }, "notificationPhoneNumber": null, "notificationEmail": null, "lastCheckedAt": null, "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:00:00.000Z" } ], "total": 1, "page": 1, "perPage": 50 } ``` Jedes Item enthält den ICMP-Monitor selbst und ein flaches `customerName`, aber keinen vollständig eingebetteten Kunden-Datensatz. ## Inline-Metriken Jeder Eintrag traegt dieselben verdichteten Kennzahlen, die auch die uebrigen Monitor-Listen liefern. Sie werden je Monitor ueber den Kalendertag, den Monat und das Jahr in UTC gebildet. | Feld | Typ | Bedeutung | |------|-----|-----------| | `uptimeDay` / `uptimeMonth` / `uptimeYear` | string | Verfuegbarkeit in Prozent mit zwei Nachkommastellen, z. B. `"99.94"` | | `avgResponseDay` / `avgResponseMonth` / `avgResponseYear` | number \| null | Mittlere Antwortzeit in Millisekunden; `null`, wenn in dem Fenster nichts gemessen wurde | | `responseGraph` | object | `{ values, avg }` fuer die letzten 24 Stunden, ein Eintrag je Stunde; eine Stunde ohne erfolgreiche Pruefung ist `null` | | `upSinceAt` | string \| null | ISO-Zeitpunkt, seit dem der Monitor laeuft, `null` solange er ausgefallen ist | | `isDown` | boolean | Ob der Monitor gerade in einem unaufgeloesten Vorfall steckt | Die Tageswerte kommen aus den Rohdaten, Monat und Jahr aus fortlaufenden Aggregaten -- in diesen beiden Fenstern kann ein Wert der neuesten Pruefung daher um einige Minuten hinterherhinken. ## Fehler - `400` Ungültige Query-Parameter (z. B. `organizationId`, `customerId`) - `401` Unauthorized - `403` Forbidden ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `page` oder `perPage` keine positive Ganzzahl ist, `sortOrder` weder `asc` noch `desc` oder `tags` keine kommagetrennte Liste von Tag-IDs
### ICMP Check triggern
URL: https://docs.uptimeify.io/de/api/monitors/icmp-monitors/trigger-check-icmp-monitor
Description: Startet einen sofortigen Check von allen zulässigen Monitoring-Standorten.
Summary: `POST /api/icmp-monitors/:icmpMonitorPublicId/trigger-check` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `icmpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des ICMP Monitors. ## cURL ```bash curl -X POST "https://YOUR_DOMAIN/api/icmp-monitors/22222222-2222-4222-8222-222222222222/trigger-check" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "success": true, "message": "Checks triggered successfully", "icmpMonitorId": 123, "locationCodes": ["de-nbg", "fi-hel"], "queueNames": ["icmp-monitor-checks-de-nbg", "icmp-monitor-checks-fi-hel"] } ``` ## Fehler - `400` ICMP Monitor Public ID (UUID) erforderlich oder keine zulässigen Standorte - `401` Unauthorized - `403` Forbidden - `404` ICMP Monitor nicht gefunden - `503` Keine aktiven Monitoring-Standorte verfügbar - `500` Failed to trigger check
### ICMP Monitor aktualisieren
URL: https://docs.uptimeify.io/de/api/monitors/icmp-monitors/update-icmp-monitor
Description: Aktualisiert einen ICMP Monitor. Dieser Endpunkt wird auch genutzt, um den Status zu wechseln.
Summary: `PATCH /api/icmp-monitors/:icmpMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `icmpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des ICMP Monitors. ## Request Body Alle Felder sind optional. - `status` (optional) - Erlaubt: `active`, `maintenance`, `disabled`, `paused`, `inactive` - Hinweis: `paused` / `inactive` werden zu `disabled` normalisiert. - `name`, `hostname`, `checkInterval`, `timeoutSeconds` (optional) - `port` (optional) - Wird von der API akzeptiert, aktuell aber nicht vom ICMP Worker genutzt. - `allowedCheckCountryCodes` (optional) - Wird auf Großbuchstaben normalisiert und dedupliziert. - `icmpConfig` (optional) - Alias für das gespeicherte `config` JSON. - `config` (optional) - Alternative Möglichkeit, das gleiche gespeicherte `config` JSON zu aktualisieren. Hinweis: Read-only Nutzer dürfen nur `status` ändern (und das Senden anderer Felder führt zu `403`). ```json { "status": "maintenance", "allowedCheckCountryCodes": ["DE", "ES"] } ``` Beispiel Konfiguration aktualisieren: ```json { "icmpConfig": { "packetSize": 56, "count": 3 } } ``` ## cURL ```bash curl -X PATCH "https://YOUR_DOMAIN/api/icmp-monitors/22222222-2222-4222-8222-222222222222" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "status": "disabled" }' ``` ## Response ```json { "id": 123, "status": "maintenance", "organizationId": 1, "customerId": 10, "name": "Core Router", "hostname": "10.0.0.1", "port": null, "checkInterval": 30, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE", "ES"], "notificationPhoneNumber": null, "notificationEmail": null, "lastCheckedAt": null, "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:05:00.000Z", "config": { "packetSize": 56, "count": 3 }, "icmpConfig": { "packetSize": 56, "count": 3 } } ``` ## Fehler - `400` Ungültiger Request Body, ungültiger Status oder ungültiger Hostname - `401` Unauthorized - `403` Forbidden (z. B. `readonly` oder global supporter) - `404` ICMP Monitor nicht gefunden ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `name` kein nicht-leerer String mit höchstens 255 Zeichen ist oder `allowedCheckCountryCodes` weder ein Array von Ländercodes noch `null` - `400 Bad Request` (`invalidTimeoutSeconds`) wenn `timeoutSeconds` keine Ganzzahl zwischen 1 und 60 ist - `400 Bad Request` (`invalidConfig`) wenn ein Config-Feld (`config` oder das typspezifische) kein Objekt ist
### IMAP/POP Monitore
URL: https://docs.uptimeify.io/de/api/monitors/imap-pop-monitors
Description: Verwalte IMAP/POP Monitore.
Summary: Pfadbasierte IMAP/POP-Monitor-Endpunkte verwenden `imapPopMonitorPublicId`-UUIDs. ## Endpunkte - [IMAP/POP Monitore auflisten](/de/api/monitors/imap-pop-monitors/list-imap-pop-monitors) - [IMAP/POP Monitor erstellen](/de/api/monitors/imap-pop-monitors/create-imap-pop-monitor) - [IMAP/POP Monitor abrufen](/de/api/monitors/imap-pop-monitors/get-imap-pop-monitor) - [IMAP/POP Monitor aktualisieren](/de/api/monitors/imap-pop-monitors/update-imap-pop-monitor) - [IMAP/POP Monitor löschen](/de/api/monitors/imap-pop-monitors/delete-imap-pop-monitor) - [IMAP/POP Check triggern](/de/api/monitors/imap-pop-monitors/trigger-check-imap-pop-monitor) - [IMAP/POP Monitor Details abrufen](/de/api/monitors/imap-pop-monitors/get-imap-pop-monitor-details) - [IMAP/POP Monitor Check Historie abrufen](/de/api/monitors/imap-pop-monitors/get-imap-pop-monitor-check-history)
### IMAP/POP Monitor erstellen
URL: https://docs.uptimeify.io/de/api/monitors/imap-pop-monitors/create-imap-pop-monitor
Description: Erstellt einen neuen IMAP/POP Monitor.
Summary: `POST /api/imap-pop-monitors` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Request Body ```json { "customerId": "11111111-1111-4111-8111-111111111111", "name": "Mailbox Access", "hostname": "mail.deinkunde.com", "port": 993, "status": "active", "checkInterval": 30, "timeoutSeconds": 30, "imapPopConfig": { "protocol": "imap", "user": "monitor@deinkunde.com", "password": "password", "tls": true, "tlsOptions": { "rejectUnauthorized": true } } } ``` ### Felder - `customerId` (number | string, required) - Akzeptiert entweder die interne numerische Kunden-ID oder die öffentliche Kunden-UUID. - `name` (string, required) - `hostname` (string, required) - Muss ein Hostname sein (kein Protokoll wie `https://`, kein Pfad wie `/imap`). - `port` (number | null, optional) - Wenn weggelassen oder `null`, wählt der Worker einen Default-Port abhängig von `imapPopConfig.protocol` und `imapPopConfig.tls`. - `status` (string, optional) - Erlaubt: `active`, `maintenance`, `disabled`, `paused`, `inactive` - Hinweis: `paused` / `inactive` werden zu `disabled` normalisiert. - `checkInterval` (number, optional) - `timeoutSeconds` (number, optional) - `checkMode` (string, optional) - Erlaubt: `protocol`, `tcp`. Standard: `protocol`. - Im Modus `tcp` führt der Monitor nur eine reine TCP-Port-Erreichbarkeitsprüfung durch: `imapPopConfig` ist nicht erforderlich und wird nicht gespeichert. Im Modus `protocol` läuft die vollständige IMAP/POP-Login-Prüfung (bisheriges Verhalten). - **`port` ist erforderlich, wenn `checkMode` `tcp` ist**. Ohne `port` schlägt der Request mit `400` / `data.code: "portRequiredForTcp"` fehl. - `imapPopConfig` (object, optional) - Wird als `config` JSON gespeichert. - Erforderlich (`user` + `password`), außer `checkMode` ist `tcp`. ### `imapPopConfig` (vom Worker unterstützte Keys) - `protocol` (`imap` | `pop3`) - Default: `imap` - `user` (string) - `password` (string) - `tls` (boolean) - Default: `false` - `tlsOptions.rejectUnauthorized` (boolean) - Wird von der IMAP Worker-Library genutzt; POP3 ignoriert diese Option aktuell. ### Default-Ports (Worker-Verhalten) Wenn `port` weggelassen oder `null` ist: - IMAP: - TLS (`tls: true`): `993` - Non-TLS (`tls: false`): `143` - POP3: - TLS (`tls: true`): `995` - Non-TLS (`tls: false`): `110` ### Duplikate Hat dieser Kunde schon einen Monitor mit derselbe `hostname` (Gross- und Kleinschreibung und ein Punkt am Ende zählen nicht), `port`, `checkMode` und `imapPopConfig.protocol`, wird die Anfrage mit `409` und `data.code` `monitorAlreadyExists` abgewiesen. `data.existingId` und `data.existingPublicId` nennen den vorhandenen Monitor. Mit `"allowDuplicate": true` wird der zweite Monitor trotzdem angelegt (zum Beispiel mit anderem Intervall oder anderen Alarmwegen). - `allowDuplicate` (boolean, optional, Standard `false`): Monitor auch als Duplikat anlegen. Wird nicht gespeichert. ```json { "statusCode": 409, "statusMessage": "A monitor for this target already exists for this customer. Send allowDuplicate: true to create it anyway.", "data": { "code": "monitorAlreadyExists", "existingId": 300, "existingPublicId": "44444444-4444-4444-8444-444444444444" } } ``` ### Grenze je Ziel-Host Eine Organisation kann höchstens 100 Monitore auf denselben Ziel-Host haben, gezählt über alle Monitortypen zusammen (Websites mit HTTP, Keyword, DNS-Website und Playwright mit echter URL, dazu TCP, ICMP, DNS, SSH, SMTP, FTP und IMAP/POP). Die Grenze schützt davor, dass die Checkflotte als Lastgenerator gegen fremde Hosts missbraucht wird. Verglichen wird der exakte Hostname: Gross- und Kleinschreibung, Port, Pfad und ein Punkt am Ende zählen nicht, `www.example.com` und `example.com` sind aber verschiedene Hosts. Ist die Grenze erreicht, wird die Anfrage mit `403` und `data.code` `targetHostMonitorLimitReached` abgewiesen. `data.host` nennt den normalisierten Host, `data.limit` die Grenze. `"allowDuplicate": true` hebt die Grenze nicht auf. Dieselbe Prüfung lä…
### IMAP/POP Monitor löschen
URL: https://docs.uptimeify.io/de/api/monitors/imap-pop-monitors/delete-imap-pop-monitor
Description: Löscht einen IMAP/POP Monitor.
Summary: `DELETE /api/imap-pop-monitors/:imapPopMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `imapPopMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des IMAP/POP Monitors. ## Response ```json { "success": true } ``` ## Errors - `400` IMAP/POP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden (z.B. `readonly` oder global supporter) - `404` IMAP/POP monitor not found ## Berechtigungen Für die Rolle `readonly` gesperrt. Ein Nur-Lese-Zugang löscht keinen Monitor, gleich welcher Besitzklasse, und ein von ihm ausgestellter API-Token ebenso wenig: Ein Token erbt die Rolle seines Erstellers. Das Bearbeiten eines Monitors mit `self_service` bleibt dieser Rolle erlaubt. Kunden-gescopte Aufrufer bindet zusätzlich die Besitzklasse: Ein `managed`-Monitor wird mit `managed_by_organization` abgelehnt, solange der Kunde kein `canEditManaged` trägt.
### IMAP/POP Monitor abrufen
URL: https://docs.uptimeify.io/de/api/monitors/imap-pop-monitors/get-imap-pop-monitor
Description: Gibt Details zu einem IMAP/POP Monitor zurück.
Summary: `GET /api/imap-pop-monitors/:imapPopMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `imapPopMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des IMAP/POP Monitors. ## cURL ```bash curl -X GET "https://YOUR_DOMAIN/api/imap-pop-monitors/66666666-6666-4666-8666-666666666666" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "id": 500, "organizationId": 1, "customerId": 10, "name": "Mailbox Access", "hostname": "mail.deinkunde.com", "port": 993, "checkInterval": 30, "timeoutSeconds": 30, "config": { "protocol": "imap", "user": "monitor@deinkunde.com", "password": "password", "tls": true }, "allowedCheckCountryCodes": null, "status": "active", "notificationPhoneNumber": null, "notificationEmail": null, "lastCheckedAt": null, "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:00:00.000Z", "customer": { "id": 10, "organizationId": 1, "name": "Example Customer", "email": "ops@deinkunde.com", "allowedCheckCountryCodes": null, "customFields": null, "alertLocationThresholdCount": 1, "createdAt": "2026-02-01T12:00:00.000Z", "updatedAt": "2026-02-01T12:00:00.000Z" }, "imapPopConfig": { "protocol": "imap", "user": "monitor@deinkunde.com", "password": "password", "tls": true } } ``` ## Errors - `400` IMAP/POP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `404` IMAP/POP monitor not found wenn der Monitor nicht existiert **oder zu einem anderen Kunden oder einer anderen Organisation gehört** (beide Fälle sind absichtlich nicht unterscheidbar)
### IMAP/POP Monitor Alert-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/imap-pop-monitors/get-imap-pop-monitor-alert-history
Description: Gibt die Benachrichtigungs-/Eskalationsversuche (Alert-Historie) für Vorfälle eines IMAP/POP Monitors zurück.
Summary: `GET /api/imap-pop-monitors/:imapPopMonitorPublicId/alert-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `imapPopMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des IMAP/POP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `sent` oder `failed`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `sentAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/imap-pop-monitors/11111111-1111-4111-8111-111111111111/alert-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 987, "incidentId": 123, "type": "slack", "status": "sent", "channelName": "Ops Slack", "channelType": "slack", "channelConfig": null, "sentAt": "2026-02-26T12:11:00.000Z", "errorMessage": null } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Jeder Eintrag ist ein Zustellversuch an einen Benachrichtigungskanal. `status` ist `sent` oder `failed` (bei Fehler ist `errorMessage` gesetzt); `channelType` ist der Kanaltyp (z. B. `email`, `slack`, `opsgenie`). Bei `channelConfig` sind Secrets geschwärzt. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 IMAP/POP monitor public ID (UUID) required` wenn `:imapPopMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### IMAP/POP Monitor Check Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/imap-pop-monitors/get-imap-pop-monitor-check-history
Description: Gibt die letzten Check-Ergebnisse für den IMAP/POP Monitor zurück.
Summary: `GET /api/imap-pop-monitors/:imapPopMonitorPublicId/check-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `imapPopMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des IMAP/POP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). Eine Seite zählt Prüfzyklen, nicht Zeilen: ein Zyklus hat eine Zeile je Standort. - `limit` (number, optional): Zyklen pro Seite (Default: `10`; Max `100`). Bei `format=csv` oder `download=1` gelten die Export-Defaults (Default `10000`, Max `50000` Zeilen). - `status` (string, optional): `success` oder `failure` (`failure` matcht auch `timeout`). Bei Minutenzeilen: kein Standort fehlgeschlagen bzw. mindestens einer. - `minMs` / `maxMs` (number, optional): Filter nach Response-Time-Bereich (`timingTotal`; bei Minutenzeilen der Minutendurchschnitt). - `from` / `to` (ISO-Datumsstring, optional): Filter nach `checkedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. ## cURL ```bash curl "https://YOUR_DOMAIN/api/imap-pop-monitors/44444444-4444-4444-8444-444444444444/check-history?page=1&limit=10" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "data": [ { "id": "33c53ac4-a2bc-475c-a904-8d3d6aab2979", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-10-01T05:40:55.690Z", "responseTimeMs": 29, "location": { "name": "Paris (FR)", "code": "par" }, "resolution": "raw" }, { "id": "1min-2026-09-30T15:55:00.000Z", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-09-30T15:55:00.000Z", "responseTimeMs": 54, "location": null, "resolution": "1min", "totalLocations": 2, "failedLocations": 0 } ], "total": 864, "page": 17, "pageCount": 87, "resolution": "mixed", "rawWindowFrom": "2026-09-30T16:00:00.000Z" } ``` - `resolution` je Zeile: `raw` ist eine einzelne Prüfung mit Standort und Fehlermeldung; `1min` ist eine Minute über alle Standorte, ohne Standort und Fehlermeldung, dafür mit `totalLocations` und `failedLocations`. - `resolution` der Seite: `raw`, `1min` oder `mixed` (die Seite liegt über der Grenze). - `rawWindowFrom`: ab hier gibt es einzelne Prüfungen; ältere Zeilen sind Minutenzeilen. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. CSV-Spalten: `checkedAt,status,responseTimeMs,location,errorMessage,resolution`. ## Aufbewahrung Einzelne Prüfungen mit Standort und Fehlermeldung bleiben 24 Stunden erhalten. Ältere Einträge kommen aus den Minutenwerten (30 Tage), eine Zeile je Minute ohne Standort und Fehlermeldung. Tageswerte (24 Monate) stehen in den Monitor-Details. ## Errors - `400` IMAP/POP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden - `404` IMAP/POP monitor not found ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status`, `minMs` oder `maxMs` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist
### IMAP/POP Monitor Details abrufen
URL: https://docs.uptimeify.io/de/api/monitors/imap-pop-monitors/get-imap-pop-monitor-details
Description: Konsolidierter Endpunkt, der das IMAP/POP Monitor Detailseiten-Payload in einem Call zurückgibt (latest check, uptime stats, incidents, alert history, maintenance windows, chart data, etc.).
Summary: `GET /api/imap-pop-monitors/:imapPopMonitorPublicId/details` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `imapPopMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des IMAP/POP Monitors. - `range` (Query, optional): `day` | `week` | `month` | `year` (Default: `day`). - `date` (Query, optional): Referenzdatum als ISO String. - `startDate` (Query, optional): Override Startdatum als ISO String. - `endDate` (Query, optional): Override Enddatum als ISO String. - `granularity` (Query, optional): Wenn gesetzt und nicht `raw`, kann das Backend Chart-Daten aggregieren. ## cURL ```bash curl -X GET "https://YOUR_DOMAIN/api/imap-pop-monitors/66666666-6666-4666-8666-666666666666/details?range=day" \ -H "Authorization: Bearer $TOKEN" ``` ## Response Die Response ist ein großes Objekt. Wichtige Top-Level Felder: - `imapPopMonitorId` - `monitor` - `latestCheck` - `uptimeStats`, `uptimeStatsMeta` - `monitoringData` - `incidents` - `alerts` - `testResultLog` - `maintenance` Beispiel (gekürzt): ```json { "imapPopMonitorId": 500, "monitor": { "id": 500, "hostname": "mail.deinkunde.com", "status": "active" }, "latestCheck": { "id": 123, "status": "success", "checkedAt": "2026-02-26T12:00:00.000Z" }, "uptimeStats": { "day": "100.00", "month": "100.00", "year": "100.00", "dayAvgResponse": 142, "monthAvgResponse": 150, "yearAvgResponse": 160 }, "maintenance": { "inMaintenance": false, "activeWindows": [], "allWindows": [] } } ``` ## Aufbewahrung Einzelne Prüfungen bleiben 24 Stunden erhalten, Minutenwerte 30 Tage und Tageswerte 24 Monate; ein Zeitraum, der älter als 30 Tage ist, liefert einen Punkt pro Tag. Hat der Monitor in den letzten 24 Stunden nicht geprüft, beschreibt `latestCheck` seine letzte Minute aus dem Aggregat: `id` beginnt mit `1min-`, `resolution` ist `1min`, `locationId` und `errorMessage` sind `null`. ## Errors - `400` Ungültige IMAP/POP Monitor Public ID (UUID) - `401` Unauthorized - `403` Forbidden - `404` IMAP/POP monitor not found - `500` Failed to fetch IMAP/POP monitor details ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `range` nicht `day`/`week`/`month`/`year` ist, `date`/`startDate`/`endDate` kein Datum ist, nur eines von `startDate`/`endDate` kommt, `tz` keine Ganzzahl ist oder `granularity` weder `raw` noch `aggregated`
### IMAP/POP Monitor Ausfall-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/imap-pop-monitors/get-imap-pop-monitor-incident-history
Description: Gibt die Vorfälle eines einzelnen IMAP/POP Monitors zurück (die letzten 100), inklusive berechneter Dauer.
Summary: `GET /api/imap-pop-monitors/:imapPopMonitorPublicId/incident-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `imapPopMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des IMAP/POP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `open`, `acknowledged` oder `resolved`. - `type` (string, optional): `downtime`, `http_status`, `ssl_expiry`, `ssl_critical`, `ssl_warning`, `response_time`, `dnsbl`, `domain_expiry_warning`, `critical` oder `inconclusive`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `startedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/imap-pop-monitors/11111111-1111-4111-8111-111111111111/incident-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 123, "publicId": "55555555-5555-4555-8555-555555555555", "type": "downtime", "status": "resolved", "startedAt": "2026-02-26T12:10:00.000Z", "endedAt": "2026-02-26T12:12:30.000Z", "durationMs": 150000, "statusCode": null, "errorMessage": "connect ETIMEDOUT", "details": "connect ETIMEDOUT", "isOngoing": false } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. **Abgelöstes Feld:** `duration` (Text, z. B. `2m 30s`) wird bis zum Entfall am 18.01.2027 weiter neben `durationMs` geliefert. Lies `durationMs`. `status` ist `open`, `acknowledged` oder `resolved`. Laufende Vorfälle haben ein `null` bei `endedAt` und `isOngoing: true`. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 IMAP/POP monitor public ID (UUID) required` wenn `:imapPopMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` oder `type` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### IMAP/POP Monitore auflisten
URL: https://docs.uptimeify.io/de/api/monitors/imap-pop-monitors/list-imap-pop-monitors
Description: Listet IMAP/POP Monitore einer Organisation auf.
Summary: `GET /api/imap-pop-monitors` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `organizationId` (Query, optional): Organisations-ID. Default ist die Organisation des aktuellen Nutzers. - `customerId` (Query, optional): Nach Kunden-ID filtern. - `search` (Query, optional): Suche nach Name, Hostname oder Kunde. - `page` (Query, optional): Seite (Default: 1). - `perPage` (Query, optional): Einträge pro Seite (Default: 50, Max: 200). ## cURL ```bash curl "https://YOUR_DOMAIN/api/imap-pop-monitors?page=1&perPage=50" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "items": [ { "id": 500, "organizationId": 1, "customerId": 10, "name": "Mailbox Access", "hostname": "mail.deinkunde.com", "port": 993, "checkInterval": 30, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "customerName": "Example Customer", "config": { "protocol": "imap", "user": "monitor@deinkunde.com", "password": "password", "tls": true }, "status": "active", "notificationPhoneNumber": null, "notificationEmail": null, "lastCheckedAt": null, "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:00:00.000Z" } ], "total": 1, "page": 1, "perPage": 50 } ``` ## Inline-Metriken Jeder Eintrag traegt dieselben verdichteten Kennzahlen, die auch die uebrigen Monitor-Listen liefern. Sie werden je Monitor ueber den Kalendertag, den Monat und das Jahr in UTC gebildet. | Feld | Typ | Bedeutung | |------|-----|-----------| | `uptimeDay` / `uptimeMonth` / `uptimeYear` | string | Verfuegbarkeit in Prozent mit zwei Nachkommastellen, z. B. `"99.94"` | | `avgResponseDay` / `avgResponseMonth` / `avgResponseYear` | number \| null | Mittlere Antwortzeit in Millisekunden; `null`, wenn in dem Fenster nichts gemessen wurde | | `responseGraph` | object | `{ values, avg }` fuer die letzten 24 Stunden, ein Eintrag je Stunde; eine Stunde ohne erfolgreiche Pruefung ist `null` | | `upSinceAt` | string \| null | ISO-Zeitpunkt, seit dem der Monitor laeuft, `null` solange er ausgefallen ist | | `isDown` | boolean | Ob der Monitor gerade in einem unaufgeloesten Vorfall steckt | Die Tageswerte kommen aus den Rohdaten, Monat und Jahr aus fortlaufenden Aggregaten -- in diesen beiden Fenstern kann ein Wert der neuesten Pruefung daher um einige Minuten hinterherhinken. ## Errors - `400` Ungültige Query Parameter (z.B. `organizationId`, `customerId`) - `401` Unauthorized - `403` Forbidden ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `page` oder `perPage` keine positive Ganzzahl ist, `sortOrder` weder `asc` noch `desc` oder `tags` keine kommagetrennte Liste von Tag-IDs
### IMAP/POP Check triggern
URL: https://docs.uptimeify.io/de/api/monitors/imap-pop-monitors/trigger-check-imap-pop-monitor
Description: Startet einen sofortigen Check von allen zulässigen Monitoring-Standorten.
Summary: `POST /api/imap-pop-monitors/:imapPopMonitorPublicId/trigger-check` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `imapPopMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des IMAP/POP Monitors. ## Response ```json { "success": true, "message": "Checks triggered successfully", "imapPopMonitorId": 500, "locationCodes": ["de-nbg", "fi-hel"], "queueNames": ["imap-pop-monitor-checks-de-nbg", "imap-pop-monitor-checks-fi-hel"] } ``` ## Errors - `400` Ungültige IMAP/POP Monitor Public ID (UUID) oder keine zulässigen Locations - `401` Unauthorized - `403` Forbidden - `404` IMAP/POP monitor not found - `503` No active monitoring locations available - `500` Failed to trigger check
### IMAP/POP Monitor aktualisieren
URL: https://docs.uptimeify.io/de/api/monitors/imap-pop-monitors/update-imap-pop-monitor
Description: Aktualisiert einen IMAP/POP Monitor und/oder ändert den Status.
Summary: `PATCH /api/imap-pop-monitors/:imapPopMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `imapPopMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des IMAP/POP Monitors. ## Request Body - `status` (optional) - Erlaubt: `active`, `maintenance`, `disabled`, `paused`, `inactive` - Hinweis: `paused` / `inactive` werden zu `disabled` normalisiert. - `name`, `hostname`, `port`, `checkInterval`, `timeoutSeconds` (optional) - `allowedCheckCountryCodes` (optional) - Wird zu Uppercase normalisiert und dedupliziert. - `checkMode` (optional) - Erlaubt: `protocol` | `tcp`. Muss einer dieser beiden Werte sein, sonst schlägt der Request mit `400` / `data.code: "invalidCheckMode"` fehl. - Beim Wechsel zu `tcp` werden gespeicherte Zugangsdaten gelöscht: der Monitor führt nur eine reine TCP-Port-Erreichbarkeitsprüfung durch und `imapPopConfig` wird nicht gespeichert. Beim Zurückwechseln zu `protocol` läuft wieder die vollständige IMAP/POP-Login-Prüfung; neue Zugangsdaten über `imapPopConfig`/`config` mitschicken. - **`port` ist erforderlich, wenn der resultierende `checkMode` `tcp` ist** (egal ob gerade in diesem Request gesetzt oder bereits am Monitor gespeichert). Ist kein Port vorhanden, schlägt der Request mit `400` / `data.code: "portRequiredForTcp"` fehl. - `imapPopConfig` (optional) - Alias für das gespeicherte `config` JSON. - `config` (optional) - Alternative, um dasselbe gespeicherte `config` JSON zu aktualisieren. Hinweis: Read-only Nutzer dürfen nur `status` ändern (bei anderen Feldern kommt `403`). ```json { "status": "active" } ``` Beispiel für Config-Update: ```json { "imapPopConfig": { "protocol": "pop3", "tls": true, "user": "monitor@deinkunde.com", "password": "password" } } ``` ## Response ```json { "id": 500, "organizationId": 1, "customerId": 10, "name": "Mailbox Access", "hostname": "mail.deinkunde.com", "port": 993, "checkInterval": 30, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "status": "active", "notificationPhoneNumber": null, "notificationEmail": null, "lastCheckedAt": null, "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:05:00.000Z", "config": { "protocol": "pop3", "tls": true, "user": "monitor@deinkunde.com", "password": "password" }, "imapPopConfig": { "protocol": "pop3", "tls": true, "user": "monitor@deinkunde.com", "password": "password" } } ``` ## Errors - `400` Ungültiger Request Body, ungültiger Status oder ungültiger Hostname - `401` Unauthorized - `403` Forbidden (z.B. `readonly` oder global supporter) - `404` IMAP/POP monitor not found ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `name` kein nicht-leerer String mit höchstens 255 Zeichen ist oder `allowedCheckCountryCodes` weder ein Array von Ländercodes noch `null` - `400 Bad Request` (`invalidTimeoutSeconds`) wenn `timeoutSeconds` keine Ganzzahl zwischen 1 und 60 ist - `400 Bad Request` (`invalidConfig`) wenn ein Config-Feld (`config` oder das typspezifische) kein Objekt ist
### SMTP Monitore
URL: https://docs.uptimeify.io/de/api/monitors/smtp-monitors
Description: Verwalte SMTP Monitore.
Summary: Pfadbasierte SMTP-Monitor-Endpunkte verwenden `smtpMonitorPublicId`-UUIDs. ## Endpunkte - [SMTP Monitore auflisten](/de/api/monitors/smtp-monitors/list-smtp-monitors) - [SMTP Monitor erstellen](/de/api/monitors/smtp-monitors/create-smtp-monitor) - [SMTP Monitor abrufen](/de/api/monitors/smtp-monitors/get-smtp-monitor) - [SMTP Monitor Details abrufen](/de/api/monitors/smtp-monitors/get-smtp-monitor-details) - [SMTP Monitor Check-Historie abrufen](/de/api/monitors/smtp-monitors/get-smtp-monitor-check-history) - [SMTP Monitor aktualisieren](/de/api/monitors/smtp-monitors/update-smtp-monitor) - [SMTP Monitor löschen](/de/api/monitors/smtp-monitors/delete-smtp-monitor) - [Check für SMTP Monitor triggern](/de/api/monitors/smtp-monitors/trigger-check-smtp-monitor)
### SMTP Monitor erstellen
URL: https://docs.uptimeify.io/de/api/monitors/smtp-monitors/create-smtp-monitor
Description: Erstellt einen neuen SMTP Monitor.
Summary: `POST /api/smtp-monitors` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Request Body ```json { "customerId": "11111111-1111-4111-8111-111111111111", "name": "Outbound SMTP", "hostname": "smtp.deinkunde.com", "port": 587, "status": "active", "checkInterval": 60, "timeoutSeconds": 30, "smtpConfig": { "secure": false, "ignoreTls": false, "requireTls": false, "auth": { "user": "username", "pass": "password" } } } ``` ### Felder - `customerId` (number | string, erforderlich) - Akzeptiert entweder die interne numerische Kunden-ID oder die öffentliche Kunden-UUID. - `name` (string, erforderlich) - `hostname` (string, erforderlich) - Muss nur ein Hostname sein (kein Protokoll wie `https://`, kein Pfad wie `/smtp`). - `port` (number | null, optional) - Wenn weggelassen oder `null`, nutzt der Worker standardmäßig `465`, wenn `smtpConfig.secure=true`, sonst `25`. - `status` (string, optional) - Erlaubt: `active`, `maintenance`, `disabled`, `paused`, `inactive` - `checkInterval` (number, optional) - `timeoutSeconds` (number, optional) - `checkMode` (string, optional) - Erlaubt: `protocol`, `tcp`. Standard: `protocol`. - Im Modus `tcp` führt der Monitor nur eine reine TCP-Port-Erreichbarkeitsprüfung durch: `smtpConfig` ist nicht erforderlich und wird nicht gespeichert. Im Modus `protocol` läuft die vollständige SMTP-Protokoll-/Auth-Prüfung (bisheriges Verhalten). - `smtpConfig` (object, optional) - Wird als `config` JSON des Monitors gespeichert. ### `smtpConfig` (vom Worker unterstützte Keys) Der SMTP Worker nutzt/normalisiert diese Keys: - `secure` (boolean, default `false`) - `ignoreTls` (boolean, default `false`) - `requireTls` (boolean, default `false`) - `auth.user` und `auth.pass` (strings) - Credentials werden nur verwendet, wenn *beide* `user` und `pass` gesetzt sind. ### Duplikate Hat dieser Kunde schon einen Monitor mit derselbe `hostname` (Gross- und Kleinschreibung und ein Punkt am Ende zählen nicht), `port` und `checkMode`, wird die Anfrage mit `409` und `data.code` `monitorAlreadyExists` abgewiesen. `data.existingId` und `data.existingPublicId` nennen den vorhandenen Monitor. Mit `"allowDuplicate": true` wird der zweite Monitor trotzdem angelegt (zum Beispiel mit anderem Intervall oder anderen Alarmwegen). - `allowDuplicate` (boolean, optional, Standard `false`): Monitor auch als Duplikat anlegen. Wird nicht gespeichert. ```json { "statusCode": 409, "statusMessage": "A monitor for this target already exists for this customer. Send allowDuplicate: true to create it anyway.", "data": { "code": "monitorAlreadyExists", "existingId": 300, "existingPublicId": "44444444-4444-4444-8444-444444444444" } } ``` ### Grenze je Ziel-Host Eine Organisation kann höchstens 100 Monitore auf denselben Ziel-Host haben, gezählt über alle Monitortypen zusammen (Websites mit HTTP, Keyword, DNS-Website und Playwright mit echter URL, dazu TCP, ICMP, DNS, SSH, SMTP, FTP und IMAP/POP). Die Grenze schützt davor, dass die Checkflotte als Lastgenerator gegen fremde Hosts missbraucht wird. Verglichen wird der exakte Hostname: Gross- und Kleinschreibung, Port, Pfad und ein Punkt am Ende zählen nicht, `www.example.com` und `example.com` sind aber verschiedene Hosts. Ist die Grenze erreicht, wird die Anfrage mit `403` und `data.code` `targetHostMonitorLimitReached` abgewiesen. `data.host` nennt den normalisierten Host, `data.limit` die Grenze. `"allowDuplicate": true` hebt die Grenze nicht auf. Dieselbe Prüfung läuft, wenn ein PATCH den `hostname` ändert. Ein PATCH ohne Hostwechsel geht immer, vorhandene Monitore über der Grenze bleiben bestehen. Brauchst du eine höhere Grenze, wende dich an den Support. Unabhängig von deiner Organisation dürfen über alle Uptimeify-Kunden hinweg höchstens 300 Monitore auf denselben Host zeigen. Darüber wird die Anfrage mit `403` und `data.code` `targetHostPlatformLimitReached` abgewiesen; `data.host` und `data.limit` sind wie oben gesetzt, die Meldung verrät nicht, wie viele…
### SMTP Monitor löschen
URL: https://docs.uptimeify.io/de/api/monitors/smtp-monitors/delete-smtp-monitor
Description: Löscht einen SMTP Monitor.
Summary: `DELETE /api/smtp-monitors/:smtpMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session und Schreibrechte. - Header: `Authorization: Bearer ` ## Parameter - `smtpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SMTP Monitors. ## cURL ```bash curl -X DELETE "https://YOUR_DOMAIN/api/smtp-monitors/33333333-3333-4333-8333-333333333333" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "success": true } ``` ## Errors - `400` SMTP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden (`readonlyMayNotDelete` bei einem Nur-Lese-Zugang, `managed_by_organization` bei einer verwalteten Ressource ohne `canEditManaged`) - `404` Not found ## Berechtigungen Für die Rolle `readonly` gesperrt. Ein Nur-Lese-Zugang löscht keinen Monitor, gleich welcher Besitzklasse, und ein von ihm ausgestellter API-Token ebenso wenig: Ein Token erbt die Rolle seines Erstellers. Das Bearbeiten eines Monitors mit `self_service` bleibt dieser Rolle erlaubt. Kunden-gescopte Aufrufer bindet zusätzlich die Besitzklasse: Ein `managed`-Monitor wird mit `managed_by_organization` abgelehnt, solange der Kunde kein `canEditManaged` trägt.
### SMTP Monitor abrufen
URL: https://docs.uptimeify.io/de/api/monitors/smtp-monitors/get-smtp-monitor
Description: Gibt Details zu einem SMTP Monitor zurück.
Summary: `GET /api/smtp-monitors/:smtpMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `smtpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SMTP Monitors. ## cURL ```bash curl "https://YOUR_DOMAIN/api/smtp-monitors/33333333-3333-4333-8333-333333333333" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "id": 200, "organizationId": 1, "customerId": 10, "name": "Outbound SMTP", "hostname": "smtp.deinkunde.com", "port": 587, "status": "active", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "customerName": "Example Customer", "notificationEmail": null, "notificationPhoneNumber": null, "lastCheckedAt": "2026-01-01T12:00:00.000Z", "createdAt": "2026-01-01T12:00:00.000Z", "updatedAt": "2026-01-01T12:00:00.000Z", "config": { "secure": false, "ignoreTls": false, "requireTls": false }, "smtpConfig": { "secure": false, "ignoreTls": false, "requireTls": false } } ``` ## Errors - `400` SMTP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `404` Not found wenn der Monitor nicht existiert **oder zu einem anderen Kunden oder einer anderen Organisation gehört** (beide Fälle sind absichtlich nicht unterscheidbar)
### SMTP Monitor Alert-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/smtp-monitors/get-smtp-monitor-alert-history
Description: Gibt die Benachrichtigungs-/Eskalationsversuche (Alert-Historie) für Vorfälle eines SMTP Monitors zurück.
Summary: `GET /api/smtp-monitors/:smtpMonitorPublicId/alert-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `smtpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SMTP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `sent` oder `failed`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `sentAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/smtp-monitors/11111111-1111-4111-8111-111111111111/alert-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 987, "incidentId": 123, "type": "slack", "status": "sent", "channelName": "Ops Slack", "channelType": "slack", "channelConfig": null, "sentAt": "2026-02-26T12:11:00.000Z", "errorMessage": null } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Jeder Eintrag ist ein Zustellversuch an einen Benachrichtigungskanal. `status` ist `sent` oder `failed` (bei Fehler ist `errorMessage` gesetzt); `channelType` ist der Kanaltyp (z. B. `email`, `slack`, `opsgenie`). Bei `channelConfig` sind Secrets geschwärzt. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 SMTP monitor public ID (UUID) required` wenn `:smtpMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### SMTP Monitor Check-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/smtp-monitors/get-smtp-monitor-check-history
Description: Gibt die letzten Check-Ergebnisse für einen SMTP Monitor zurück.
Summary: `GET /api/smtp-monitors/:smtpMonitorPublicId/check-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `smtpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SMTP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). Eine Seite zählt Prüfzyklen, nicht Zeilen: ein Zyklus hat eine Zeile je Standort. - `limit` (number, optional): Zyklen pro Seite (Default: `10`; Max `100`). Bei `format=csv` oder `download=1` gelten die Export-Defaults (Default `10000`, Max `50000` Zeilen). - `status` (string, optional): `success` oder `failure` (`failure` matcht auch `timeout`). Bei Minutenzeilen: kein Standort fehlgeschlagen bzw. mindestens einer. - `minMs` / `maxMs` (number, optional): Filter nach Response-Time-Bereich (`timingTotal`; bei Minutenzeilen der Minutendurchschnitt). - `from` / `to` (ISO-Datumsstring, optional): Filter nach `checkedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. ## cURL ```bash curl "https://YOUR_DOMAIN/api/smtp-monitors/44444444-4444-4444-8444-444444444444/check-history?page=1&limit=10" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "data": [ { "id": "33c53ac4-a2bc-475c-a904-8d3d6aab2979", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-10-01T05:40:55.690Z", "responseTimeMs": 29, "location": { "name": "Paris (FR)", "code": "par" }, "resolution": "raw" }, { "id": "1min-2026-09-30T15:55:00.000Z", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-09-30T15:55:00.000Z", "responseTimeMs": 54, "location": null, "resolution": "1min", "totalLocations": 2, "failedLocations": 0 } ], "total": 864, "page": 17, "pageCount": 87, "resolution": "mixed", "rawWindowFrom": "2026-09-30T16:00:00.000Z" } ``` - `resolution` je Zeile: `raw` ist eine einzelne Prüfung mit Standort und Fehlermeldung; `1min` ist eine Minute über alle Standorte, ohne Standort und Fehlermeldung, dafür mit `totalLocations` und `failedLocations`. - `resolution` der Seite: `raw`, `1min` oder `mixed` (die Seite liegt über der Grenze). - `rawWindowFrom`: ab hier gibt es einzelne Prüfungen; ältere Zeilen sind Minutenzeilen. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. CSV-Spalten: `checkedAt,status,responseTimeMs,location,errorMessage,resolution`. ## Aufbewahrung Einzelne Prüfungen mit Standort und Fehlermeldung bleiben 24 Stunden erhalten. Ältere Einträge kommen aus den Minutenwerten (30 Tage), eine Zeile je Minute ohne Standort und Fehlermeldung. Tageswerte (24 Monate) stehen in den Monitor-Details. ## Errors - `400` SMTP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden - `404` Not found ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status`, `minMs` oder `maxMs` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist
### SMTP Monitor Details abrufen
URL: https://docs.uptimeify.io/de/api/monitors/smtp-monitors/get-smtp-monitor-details
Description: Konsolidierter Endpunkt, der die Daten für die SMTP Monitor Detailseite in einem Call zurückgibt.
Summary: `GET /api/smtp-monitors/:smtpMonitorPublicId/details` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `smtpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SMTP Monitors. ## Query Parameter - `range` (string, optional): `day`, `week`, `month`, `year` (Default: `day`) - `date` (string, optional): Referenzdatum (wird via `new Date(date)` geparst) - `startDate` (string, optional) - `endDate` (string, optional) - `granularity` (string, optional) - Wenn `raw`, wird Aggregation deaktiviert. ## cURL ```bash curl "https://YOUR_DOMAIN/api/smtp-monitors/33333333-3333-4333-8333-333333333333/details?range=day" \ -H "Authorization: Bearer $TOKEN" ``` ## Response Die Response ist ein einzelnes Objekt mit diesen Top-Level Keys: - `smtpMonitorId` - `monitor` - `latestCheck` - `uptimeStats` - `uptimeStatsMeta` - `monitoringData` - `incidents` - `alerts` - `testResultLog` - `maintenance` Beispiel (gekürzt): ```json { "smtpMonitorId": 200, "monitor": { "id": 200, "customerId": 10, "name": "Outbound SMTP", "hostname": "smtp.deinkunde.com", "port": 587, "status": "active", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "config": { "secure": false, "requireTls": true } }, "latestCheck": { "status": "success", "checkedAt": "2026-01-01T12:00:00.000Z", "timingSmtp": 123, "locationCode": "de-nbg", "locationName": "Nuremberg (DE)" }, "uptimeStats": { "day": 99.9, "month": 99.5, "year": 99.0, "dayAvgResponse": 120, "monthAvgResponse": 140, "yearAvgResponse": 150 }, "maintenance": { "inMaintenance": false, "activeWindows": [], "allWindows": [] } } ``` ## Aufbewahrung Einzelne Prüfungen bleiben 24 Stunden erhalten, Minutenwerte 30 Tage und Tageswerte 24 Monate; ein Zeitraum, der älter als 30 Tage ist, liefert einen Punkt pro Tag. Hat der Monitor in den letzten 24 Stunden nicht geprüft, beschreibt `latestCheck` seine letzte Minute aus dem Aggregat: `id` beginnt mit `1min-`, `resolution` ist `1min`, `locationId` und `errorMessage` sind `null`. ## Errors - `400` Ungültige SMTP Monitor Public ID (UUID) - `401` Unauthorized - `403` Forbidden - `404` Not found - `500` Failed to fetch SMTP monitor details ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `range` nicht `day`/`week`/`month`/`year` ist, `date`/`startDate`/`endDate` kein Datum ist, nur eines von `startDate`/`endDate` kommt, `tz` keine Ganzzahl ist oder `granularity` weder `raw` noch `aggregated`
### SMTP Monitor Ausfall-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/smtp-monitors/get-smtp-monitor-incident-history
Description: Gibt die Vorfälle eines einzelnen SMTP Monitors zurück (die letzten 100), inklusive berechneter Dauer.
Summary: `GET /api/smtp-monitors/:smtpMonitorPublicId/incident-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `smtpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SMTP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `open`, `acknowledged` oder `resolved`. - `type` (string, optional): `downtime`, `http_status`, `ssl_expiry`, `ssl_critical`, `ssl_warning`, `response_time`, `dnsbl`, `domain_expiry_warning`, `critical` oder `inconclusive`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `startedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/smtp-monitors/11111111-1111-4111-8111-111111111111/incident-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 123, "publicId": "55555555-5555-4555-8555-555555555555", "type": "downtime", "status": "resolved", "startedAt": "2026-02-26T12:10:00.000Z", "endedAt": "2026-02-26T12:12:30.000Z", "durationMs": 150000, "statusCode": null, "errorMessage": "connect ETIMEDOUT", "details": "connect ETIMEDOUT", "isOngoing": false } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. **Abgelöstes Feld:** `duration` (Text, z. B. `2m 30s`) wird bis zum Entfall am 18.01.2027 weiter neben `durationMs` geliefert. Lies `durationMs`. `status` ist `open`, `acknowledged` oder `resolved`. Laufende Vorfälle haben ein `null` bei `endedAt` und `isOngoing: true`. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 SMTP monitor public ID (UUID) required` wenn `:smtpMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` oder `type` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### SMTP Monitore auflisten
URL: https://docs.uptimeify.io/de/api/monitors/smtp-monitors/list-smtp-monitors
Description: Listet SMTP Monitore einer Organisation auf.
Summary: `GET /api/smtp-monitors` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `organizationId` (Query, optional): Organisations-ID. Default ist die Organisation des aktuellen Nutzers. - `customerId` (Query, optional): Nach Kunden-ID filtern. - `search` (Query, optional): Suche nach Name, Hostname oder Kunde. - `page` (Query, optional): Seite (Default: 1). - `perPage` (Query, optional): Einträge pro Seite (Default: 50, Max: 200). ## cURL ```bash curl "https://YOUR_DOMAIN/api/smtp-monitors?page=1&perPage=50" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "items": [ { "id": 200, "organizationId": 1, "customerId": 10, "name": "Outbound SMTP", "hostname": "smtp.deinkunde.com", "port": 587, "status": "active", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "customerName": "Example Customer", "notificationEmail": null, "notificationPhoneNumber": null, "lastCheckedAt": "2026-01-01T12:00:00.000Z", "createdAt": "2026-01-01T12:00:00.000Z", "updatedAt": "2026-01-01T12:00:00.000Z", "config": { "secure": false, "ignoreTls": false, "requireTls": false } } ], "total": 1, "page": 1, "perPage": 50 } ``` ## Inline-Metriken Jeder Eintrag traegt dieselben verdichteten Kennzahlen, die auch die uebrigen Monitor-Listen liefern. Sie werden je Monitor ueber den Kalendertag, den Monat und das Jahr in UTC gebildet. | Feld | Typ | Bedeutung | |------|-----|-----------| | `uptimeDay` / `uptimeMonth` / `uptimeYear` | string | Verfuegbarkeit in Prozent mit zwei Nachkommastellen, z. B. `"99.94"` | | `avgResponseDay` / `avgResponseMonth` / `avgResponseYear` | number \| null | Mittlere Antwortzeit in Millisekunden; `null`, wenn in dem Fenster nichts gemessen wurde | | `responseGraph` | object | `{ values, avg }` fuer die letzten 24 Stunden, ein Eintrag je Stunde; eine Stunde ohne erfolgreiche Pruefung ist `null` | | `upSinceAt` | string \| null | ISO-Zeitpunkt, seit dem der Monitor laeuft, `null` solange er ausgefallen ist | | `isDown` | boolean | Ob der Monitor gerade in einem unaufgeloesten Vorfall steckt | Die Tageswerte kommen aus den Rohdaten, Monat und Jahr aus fortlaufenden Aggregaten -- in diesen beiden Fenstern kann ein Wert der neuesten Pruefung daher um einige Minuten hinterherhinken. ## Errors - `400` Ungültige `organizationId` oder `customerId` - `401` Unauthorized - `403` Forbidden ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `page` oder `perPage` keine positive Ganzzahl ist, `sortOrder` weder `asc` noch `desc` oder `tags` keine kommagetrennte Liste von Tag-IDs
### Check für SMTP Monitor triggern
URL: https://docs.uptimeify.io/de/api/monitors/smtp-monitors/trigger-check-smtp-monitor
Description: Startet einen sofortigen Check von allen zulässigen Monitoring-Standorten.
Summary: `POST /api/smtp-monitors/:smtpMonitorPublicId/trigger-check` ## Authentifizierung Erfordert eine gültige Session und Schreibrechte. - Header: `Authorization: Bearer ` ## Parameter - `smtpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SMTP Monitors. ## cURL ```bash curl -X POST "https://YOUR_DOMAIN/api/smtp-monitors/33333333-3333-4333-8333-333333333333/trigger-check" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "success": true, "message": "Checks triggered successfully", "smtpMonitorId": 200, "locationCodes": ["de-nbg", "fi-hel"], "queueNames": ["smtp-monitor-checks-de-nbg", "smtp-monitor-checks-fi-hel"] } ``` ## Errors - `400` SMTP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden - `404` Not found - `500` Failed to trigger check (die Status-Message kann z. B. "No active monitoring locations available" enthalten)
### SMTP Monitor aktualisieren
URL: https://docs.uptimeify.io/de/api/monitors/smtp-monitors/update-smtp-monitor
Description: Aktualisiert einen SMTP Monitor.
Summary: `PATCH /api/smtp-monitors/:smtpMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `smtpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SMTP Monitors. ## Request Body Alle Felder sind optional. ```json { "name": "Outbound SMTP (Primary)", "hostname": "smtp.deinkunde.com", "port": 587, "status": "paused", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["de", "es"], "smtpConfig": { "secure": false, "requireTls": true, "auth": { "user": "username", "pass": "password" } } } ``` ### Hinweise - `status` akzeptiert `active`, `maintenance`, `disabled`, `paused`, `inactive`. - `paused` und `inactive` werden zu `disabled` normalisiert. - `allowedCheckCountryCodes` wird zu Uppercase ISO Codes normalisiert (z. B. `DE`, `US`). Leere Listen werden `null`. - `checkMode` (string, optional): `protocol` (Standard) | `tcp`. Beim Wechsel zu `tcp` werden gespeicherte Zugangsdaten gelöscht: der Monitor führt nur eine reine TCP-Port-Erreichbarkeitsprüfung durch und `smtpConfig` wird nicht gespeichert. Beim Zurückwechseln zu `protocol` läuft wieder die vollständige SMTP-Protokoll-/Auth-Prüfung; neue Zugangsdaten über `smtpConfig`/`config` mitschicken. - SMTP Config kann als `smtpConfig` oder als `config` (Alias) übergeben werden. Wenn beides fehlt, bleibt die gespeicherte Config unverändert. - Nutzer mit Rolle `readonly` dürfen nur `status` ändern. ## cURL ```bash curl -X PATCH "https://YOUR_DOMAIN/api/smtp-monitors/33333333-3333-4333-8333-333333333333" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "status": "disabled" }' ``` ## Response ```json { "id": 200, "organizationId": 1, "customerId": 10, "name": "Outbound SMTP (Primary)", "hostname": "smtp.deinkunde.com", "port": 587, "status": "disabled", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "notificationEmail": null, "notificationPhoneNumber": null, "lastCheckedAt": "2026-01-01T12:00:00.000Z", "createdAt": "2026-01-01T12:00:00.000Z", "updatedAt": "2026-01-01T12:01:00.000Z", "config": { "secure": false, "requireTls": true, "auth": { "user": "username", "pass": "password" } }, "smtpConfig": { "secure": false, "requireTls": true, "auth": { "user": "username", "pass": "password" } } } ``` ## Errors - `400` SMTP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden (readonly Nutzer dürfen nur `status` ändern; global supporters dürfen nicht aktualisieren) - `404` Not found ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `name` kein nicht-leerer String mit höchstens 255 Zeichen ist oder `allowedCheckCountryCodes` weder ein Array von Ländercodes noch `null` - `400 Bad Request` (`invalidTimeoutSeconds`) wenn `timeoutSeconds` keine Ganzzahl zwischen 1 und 60 ist - `400 Bad Request` (`invalidConfig`) wenn ein Config-Feld (`config` oder das typspezifische) kein Objekt ist
### SSH Monitore
URL: https://docs.uptimeify.io/de/api/monitors/ssh-monitors
Description: Verwalte SSH Monitore.
Summary: Pfadbasierte SSH-Monitor-Endpunkte verwenden `sshMonitorPublicId`-UUIDs. ## Endpunkte - [SSH Monitore auflisten](/de/api/monitors/ssh-monitors/list-ssh-monitors) - [SSH Monitor erstellen](/de/api/monitors/ssh-monitors/create-ssh-monitor) - [SSH Monitor abrufen](/de/api/monitors/ssh-monitors/get-ssh-monitor) - [SSH Monitor Details abrufen](/de/api/monitors/ssh-monitors/get-ssh-monitor-details) - [SSH Monitor Check Historie abrufen](/de/api/monitors/ssh-monitors/get-ssh-monitor-check-history) - [SSH Monitor aktualisieren](/de/api/monitors/ssh-monitors/update-ssh-monitor) - [SSH Monitor löschen](/de/api/monitors/ssh-monitors/delete-ssh-monitor) - [SSH Check triggern](/de/api/monitors/ssh-monitors/trigger-check-ssh-monitor)
### SSH Monitor erstellen
URL: https://docs.uptimeify.io/de/api/monitors/ssh-monitors/create-ssh-monitor
Description: Erstellt einen neuen SSH Monitor.
Summary: `POST /api/ssh-monitors` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Request Body ```json { "customerId": "11111111-1111-4111-8111-111111111111", "name": "Bastion Host", "hostname": "ssh.deinkunde.com", "port": 22, "status": "active", "checkInterval": 60, "timeoutSeconds": 30, "sshConfig": { "username": "root", "password": "password", "privateKey": "-----BEGIN OPENSSH PRIVATE KEY-----..." } } ``` ### Felder - `customerId` (number | string, required) - Akzeptiert entweder die interne numerische Kunden-ID oder die öffentliche Kunden-UUID. - `name` (string, required) - `hostname` (string, required) - Muss ein Hostname sein (kein Protokoll wie `https://`, kein Pfad wie `/ssh`). - `port` (number | null, optional) - Wenn weggelassen oder `null`, nutzt der Worker standardmäßig Port `22`. - `status` (string, optional) - Erlaubt: `active`, `maintenance`, `disabled`, `paused`, `inactive` - `checkInterval` (number, optional) - `timeoutSeconds` (number, optional) - `checkMode` (string, optional) - Erlaubt: `protocol`, `tcp`. Standard: `protocol`. - Im Modus `tcp` führt der Monitor nur eine reine TCP-Port-Erreichbarkeitsprüfung durch: `sshConfig` ist nicht erforderlich und wird nicht gespeichert. Im Modus `protocol` läuft die vollständige SSH-Login-/Handshake-Prüfung (bisheriges Verhalten). - `sshConfig` (object, optional) - Wird als `config` JSON gespeichert. - Erforderlich (username + password oder privateKey), außer `checkMode` ist `tcp`. ### `sshConfig` (vom Worker unterstützte Keys) - `username` (string) - Wenn weggelassen, nutzt der Worker `anonymous`. - `password` (string) - `privateKey` (string) ### Duplikate Hat dieser Kunde schon einen Monitor mit derselbe `hostname` (Gross- und Kleinschreibung und ein Punkt am Ende zählen nicht), `port` und `checkMode`, wird die Anfrage mit `409` und `data.code` `monitorAlreadyExists` abgewiesen. `data.existingId` und `data.existingPublicId` nennen den vorhandenen Monitor. Mit `"allowDuplicate": true` wird der zweite Monitor trotzdem angelegt (zum Beispiel mit anderem Intervall oder anderen Alarmwegen). - `allowDuplicate` (boolean, optional, Standard `false`): Monitor auch als Duplikat anlegen. Wird nicht gespeichert. ```json { "statusCode": 409, "statusMessage": "A monitor for this target already exists for this customer. Send allowDuplicate: true to create it anyway.", "data": { "code": "monitorAlreadyExists", "existingId": 300, "existingPublicId": "44444444-4444-4444-8444-444444444444" } } ``` ### Grenze je Ziel-Host Eine Organisation kann höchstens 100 Monitore auf denselben Ziel-Host haben, gezählt über alle Monitortypen zusammen (Websites mit HTTP, Keyword, DNS-Website und Playwright mit echter URL, dazu TCP, ICMP, DNS, SSH, SMTP, FTP und IMAP/POP). Die Grenze schützt davor, dass die Checkflotte als Lastgenerator gegen fremde Hosts missbraucht wird. Verglichen wird der exakte Hostname: Gross- und Kleinschreibung, Port, Pfad und ein Punkt am Ende zählen nicht, `www.example.com` und `example.com` sind aber verschiedene Hosts. Ist die Grenze erreicht, wird die Anfrage mit `403` und `data.code` `targetHostMonitorLimitReached` abgewiesen. `data.host` nennt den normalisierten Host, `data.limit` die Grenze. `"allowDuplicate": true` hebt die Grenze nicht auf. Dieselbe Prüfung läuft, wenn ein PATCH den `hostname` ändert. Ein PATCH ohne Hostwechsel geht immer, vorhandene Monitore über der Grenze bleiben bestehen. Brauchst du eine höhere Grenze, wende dich an den Support. Unabhängig von deiner Organisation dürfen über alle Uptimeify-Kunden hinweg höchstens 300 Monitore auf denselben Host zeigen. Darüber wird die Anfrage mit `403` und `data.code` `targetHostPlatformLimitReached` abgewiesen; `data.host` und `data.limit` sind wie oben gesetzt, die Meldung verrät nicht, wie viele Monitore andere Organisationen haben. ```json { "statusCode": 403, "statusMessage": "Target host monitor limit reached: your organization already has 100 monitors for example…
### SSH Monitor löschen
URL: https://docs.uptimeify.io/de/api/monitors/ssh-monitors/delete-ssh-monitor
Description: Löscht einen SSH Monitor.
Summary: `DELETE /api/ssh-monitors/:sshMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session und Schreibrechte. - Header: `Authorization: Bearer ` ## Parameter - `sshMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SSH Monitors. ## cURL ```bash curl -X DELETE "https://YOUR_DOMAIN/api/ssh-monitors/44444444-4444-4444-8444-444444444444" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "success": true } ``` ## Errors - `400` SSH Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden (`readonlyMayNotDelete` bei einem Nur-Lese-Zugang, `managed_by_organization` bei einer verwalteten Ressource ohne `canEditManaged`) - `404` Not found ## Berechtigungen Für die Rolle `readonly` gesperrt. Ein Nur-Lese-Zugang löscht keinen Monitor, gleich welcher Besitzklasse, und ein von ihm ausgestellter API-Token ebenso wenig: Ein Token erbt die Rolle seines Erstellers. Das Bearbeiten eines Monitors mit `self_service` bleibt dieser Rolle erlaubt. Kunden-gescopte Aufrufer bindet zusätzlich die Besitzklasse: Ein `managed`-Monitor wird mit `managed_by_organization` abgelehnt, solange der Kunde kein `canEditManaged` trägt.
### SSH Monitor abrufen
URL: https://docs.uptimeify.io/de/api/monitors/ssh-monitors/get-ssh-monitor
Description: Gibt Details zu einem SSH Monitor zurück.
Summary: `GET /api/ssh-monitors/:sshMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `sshMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SSH Monitors. ## cURL ```bash curl "https://YOUR_DOMAIN/api/ssh-monitors/44444444-4444-4444-8444-444444444444" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "id": 300, "organizationId": 1, "customerId": 10, "name": "Bastion Host", "hostname": "ssh.deinkunde.com", "port": 22, "status": "active", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "customerName": "Example Customer", "notificationEmail": null, "notificationPhoneNumber": null, "lastCheckedAt": "2026-02-26T12:00:00.000Z", "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:00:00.000Z", "config": { "username": "root" }, "sshConfig": { "username": "root" } } ``` ## Errors - `400` SSH Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `404` Not found wenn der Monitor nicht existiert **oder zu einem anderen Kunden oder einer anderen Organisation gehört** (beide Fälle sind absichtlich nicht unterscheidbar)
### SSH Monitor Alert-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/ssh-monitors/get-ssh-monitor-alert-history
Description: Gibt die Benachrichtigungs-/Eskalationsversuche (Alert-Historie) für Vorfälle eines SSH Monitors zurück.
Summary: `GET /api/ssh-monitors/:sshMonitorPublicId/alert-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `sshMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SSH Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `sent` oder `failed`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `sentAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/ssh-monitors/11111111-1111-4111-8111-111111111111/alert-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 987, "incidentId": 123, "type": "slack", "status": "sent", "channelName": "Ops Slack", "channelType": "slack", "channelConfig": null, "sentAt": "2026-02-26T12:11:00.000Z", "errorMessage": null } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Jeder Eintrag ist ein Zustellversuch an einen Benachrichtigungskanal. `status` ist `sent` oder `failed` (bei Fehler ist `errorMessage` gesetzt); `channelType` ist der Kanaltyp (z. B. `email`, `slack`, `opsgenie`). Bei `channelConfig` sind Secrets geschwärzt. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 SSH monitor public ID (UUID) required` wenn `:sshMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### SSH Monitor Check Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/ssh-monitors/get-ssh-monitor-check-history
Description: Gibt die letzten Check-Ergebnisse für einen SSH Monitor zurück.
Summary: `GET /api/ssh-monitors/:sshMonitorPublicId/check-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `sshMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SSH Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). Eine Seite zählt Prüfzyklen, nicht Zeilen: ein Zyklus hat eine Zeile je Standort. - `limit` (number, optional): Zyklen pro Seite (Default: `10`; Max `100`). Bei `format=csv` oder `download=1` gelten die Export-Defaults (Default `10000`, Max `50000` Zeilen). - `status` (string, optional): `success` oder `failure` (`failure` matcht auch `timeout`). Bei Minutenzeilen: kein Standort fehlgeschlagen bzw. mindestens einer. - `minMs` / `maxMs` (number, optional): Filter nach Response-Time-Bereich (`timingTotal`; bei Minutenzeilen der Minutendurchschnitt). - `from` / `to` (ISO-Datumsstring, optional): Filter nach `checkedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. ## cURL ```bash curl "https://YOUR_DOMAIN/api/ssh-monitors/44444444-4444-4444-8444-444444444444/check-history?page=1&limit=10" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "data": [ { "id": "33c53ac4-a2bc-475c-a904-8d3d6aab2979", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-10-01T05:40:55.690Z", "responseTimeMs": 29, "location": { "name": "Paris (FR)", "code": "par" }, "resolution": "raw" }, { "id": "1min-2026-09-30T15:55:00.000Z", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-09-30T15:55:00.000Z", "responseTimeMs": 54, "location": null, "resolution": "1min", "totalLocations": 2, "failedLocations": 0 } ], "total": 864, "page": 17, "pageCount": 87, "resolution": "mixed", "rawWindowFrom": "2026-09-30T16:00:00.000Z" } ``` - `resolution` je Zeile: `raw` ist eine einzelne Prüfung mit Standort und Fehlermeldung; `1min` ist eine Minute über alle Standorte, ohne Standort und Fehlermeldung, dafür mit `totalLocations` und `failedLocations`. - `resolution` der Seite: `raw`, `1min` oder `mixed` (die Seite liegt über der Grenze). - `rawWindowFrom`: ab hier gibt es einzelne Prüfungen; ältere Zeilen sind Minutenzeilen. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. CSV-Spalten: `checkedAt,status,responseTimeMs,location,errorMessage,resolution`. ## Aufbewahrung Einzelne Prüfungen mit Standort und Fehlermeldung bleiben 24 Stunden erhalten. Ältere Einträge kommen aus den Minutenwerten (30 Tage), eine Zeile je Minute ohne Standort und Fehlermeldung. Tageswerte (24 Monate) stehen in den Monitor-Details. ## Errors - `400` SSH Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden - `404` Not found ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status`, `minMs` oder `maxMs` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist
### SSH Monitor Details abrufen
URL: https://docs.uptimeify.io/de/api/monitors/ssh-monitors/get-ssh-monitor-details
Description: Konsolidierter Endpunkt, der die Daten für die SSH Monitor Detailseite in einem Call zurückgibt.
Summary: `GET /api/ssh-monitors/:sshMonitorPublicId/details` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `sshMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SSH Monitors. ## Query Parameter - `range` (string, optional): `day`, `week`, `month`, `year` (Default: `day`) - `date` (string, optional): Referenzdatum (wird via `new Date(date)` geparst) - `startDate` (string, optional) - `endDate` (string, optional) - `granularity` (string, optional) - Wenn `raw`, wird Aggregation deaktiviert. ## cURL ```bash curl "https://YOUR_DOMAIN/api/ssh-monitors/44444444-4444-4444-8444-444444444444/details?range=day" \ -H "Authorization: Bearer $TOKEN" ``` ## Response Die Response ist ein einzelnes Objekt mit diesen Top-Level Keys: - `sshMonitorId` - `monitor` - `latestCheck` - `uptimeStats` - `uptimeStatsMeta` - `monitoringData` - `incidents` - `alerts` - `testResultLog` - `maintenance` Beispiel (gekürzt): ```json { "sshMonitorId": 300, "monitor": { "id": 300, "customerId": 10, "name": "Bastion Host", "hostname": "ssh.deinkunde.com", "port": 22, "status": "active", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "config": { "username": "root" } }, "latestCheck": { "status": "success", "checkedAt": "2026-02-26T12:00:00.000Z", "timingSsh": 123, "locationCode": "de-nbg", "locationName": "Nuremberg (DE)" }, "uptimeStats": { "day": 99.9, "month": 99.5, "year": 99.0, "dayAvgResponse": 120, "monthAvgResponse": 140, "yearAvgResponse": 150 }, "maintenance": { "inMaintenance": false, "activeWindows": [], "allWindows": [] } } ``` ## Aufbewahrung Einzelne Prüfungen bleiben 24 Stunden erhalten, Minutenwerte 30 Tage und Tageswerte 24 Monate; ein Zeitraum, der älter als 30 Tage ist, liefert einen Punkt pro Tag. Hat der Monitor in den letzten 24 Stunden nicht geprüft, beschreibt `latestCheck` seine letzte Minute aus dem Aggregat: `id` beginnt mit `1min-`, `resolution` ist `1min`, `locationId` und `errorMessage` sind `null`. ## Errors - `400` Ungültige SSH Monitor Public ID (UUID) - `401` Unauthorized - `403` Forbidden - `404` Not found - `500` Failed to fetch SSH monitor details ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `range` nicht `day`/`week`/`month`/`year` ist, `date`/`startDate`/`endDate` kein Datum ist, nur eines von `startDate`/`endDate` kommt, `tz` keine Ganzzahl ist oder `granularity` weder `raw` noch `aggregated`
### SSH Monitor Ausfall-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/ssh-monitors/get-ssh-monitor-incident-history
Description: Gibt die Vorfälle eines einzelnen SSH Monitors zurück (die letzten 100), inklusive berechneter Dauer.
Summary: `GET /api/ssh-monitors/:sshMonitorPublicId/incident-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `sshMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SSH Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `open`, `acknowledged` oder `resolved`. - `type` (string, optional): `downtime`, `http_status`, `ssl_expiry`, `ssl_critical`, `ssl_warning`, `response_time`, `dnsbl`, `domain_expiry_warning`, `critical` oder `inconclusive`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `startedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/ssh-monitors/11111111-1111-4111-8111-111111111111/incident-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 123, "publicId": "55555555-5555-4555-8555-555555555555", "type": "downtime", "status": "resolved", "startedAt": "2026-02-26T12:10:00.000Z", "endedAt": "2026-02-26T12:12:30.000Z", "durationMs": 150000, "statusCode": null, "errorMessage": "connect ETIMEDOUT", "details": "connect ETIMEDOUT", "isOngoing": false } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. **Abgelöstes Feld:** `duration` (Text, z. B. `2m 30s`) wird bis zum Entfall am 18.01.2027 weiter neben `durationMs` geliefert. Lies `durationMs`. `status` ist `open`, `acknowledged` oder `resolved`. Laufende Vorfälle haben ein `null` bei `endedAt` und `isOngoing: true`. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 SSH monitor public ID (UUID) required` wenn `:sshMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` oder `type` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### SSH Monitore auflisten
URL: https://docs.uptimeify.io/de/api/monitors/ssh-monitors/list-ssh-monitors
Description: Listet SSH Monitore einer Organisation auf.
Summary: `GET /api/ssh-monitors` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `organizationId` (Query, optional): Organisations-ID. Default ist die Organisation des aktuellen Nutzers. - `customerId` (Query, optional): Nach Kunden-ID filtern. - `search` (Query, optional): Suche nach Name, Hostname oder Kunde. - `page` (Query, optional): Seite (Default: 1). - `perPage` (Query, optional): Einträge pro Seite (Default: 50, Max: 200). ## cURL ```bash curl "https://YOUR_DOMAIN/api/ssh-monitors?page=1&perPage=50" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "items": [ { "id": 300, "organizationId": 1, "customerId": 10, "name": "Bastion Host", "hostname": "ssh.deinkunde.com", "port": 22, "status": "active", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "customerName": "Example Customer", "notificationEmail": null, "notificationPhoneNumber": null, "lastCheckedAt": "2026-02-26T12:00:00.000Z", "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:00:00.000Z", "config": { "username": "root" } } ], "total": 1, "page": 1, "perPage": 50 } ``` ## Inline-Metriken Jeder Eintrag traegt dieselben verdichteten Kennzahlen, die auch die uebrigen Monitor-Listen liefern. Sie werden je Monitor ueber den Kalendertag, den Monat und das Jahr in UTC gebildet. | Feld | Typ | Bedeutung | |------|-----|-----------| | `uptimeDay` / `uptimeMonth` / `uptimeYear` | string | Verfuegbarkeit in Prozent mit zwei Nachkommastellen, z. B. `"99.94"` | | `avgResponseDay` / `avgResponseMonth` / `avgResponseYear` | number \| null | Mittlere Antwortzeit in Millisekunden; `null`, wenn in dem Fenster nichts gemessen wurde | | `responseGraph` | object | `{ values, avg }` fuer die letzten 24 Stunden, ein Eintrag je Stunde; eine Stunde ohne erfolgreiche Pruefung ist `null` | | `upSinceAt` | string \| null | ISO-Zeitpunkt, seit dem der Monitor laeuft, `null` solange er ausgefallen ist | | `isDown` | boolean | Ob der Monitor gerade in einem unaufgeloesten Vorfall steckt | Die Tageswerte kommen aus den Rohdaten, Monat und Jahr aus fortlaufenden Aggregaten -- in diesen beiden Fenstern kann ein Wert der neuesten Pruefung daher um einige Minuten hinterherhinken. ## Errors - `400` Ungültige `organizationId` oder `customerId` - `401` Unauthorized - `403` Forbidden ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `page` oder `perPage` keine positive Ganzzahl ist, `sortOrder` weder `asc` noch `desc` oder `tags` keine kommagetrennte Liste von Tag-IDs
### SSH Check triggern
URL: https://docs.uptimeify.io/de/api/monitors/ssh-monitors/trigger-check-ssh-monitor
Description: Startet einen sofortigen Check von allen zulässigen Monitoring-Standorten.
Summary: `POST /api/ssh-monitors/:sshMonitorPublicId/trigger-check` ## Authentifizierung Erfordert eine gültige Session und Schreibrechte. - Header: `Authorization: Bearer ` ## Parameter - `sshMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SSH Monitors. ## cURL ```bash curl -X POST "https://YOUR_DOMAIN/api/ssh-monitors/44444444-4444-4444-8444-444444444444/trigger-check" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "success": true, "message": "Checks triggered successfully", "sshMonitorId": 300, "locationCodes": ["de-nbg", "fi-hel"], "queueNames": ["ssh-monitor-checks-de-nbg", "ssh-monitor-checks-fi-hel"] } ``` ## Errors - `400` SSH Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden - `404` Not found - `500` Failed to trigger check (die StatusMessage kann z.B. "No active monitoring locations available" enthalten)
### SSH Monitor aktualisieren
URL: https://docs.uptimeify.io/de/api/monitors/ssh-monitors/update-ssh-monitor
Description: Aktualisiert einen SSH Monitor und/oder ändert den Status.
Summary: `PATCH /api/ssh-monitors/:sshMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `sshMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des SSH Monitors. ## Request Body Alle Felder sind optional. ```json { "name": "Bastion Host (Primary)", "hostname": "ssh.deinkunde.com", "port": 22, "status": "paused", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["de", "es"], "sshConfig": { "username": "root", "privateKey": "-----BEGIN OPENSSH PRIVATE KEY-----..." } } ``` ### Hinweise - `status` akzeptiert `active`, `maintenance`, `disabled`, `paused`, `inactive`. - `paused` und `inactive` werden zu `disabled` normalisiert. - `allowedCheckCountryCodes` wird zu Uppercase ISO Codes normalisiert (z.B. `DE`, `US`). Leere Listen werden zu `null`. - `checkMode` (string, optional): `protocol` (Standard) | `tcp`. Beim Wechsel zu `tcp` werden gespeicherte Zugangsdaten gelöscht: der Monitor führt nur eine reine TCP-Port-Erreichbarkeitsprüfung durch und `sshConfig` wird nicht gespeichert. Beim Zurückwechseln zu `protocol` läuft wieder die vollständige SSH-Login-/Handshake-Prüfung; neue Zugangsdaten über `sshConfig`/`config` mitschicken. - SSH Config kann als `sshConfig` oder als `config` (Alias) übergeben werden. Wenn keiner der Keys vorhanden ist, bleibt die gespeicherte Config unverändert. - Nutzer mit Rolle `readonly` können nur `status` ändern. ## cURL ```bash curl -X PATCH "https://YOUR_DOMAIN/api/ssh-monitors/44444444-4444-4444-8444-444444444444" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "status": "disabled" }' ``` ## Response ```json { "id": 300, "organizationId": 1, "customerId": 10, "name": "Bastion Host (Primary)", "hostname": "ssh.deinkunde.com", "port": 22, "status": "disabled", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "notificationEmail": null, "notificationPhoneNumber": null, "lastCheckedAt": "2026-02-26T12:00:00.000Z", "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:01:00.000Z", "config": { "username": "root" }, "sshConfig": { "username": "root" } } ``` ## Errors - `400` SSH Monitor Public ID (UUID) erforderlich / ungültige Felder - `401` Unauthorized - `403` Forbidden (readonly darf nur `status` ändern; global supporters dürfen nicht updaten) - `404` Not found ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `name` kein nicht-leerer String mit höchstens 255 Zeichen ist oder `allowedCheckCountryCodes` weder ein Array von Ländercodes noch `null` - `400 Bad Request` (`invalidTimeoutSeconds`) wenn `timeoutSeconds` keine Ganzzahl zwischen 1 und 60 ist - `400 Bad Request` (`invalidConfig`) wenn ein Config-Feld (`config` oder das typspezifische) kein Objekt ist
### TCP Monitore
URL: https://docs.uptimeify.io/de/api/monitors/tcp-monitors
Description: Verwalte TCP Monitore.
Summary: Pfadbasierte TCP-Monitor-Endpunkte verwenden `tcpMonitorPublicId`-UUIDs. ## Endpunkte - [TCP Monitore auflisten](/de/api/monitors/tcp-monitors/list-tcp-monitors) - [TCP Monitor erstellen](/de/api/monitors/tcp-monitors/create-tcp-monitor) - [TCP Monitor abrufen](/de/api/monitors/tcp-monitors/get-tcp-monitor) - [TCP Monitor Details abrufen](/de/api/monitors/tcp-monitors/get-tcp-monitor-details) - [TCP Monitor Check Historie abrufen](/de/api/monitors/tcp-monitors/get-tcp-monitor-check-history) - [TCP Monitor Alert-Historie abrufen](/de/api/monitors/tcp-monitors/get-tcp-monitor-alert-history) - [TCP Monitor Incident-Historie abrufen](/de/api/monitors/tcp-monitors/get-tcp-monitor-incident-history) - [TCP Monitor aktualisieren](/de/api/monitors/tcp-monitors/update-tcp-monitor) - [TCP Monitor löschen](/de/api/monitors/tcp-monitors/delete-tcp-monitor) - [TCP Check triggern](/de/api/monitors/tcp-monitors/trigger-check-tcp-monitor)
### TCP Monitor erstellen
URL: https://docs.uptimeify.io/de/api/monitors/tcp-monitors/create-tcp-monitor
Description: Erstellt einen neuen TCP Monitor.
Summary: `POST /api/tcp-monitors` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Request Body ```json { "customerId": "11111111-1111-4111-8111-111111111111", "name": "Redis Primary", "hostname": "redis.deinkunde.com", "port": 6379, "status": "active", "checkInterval": 60, "timeoutSeconds": 30, "config": { "expectBanner": "+PONG" } } ``` ### Felder - `customerId` (number | string, required) - Akzeptiert entweder die interne numerische Kunden-ID oder die öffentliche Kunden-UUID. - `name` (string, required, max. 255 Zeichen) - `hostname` (string, required, max. 253 Zeichen) - Muss ein reiner Hostname sein (kein Protokoll wie `https://`, kein Pfad wie `/status`). - `port` (number, **required**, 1-65535) - Anders als bei anderen Monitor-Typen gibt es bei TCP-Monitoren keinen Standardport: der Port muss immer angegeben werden. - `status` (string, optional) - Erlaubt: `active`, `maintenance`, `disabled`, `paused`, `inactive` (`paused`/`inactive` werden zu `disabled` normalisiert). Standard: `active`. - `checkInterval` (number, optional, 1-1440 Minuten) - Standard: `30`. - `timeoutSeconds` (number, optional, 1-60) - Standard: `30`. - `allowedCheckCountryCodes` (string[], optional) - Beschränkt Checks auf diese ISO-3166-1-alpha-2-Ländercodes. - `managementType` (string, optional) - Erlaubt: `managed`, `self_service`. Nur Organisations-Writer dürfen dies setzen; alle anderen Aufrufer erhalten immer `managed`. - `config` (object, optional) - Wird als `config` JSON des Monitors gespeichert. TCP-Monitore enthalten **keine Zugangsdaten**: der einzige unterstützte Key ist `expectBanner`. - `expectedState` (string, optional, auf oberster Ebene, nicht in `config`) - `up` (Standard): Alarm, wenn der Port nicht erreichbar ist. `down`: Alarm, wenn der Port eine Verbindung annimmt, für Ports, die geschlossen bleiben müssen (z. B. ein Wartungs- oder Debug-Port). Verbindung abgelehnt, Timeout, Reset sowie Host oder Netz nicht erreichbar gelten als geschlossen (gesund); DNS-Auflösungsfehler und andere Fehler schlagen weiter fehl, damit ein Tippfehler im Hostnamen nicht grün aussieht. `expectBanner` wird ignoriert, solange `expectedState` auf `down` steht. ### `config` (vom Worker unterstützte Keys) - `expectBanner` (string, optional, max. 255 Zeichen) - Wenn gesetzt, prüft der Worker, ob die Rohbytes direkt nach dem TCP-Handshake diesen Teilstring enthalten (z. B. `+PONG` bei Redis, `220` bei einem SMTP-Banner). Wenn weggelassen, prüft der Check nur, ob der TCP-Handshake erfolgreich ist. ### Duplikate Hat dieser Kunde schon einen Monitor mit derselbe `hostname` (Gross- und Kleinschreibung und ein Punkt am Ende zählen nicht) und `port`, wird die Anfrage mit `409` und `data.code` `monitorAlreadyExists` abgewiesen. `data.existingId` und `data.existingPublicId` nennen den vorhandenen Monitor. Mit `"allowDuplicate": true` wird der zweite Monitor trotzdem angelegt (zum Beispiel mit anderem Intervall oder anderen Alarmwegen). - `allowDuplicate` (boolean, optional, Standard `false`): Monitor auch als Duplikat anlegen. Wird nicht gespeichert. ```json { "statusCode": 409, "statusMessage": "A monitor for this target already exists for this customer. Send allowDuplicate: true to create it anyway.", "data": { "code": "monitorAlreadyExists", "existingId": 300, "existingPublicId": "44444444-4444-4444-8444-444444444444" } } ``` ### Grenze je Ziel-Host Eine Organisation kann höchstens 100 Monitore auf denselben Ziel-Host haben, gezählt über alle Monitortypen zusammen (Websites mit HTTP, Keyword, DNS-Website und Playwright mit echter URL, dazu TCP, ICMP, DNS, SSH, SMTP, FTP und IMAP/POP). Die Grenze schützt davor, dass die Checkflotte als Lastgenerator gegen fremde Hosts missbraucht wird. Verglichen wird der exakte Hostname: Gross- und Kleinschreibung, Port, Pfad und ein Punkt am Ende zählen nicht, `www.example.com` und `example.com` sind aber verschiedene Hosts. Ist die Grenze erreicht, wird die Anfrage mit `403` und `data.co…
### TCP Monitor löschen
URL: https://docs.uptimeify.io/de/api/monitors/tcp-monitors/delete-tcp-monitor
Description: Löscht einen TCP Monitor.
Summary: `DELETE /api/tcp-monitors/:tcpMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session und Schreibrechte. - Header: `Authorization: Bearer ` ## Parameter - `tcpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des TCP Monitors. ## cURL ```bash curl -X DELETE "https://YOUR_DOMAIN/api/tcp-monitors/44444444-4444-4444-8444-444444444444" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "success": true } ``` ## Errors - `400` TCP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden (`readonlyMayNotDelete` bei einem Nur-Lese-Zugang, `managed_by_organization` bei einer verwalteten Ressource ohne `canEditManaged`) - `404` Not found ## Berechtigungen Für die Rolle `readonly` gesperrt. Ein Nur-Lese-Zugang löscht keinen Monitor, gleich welcher Besitzklasse, und ein von ihm ausgestellter API-Token ebenso wenig: Ein Token erbt die Rolle seines Erstellers. Das Bearbeiten eines Monitors mit `self_service` bleibt dieser Rolle erlaubt. Kunden-gescopte Aufrufer bindet zusätzlich die Besitzklasse: Ein `managed`-Monitor wird mit `managed_by_organization` abgelehnt, solange der Kunde kein `canEditManaged` trägt.
### TCP Monitor abrufen
URL: https://docs.uptimeify.io/de/api/monitors/tcp-monitors/get-tcp-monitor
Description: Gibt Details zu einem TCP Monitor zurück.
Summary: `GET /api/tcp-monitors/:tcpMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `tcpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des TCP Monitors. ## cURL ```bash curl "https://YOUR_DOMAIN/api/tcp-monitors/44444444-4444-4444-8444-444444444444" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "id": 300, "publicId": "44444444-4444-4444-8444-444444444444", "organizationId": 1, "customerId": 10, "name": "Redis Primary", "hostname": "redis.deinkunde.com", "port": 6379, "status": "active", "managementType": "managed", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "customerName": "Example Customer", "notificationEmail": null, "notificationPhoneNumber": null, "lastCheckedAt": "2026-02-26T12:00:00.000Z", "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:00:00.000Z", "expectedState": "up", "config": { "expectBanner": "+PONG" } } ``` ## Errors - `400` TCP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `404` Not found wenn der Monitor nicht existiert **oder zu einem anderen Kunden oder einer anderen Organisation gehört** (beide Fälle sind absichtlich nicht unterscheidbar)
### TCP Monitor Alert-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/tcp-monitors/get-tcp-monitor-alert-history
Description: Gibt paginierte Benachrichtigungs-/Eskalationsversuche (Alert-Historie) für Vorfälle eines TCP Monitors zurück.
Summary: `GET /api/tcp-monitors/:tcpMonitorPublicId/alert-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `tcpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des TCP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `sent` oder `failed`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `sentAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/tcp-monitors/11111111-1111-4111-8111-111111111111/alert-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 987, "incidentId": 123, "type": "slack", "status": "sent", "channelName": "Ops Slack", "channelType": "slack", "channelConfig": null, "sentAt": "2026-02-26T12:11:00.000Z", "errorMessage": null } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Jeder Eintrag ist ein Zustellversuch an einen Benachrichtigungskanal. `status` ist `sent` oder `failed` (bei Fehler ist `errorMessage` gesetzt); `channelType` ist der Kanaltyp (z. B. `email`, `slack`, `opsgenie`). Bei `channelConfig` sind Secrets geschwärzt. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 TCP monitor public ID (UUID) required` wenn `:tcpMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### TCP Monitor Check Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/tcp-monitors/get-tcp-monitor-check-history
Description: Gibt paginierte Check-Ergebnisse für einen TCP Monitor zurück.
Summary: `GET /api/tcp-monitors/:tcpMonitorPublicId/check-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `tcpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des TCP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). Eine Seite zählt Prüfzyklen, nicht Zeilen: ein Zyklus hat eine Zeile je Standort. - `limit` (number, optional): Zyklen pro Seite (Default: `10`; Max `100`). Bei `format=csv` oder `download=1` gelten die Export-Defaults (Default `10000`, Max `50000` Zeilen). - `status` (string, optional): `success` oder `failure` (`failure` matcht auch `timeout`). Bei Minutenzeilen: kein Standort fehlgeschlagen bzw. mindestens einer. - `minMs` / `maxMs` (number, optional): Filter nach Response-Time-Bereich (`timingTotal`; bei Minutenzeilen der Minutendurchschnitt). - `from` / `to` (ISO-Datumsstring, optional): Filter nach `checkedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. ## cURL ```bash curl "https://YOUR_DOMAIN/api/tcp-monitors/44444444-4444-4444-8444-444444444444/check-history?page=1&limit=10" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "data": [ { "id": "33c53ac4-a2bc-475c-a904-8d3d6aab2979", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-10-01T05:40:55.690Z", "responseTimeMs": 29, "location": { "name": "Paris (FR)", "code": "par" }, "resolution": "raw" }, { "id": "1min-2026-09-30T15:55:00.000Z", "status": "success", "success": true, "errorMessage": null, "checkedAt": "2026-09-30T15:55:00.000Z", "responseTimeMs": 54, "location": null, "resolution": "1min", "totalLocations": 2, "failedLocations": 0 } ], "total": 864, "page": 17, "pageCount": 87, "resolution": "mixed", "rawWindowFrom": "2026-09-30T16:00:00.000Z" } ``` - `resolution` je Zeile: `raw` ist eine einzelne Prüfung mit Standort und Fehlermeldung; `1min` ist eine Minute über alle Standorte, ohne Standort und Fehlermeldung, dafür mit `totalLocations` und `failedLocations`. - `resolution` der Seite: `raw`, `1min` oder `mixed` (die Seite liegt über der Grenze). - `rawWindowFrom`: ab hier gibt es einzelne Prüfungen; ältere Zeilen sind Minutenzeilen. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. CSV-Spalten: `checkedAt,status,responseTimeMs,location,errorMessage,resolution`. ## Aufbewahrung Einzelne Prüfungen mit Standort und Fehlermeldung bleiben 24 Stunden erhalten. Ältere Einträge kommen aus den Minutenwerten (30 Tage), eine Zeile je Minute ohne Standort und Fehlermeldung. Tageswerte (24 Monate) stehen in den Monitor-Details. ## Errors - `400` TCP Monitor Public ID (UUID) erforderlich - `401` Unauthorized - `403` Forbidden - `404` Not found ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status`, `minMs` oder `maxMs` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist
### TCP Monitor Details abrufen
URL: https://docs.uptimeify.io/de/api/monitors/tcp-monitors/get-tcp-monitor-details
Description: Konsolidierter Endpunkt, der die Daten für die TCP Monitor Detailseite in einem Call zurückgibt.
Summary: `GET /api/tcp-monitors/:tcpMonitorPublicId/details` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `tcpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des TCP Monitors. ## Query Parameter - `range` (string, optional): `day`, `week`, `month`, `year` (Default: `day`) - `date` (string, optional): Referenzdatum (wird via `new Date(date)` geparst) - `startDate` (string, optional) - `endDate` (string, optional) - `granularity` (string, optional) - Wenn `raw`, wird Aggregation deaktiviert. ## cURL ```bash curl "https://YOUR_DOMAIN/api/tcp-monitors/44444444-4444-4444-8444-444444444444/details?range=day" \ -H "Authorization: Bearer $TOKEN" ``` ## Response Die Response ist ein einzelnes Objekt mit diesen Top-Level Keys: - `tcpMonitorId` - `monitor` - `latestCheck` - `uptimeStats` - `uptimeStatsMeta` - `monitoringData` - `incidents` - `alerts` - `testResultLog` - `maintenance` Beispiel (gekürzt): ```json { "tcpMonitorId": 300, "monitor": { "id": 300, "customerId": 10, "name": "Redis Primary", "hostname": "redis.deinkunde.com", "port": 6379, "status": "active", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "config": { "expectBanner": "+PONG" } }, "latestCheck": { "status": "success", "checkedAt": "2026-02-26T12:00:00.000Z", "timingTotal": 123, "locationCode": "de-nbg", "locationName": "Nuremberg (DE)" }, "uptimeStats": { "day": 99.9, "month": 99.5, "year": 99.0, "dayAvgResponse": 120, "monthAvgResponse": 140, "yearAvgResponse": 150 }, "maintenance": { "inMaintenance": false, "activeWindows": [], "allWindows": [] } } ``` ## Aufbewahrung Einzelne Prüfungen bleiben 24 Stunden erhalten, Minutenwerte 30 Tage und Tageswerte 24 Monate; ein Zeitraum, der älter als 30 Tage ist, liefert einen Punkt pro Tag. Hat der Monitor in den letzten 24 Stunden nicht geprüft, beschreibt `latestCheck` seine letzte Minute aus dem Aggregat: `id` beginnt mit `1min-`, `resolution` ist `1min`, `locationId` und `errorMessage` sind `null`. ## Errors - `400` Ungültige TCP Monitor Public ID (UUID) - `401` Unauthorized - `403` Forbidden - `404` Not found - `500` Failed to fetch TCP monitor details ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `range` nicht `day`/`week`/`month`/`year` ist, `date`/`startDate`/`endDate` kein Datum ist, nur eines von `startDate`/`endDate` kommt, `tz` keine Ganzzahl ist oder `granularity` weder `raw` noch `aggregated`
### TCP Monitor Ausfall-Historie abrufen
URL: https://docs.uptimeify.io/de/api/monitors/tcp-monitors/get-tcp-monitor-incident-history
Description: Gibt paginierte Vorfälle eines einzelnen TCP Monitors zurück, inklusive berechneter Dauer.
Summary: `GET /api/tcp-monitors/:tcpMonitorPublicId/incident-history` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `tcpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des TCP Monitors. ## Query Parameter - `page` (number, optional): Seite (Default: `1`). - `limit` (number, optional): Einträge pro Seite (Default: `25`; Max `100`). Wird bei `format=csv` oder `download=1` durch die Export-Defaults ersetzt (Default `10000`, Max `50000`). - `status` (string, optional): `open`, `acknowledged` oder `resolved`. - `type` (string, optional): `downtime`, `http_status`, `ssl_expiry`, `ssl_critical`, `ssl_warning`, `response_time`, `dnsbl`, `domain_expiry_warning`, `critical` oder `inconclusive`. - `from` / `to` (ISO-Datumsstring, optional): Filter nach `startedAt`-Bereich. - `format` (string, optional): `json` (Default) oder `csv`. - `download` (string, optional): `1` erzwingt einen Attachment-Download, `0` (Default) liefert die Seite. - `envelope` (string, optional): `items` liefert die Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/tcp-monitors/11111111-1111-4111-8111-111111111111/incident-history?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Beispiel-Antwort ```json { "items": [ { "id": 123, "publicId": "55555555-5555-4555-8555-555555555555", "type": "downtime", "status": "resolved", "startedAt": "2026-02-26T12:10:00.000Z", "endedAt": "2026-02-26T12:12:30.000Z", "durationMs": 150000, "statusCode": null, "errorMessage": "connect ETIMEDOUT", "details": "connect ETIMEDOUT", "isOngoing": false } ], "total": 1, "page": 1, "perPage": 25 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist das `limit`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ data, total, page, pageCount }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. **Abgelöstes Feld:** `duration` (Text, z. B. `2m 30s`) wird bis zum Entfall am 18.01.2027 weiter neben `durationMs` geliefert. Lies `durationMs`. `status` ist `open`, `acknowledged` oder `resolved`. Laufende Vorfälle haben ein `null` bei `endedAt` und `isOngoing: true`. Bei `format=csv` (oder `download=1`) ist die Response ein `text/csv`-Attachment (bzw. `application/json` bei `format=json&download=1`) anstelle der paginierten JSON-Antwort oben. ## Häufige Fehler - `400 TCP monitor public ID (UUID) required` wenn `:tcpMonitorPublicId` ungültig ist - `400 Bad Request` (`invalidRequestBody`) wenn ein Query-Parameter ungültig ist: `page`/`limit` keine positive Ganzzahl, `format` weder `json` noch `csv`, `download` weder `0` noch `1`, oder ein unbekannter Wert in `status` oder `type` - `400 Bad Request` (`invalidDateRange`) wenn `from` oder `to` kein Datum ist - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf den Monitor hast
### TCP Monitore auflisten
URL: https://docs.uptimeify.io/de/api/monitors/tcp-monitors/list-tcp-monitors
Description: Listet TCP Monitore einer Organisation auf.
Summary: `GET /api/tcp-monitors` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `organizationId` (Query, optional): Organisations-ID. Default ist die Organisation des aktuellen Nutzers. - `customerId` (Query, optional): Nach Kunden-ID filtern. - `search` (Query, optional): Suche nach Name, Hostname oder Kunde. - `page` (Query, optional): Seite (Default: 1). - `perPage` (Query, optional): Einträge pro Seite (Default: 50, Max: 200). ## cURL ```bash curl "https://YOUR_DOMAIN/api/tcp-monitors?page=1&perPage=50" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "items": [ { "id": 300, "publicId": "44444444-4444-4444-8444-444444444444", "organizationId": 1, "customerId": 10, "name": "Redis Primary", "hostname": "redis.deinkunde.com", "port": 6379, "status": "active", "managementType": "managed", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "customerName": "Example Customer", "notificationEmail": null, "notificationPhoneNumber": null, "lastCheckedAt": "2026-02-26T12:00:00.000Z", "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:00:00.000Z", "expectedState": "up", "config": { "expectBanner": "+PONG" }, "tags": [] } ], "total": 1, "page": 1, "perPage": 50 } ``` ## Inline-Metriken Jeder Eintrag traegt dieselben verdichteten Kennzahlen, die auch die uebrigen Monitor-Listen liefern. Sie werden je Monitor ueber den Kalendertag, den Monat und das Jahr in UTC gebildet. | Feld | Typ | Bedeutung | |------|-----|-----------| | `uptimeDay` / `uptimeMonth` / `uptimeYear` | string | Verfuegbarkeit in Prozent mit zwei Nachkommastellen, z. B. `"99.94"` | | `avgResponseDay` / `avgResponseMonth` / `avgResponseYear` | number \| null | Mittlere Antwortzeit in Millisekunden; `null`, wenn in dem Fenster nichts gemessen wurde | | `responseGraph` | object | `{ values, avg }` fuer die letzten 24 Stunden, ein Eintrag je Stunde; eine Stunde ohne erfolgreiche Pruefung ist `null` | | `upSinceAt` | string \| null | ISO-Zeitpunkt, seit dem der Monitor laeuft, `null` solange er ausgefallen ist | | `isDown` | boolean | Ob der Monitor gerade in einem unaufgeloesten Vorfall steckt | Die Tageswerte kommen aus den Rohdaten, Monat und Jahr aus fortlaufenden Aggregaten -- in diesen beiden Fenstern kann ein Wert der neuesten Pruefung daher um einige Minuten hinterherhinken. ## Errors - `400` Ungültige `organizationId` oder `customerId` - `401` Unauthorized - `403` Forbidden ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `page` oder `perPage` keine positive Ganzzahl ist, `sortOrder` weder `asc` noch `desc` oder `tags` keine kommagetrennte Liste von Tag-IDs
### TCP Check triggern
URL: https://docs.uptimeify.io/de/api/monitors/tcp-monitors/trigger-check-tcp-monitor
Description: Startet einen sofortigen Check von einem zulässigen Monitoring-Standort.
Summary: `POST /api/tcp-monitors/:tcpMonitorPublicId/trigger-check` ## Authentifizierung Erfordert eine gültige Session und Schreibrechte. - Header: `Authorization: Bearer ` ## Parameter - `tcpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des TCP Monitors. ## Hinweise - Der Standort wird deterministisch aus den aktuell aktiven Monitoring-Standorten gewählt (gefiltert nach `allowedCheckCountryCodes` des Monitors bzw. des Kunden, falls gesetzt). - Pro Monitor rate-limited über einen kurzen Cooldown; zu schnelles erneutes Triggern liefert `429`. ## cURL ```bash curl -X POST "https://YOUR_DOMAIN/api/tcp-monitors/44444444-4444-4444-8444-444444444444/trigger-check" \ -H "Authorization: Bearer $TOKEN" ``` ## Response ```json { "success": true, "message": "Check triggered successfully", "tcpMonitorId": 300, "locationCode": "de-nbg", "queueName": "tcp-monitor-checks-de-nbg" } ``` ## Errors - `400` Keine zulässigen Monitoring-Standorte für die ausgewählten Länder - `401` Unauthorized - `403` Forbidden - `404` Not found - `429` Check wurde kürzlich bereits getriggert: erneut nach dem Cooldown versuchen (`retryAfterMs` im Error-Payload) - `500` / `503` Failed to trigger check (z. B. "No active monitoring locations available")
### TCP Monitor aktualisieren
URL: https://docs.uptimeify.io/de/api/monitors/tcp-monitors/update-tcp-monitor
Description: Aktualisiert einen TCP Monitor und/oder ändert den Status.
Summary: `PATCH /api/tcp-monitors/:tcpMonitorPublicId` ## Authentifizierung Erfordert eine gültige Session. - Header: `Authorization: Bearer ` ## Parameter - `tcpMonitorPublicId` (Pfad, erforderlich): Öffentliche UUID des TCP Monitors. ## Request Body Alle Felder sind optional. ```json { "name": "Redis Primary", "hostname": "redis.deinkunde.com", "port": 6379, "status": "paused", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["de", "es"], "config": { "expectBanner": "+PONG" } } ``` ### Hinweise - `status` akzeptiert `active`, `maintenance`, `disabled`, `paused`, `inactive`. - `paused` und `inactive` werden zu `disabled` normalisiert. - `port` muss, falls angegeben, eine Ganzzahl zwischen `1` und `65535` sein. - `allowedCheckCountryCodes` wird zu Uppercase ISO Codes normalisiert (z. B. `DE`, `US`). Leere Listen werden zu `null`. - `config` akzeptiert nur den Key `expectBanner` (wird in die bestehende gespeicherte Config gemergt). Es gibt keinen `sshConfig`-artigen Alias und keine Zugangsdaten-Felder. TCP-Monitore enthalten keine Zugangsdaten. Wenn weggelassen, bleibt die gespeicherte Config unverändert. - `expectedState` (`up` oder `down`, auf oberster Ebene, nicht in `config`) schaltet zwischen Alarm bei nicht erreichbarem Port (`up`) und Alarm bei angenommener Verbindung (`down`) um; was als geschlossen gilt, steht unter TCP-Monitor erstellen. `expectBanner` wird ignoriert, solange `down` gilt. Wenn weggelassen, bleibt der gespeicherte Wert unverändert. - Nutzer mit Rolle `readonly` können nur `status` ändern. ## cURL ```bash curl -X PATCH "https://YOUR_DOMAIN/api/tcp-monitors/44444444-4444-4444-8444-444444444444" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "status": "disabled" }' ``` ## Response ```json { "id": 300, "publicId": "44444444-4444-4444-8444-444444444444", "organizationId": 1, "customerId": 10, "name": "Redis Primary", "hostname": "redis.deinkunde.com", "port": 6379, "status": "disabled", "managementType": "managed", "checkInterval": 60, "timeoutSeconds": 30, "allowedCheckCountryCodes": ["DE"], "notificationEmail": null, "notificationPhoneNumber": null, "lastCheckedAt": "2026-02-26T12:00:00.000Z", "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:01:00.000Z", "expectedState": "up", "config": { "expectBanner": "+PONG" } } ``` ## Errors - `400` TCP Monitor Public ID (UUID) erforderlich / ungültige Felder (z. B. `invalidPort`, `invalidConfig`, `invalidStatus`) - `401` Unauthorized - `403` Forbidden (readonly darf nur `status` ändern; global supporters dürfen nicht updaten) - `404` Not found ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`) wenn `name` kein nicht-leerer String mit höchstens 255 Zeichen ist oder `allowedCheckCountryCodes` weder ein Array von Ländercodes noch `null` - `400 Bad Request` (`invalidTimeoutSeconds`) wenn `timeoutSeconds` keine Ganzzahl zwischen 1 und 60 ist - `400 Bad Request` (`invalidConfig`) wenn ein Config-Feld (`config` oder das typspezifische) kein Objekt ist
### Benachrichtigungskanäle
URL: https://docs.uptimeify.io/de/api/notification-channels
Description: Verwalte, wie und wohin Alerts zugestellt werden. Kanäle können auf Organisationsebene (Standard für alle Kunden), auf Kundenebene (Override für einen bestimmten Kunden) oder auf Website-Ebene (Override für einen bestimmten Monitor) liegen.
Summary: ## Authentifizierung Alle Beispiele setzen einen Bearer-Token voraus: ```bash BASE_URL="https://uptimeify.io" TOKEN="" ``` ## Kanaltypen und Config Jeder Kanaltyp hat eine spezifische `config`-Struktur: | Type | Config Fields | Notes | |------|--------------|-------| | `email` | `{ email, to }` | E-Mail-Adresse und Empfängername | | `sms` | `{ phoneNumber }` | Telefonnummer im internationalen Format | | `webhook` | `{ url, method?, headers?, bodyTemplate?, timeout?, retryAttempts?, retryDelay?, expectedStatusCodes?, secret? }` | HTTP-Webhook. `secret` für HMAC-Signierung | | `slack` | `{ webhookUrl, username?, iconEmoji?, color? }` | Slack Incoming-Webhook-URL. Die URL enthält das Posting-Token und gilt als Geheimnis | | `discord` | `{ webhookUrl, username?, color? }` | Discord Incoming-Webhook-URL. Die URL enthält das Posting-Token und gilt als Geheimnis | | `teams` | `{ webhookUrl }` | Microsoft-Teams-Workflow- bzw. Connector-URL. Gilt als Geheimnis | | `pagerduty` | `{ routingKey }` | PagerDuty Events API v2 Routing-Key | | `pushover` | `{ userKey, apiToken }` | Pushover User-Key und API-Token | | `opsgenie` | `{ apiKey }` | Opsgenie API-Key | Geheimnisse (Webhook-`secret`, Slack-/Discord-/Teams-Webhook-URLs, PagerDuty-Routing-Keys, Pushover-Zugangsdaten, Opsgenie-API-Keys) werden **verschlüsselt gespeichert** und **in API-Antworten unkenntlich gemacht**: Der Wert kommt als `null` zurück, und ein boolesches Flag daneben sagt, ob einer hinterlegt ist (`hasSecret`, `hasWebhookUrl`, `hasRoutingKey`, …). Ein Slack-, Discord- oder Teams-Kanal liest sich deshalb als `"config": { "webhookUrl": null, "hasWebhookUrl": true, … }`. Lässt du ein solches Feld beim `PATCH` weg (oder schickst `null` bzw. einen leeren String), bleibt der gespeicherte Wert erhalten; ein neuer Wert ersetzt ihn. Der generische Typ `webhook` ist die Ausnahme: Seine `url` ist die eigene Adresse des Kunden und bleibt sichtbar, nur sein `secret` wird unkenntlich gemacht. ## Webhook-Signaturprüfung Wenn auf einem Webhook-Kanal ein `secret` konfiguriert ist, signiert Uptimeify ausgehende Payloads, damit Empfänger die Authentizität verifizieren können. **Algorithmus:** HMAC-SHA256 **Header:** `X-Webhook-Signature`: hex-kodierter HMAC-SHA256-Digest **Begleitende Header, die mit jedem Webhook gesendet werden:** | Header | Value | |--------|-------| | `X-Webhook-Signature` | Hex-kodierter HMAC-SHA256-Digest | | `X-Webhook-Signature-Algorithm` | `sha256` | | `X-Webhook-Timestamp` | ISO-8601-Zeitstempel (z. B. `2026-05-05T12:00:00.000Z`) | | `X-Webhook-Attempt` | 1-basierte Retry-Nummer (z. B. `1`, `2`, `3`) | | `X-Webhook-Event` | Event-Typ: `alert`, `recovery` oder `dnsbl` | **Verifizierungsschritte:** 1. Lies den rohen Request-Body als String (nicht zuerst als JSON parsen). 2. Berechne HMAC-SHA256 mit dem im Kanal konfigurierten `secret` als Schlüssel und dem rohen Body-String als Nachricht. 3. Vergleiche das Ergebnis (hex-kodiert) mit dem Wert des `X-Webhook-Signature`-Headers per konstanter Laufzeit-Vergleich (constant-time comparison). 4. Optional kannst du `X-Webhook-Timestamp` für Replay-Schutz prüfen. ```javascript // Node.js verification example const crypto = require('crypto') function verifySignature(rawBody, signature, secret) { const expected = crypto .createHmac('sha256', secret) .update(rawBody) .digest('hex') return crypto.timingSafeEqual( Buffer.from(signature), Buffer.from(expected) ) } ``` ```python # Python verification example def verify_signature(raw_body, signature, secret): expected = hmac.new( secret.encode('utf-8'), raw_body.encode('utf-8'), hashlib.sha256 ).hexdigest() return hmac.compare_digest(signature, expected) ``` ## Scope-Auflösung Beim Auflisten von Kanälen bestimmt der Scope, welche Kanäle zurückgegeben werden: - **Organisationsebene** (nur `organizationId`, kein `customerId`/`websiteId`): Standardkanäle für alle Kunden - **Kundenebene** (`customerId` gesetzt, kein `websiteId`): Kundenspezifische Overrides - **Website-…
### Benachrichtigungskanal erstellen
URL: https://docs.uptimeify.io/de/api/notification-channels/create-notification-channel
Description: Erstellt einen neuen Benachrichtigungskanal. Geheimnisse in config werden serverseitig verschlüsselt.
Summary: `POST /api/notification-channels` ## Anfrage (Request Body) | Field | Type | Required | Default | Description | |-------|------|----------|---------|-------------| | `type` | string | Ja | - | Kanaltyp, einer aus der Liste unten (alles andere ist ein `400`) | | `name` | string | Ja | - | Anzeigename, 1 bis 100 Zeichen | | `config` | object\|string | Ja | - | Kanalkonfiguration (siehe Typtabelle). Als JSON-Objekt oder JSON-String mit höchstens 20 kB übergeben. | | `organizationId` | number | Nein | aus Session | Organisations-Scope | | `customerId` | number | Nein | null | Kunden-Scope | | `websiteId` | number | Nein | null | Website-Scope. Erfordert `sourceChannelId`. | | `sourceChannelId` | number\|string | Bedingt | null | Übergeordnete Kanal-ID für Website-Overrides | | `category` | string | Nein | `direct` | `direct` oder `integration` | | `delaySeconds` | number | Nein | 0 | Verzögerung vor dem Senden des Alerts, Ganzzahl 0 bis 86400 | | `conditions` | object\|string | Nein | null | Alert-Bedingungen (z. B. `{"onlyFullService": true, "minIncidentDuration": 300}`), JSON-Objekt oder JSON-String mit höchstens 20 kB | | `isActive` | boolean | Nein | true | Ob der Kanal aktiv ist | `delaySeconds` läuft für diesen Kanal auf einer eigenen Uhr, beginnend in dem Moment, in dem dieser Kanal benachrichtigen würde, unabhängig von jedem anderen Kanal am selben Alarm. Beginnt in dieser Zeit ein Wartungsfenster oder ist die Störung bis dahin bereits behoben, wird auf diesem Kanal nichts mehr zugestellt. `priority` ist aus der Kanalkonfiguration entfernt. Eine Anfrage, die das Feld noch mitschickt, wird weiterhin angenommen, das Feld wird einfach ignoriert, sodass bestehende Integrationen unverändert weiterlaufen. ## Kanaltypen Direkt (`category: "direct"`): `email`, `sms`, `webhook`. Integrationen (`category: "integration"`): `incident_management`, `slack`, `discord`, `teams`, `pagerduty`, `opsgenie`, `allquiet`, `telegram`, `googlechat`, `mattermost`, `rocketchat`, `matrix`, `lark`, `dingtalk`, `wecom`, `ilert`, `grafanaoncall`, `squadcast`, `incidentio`, `pushover`, `ntfy`, `gotify`, `jira`, `github`, `gitlab`, `linear`, `servicenow`. Die `config`-Felder hängen vom Typ ab: siehe [Integrationen](/de/integrations), was jeder Kanal benötigt. Du kannst einen Kanal vor dem Speichern mit dem Endpunkt [Benachrichtigungskanal testen](/de/api/notification-channels/test-notification-channel) validieren. ### `incident_management` Uptimeifys eigenes Incident Management ist ein Integrationskanal wie jeder andere, mit zwei Unterschieden: - Er erwartet eine **leere `config`** (`{}`). Es gibt keinen Endpunkt und keine Zugangsdaten; bestätigte Ausfälle werden intern zugestellt. - Er ist **nicht testbar**: der Endpunkt [Benachrichtigungskanal testen](/de/api/notification-channels/test-notification-channel) unterstützt diesen Typ nicht. Der Kanal steuert, *welche* Monitore über Incident Management alarmieren. Sein Geltungsbereich (`customerId` / `websiteId`, beide optional, beide weglassen für die gesamte Organisation) und seine `allowedPackageTypes` bestimmen, wessen bestätigte Ausfälle zu IM-Incidents werden; alles andere bleibt bei den klassischen Benachrichtigungen. Ein Monitoring-Ausfall erreicht Incident Management nur dann, wenn ein passender, aktiver Kanal existiert **und** das Paket des Kunden Integrations-Alarme erlaubt. ## Beispiel (cURL): E-Mail-Kanal ```bash curl -X POST "$BASE_URL/api/notification-channels" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "type": "email", "name": "Ops Email", "config": { "email": "ops@deinkunde.com", "to": "Ops Team " }, "organizationId": 1 }' ``` ## Beispiel (cURL): Slack-Kanal ```bash curl -X POST "$BASE_URL/api/notification-channels" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "type": "slack", "name": "Alerts Slack Channel", "config": { "webhookUrl": "https://hooks.slack.com/services/T00/B00/xxx" }, "organizationId…
### Benachrichtigungskanal löschen
URL: https://docs.uptimeify.io/de/api/notification-channels/delete-notification-channel
Description: Löscht einen Benachrichtigungskanal. War der Kanal ein Standard auf Organisationsebene, werden die Organisations-Standards automatisch synchronisiert.
Summary: `DELETE /api/notification-channels/:id` ## Beispiel (cURL) ```bash curl -X DELETE "$BASE_URL/api/notification-channels/1" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort (Response) ```json { "success": true } ``` ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` wenn du auf Kanäle außerhalb deines Scopes zugreifst - `404 Not found` wenn der Kanal nicht existiert ## Berechtigungen Organisations-Admins schreiben Kanäle auf jeder Ebene. Ein kundengebundener Zugang (Rolle `readonly`) darf Kanäle anlegen, ändern und löschen, die an einen SEINER EIGENEN Kunden gebunden sind. Genau das bietet ihm die Integrationsseite im Dashboard an, während die API es bis zum 04.09.2026 mit einem nackten `403` verweigert hat. Zwei Grenzen bleiben: Ein Kanal auf Organisationsebene, also ohne `customerId`, ist weiterhin Admins vorbehalten, und ein Kanal eines Kunden ausserhalb des eigenen Scopes wird abgelehnt wie bisher. Die Rollen `editor` und `responder` schreiben hier nicht.
### Benachrichtigungskanal abfragen
URL: https://docs.uptimeify.io/de/api/notification-channels/get-notification-channel
Description: Gibt einen Benachrichtigungskanal zurück, in derselben Form wie ein Eintrag der Kanalliste. Geheimnisse in config sind geschwärzt.
Summary: `GET /api/notification-channels/{id}` ## Zugriff Dieselbe Bereichsprüfung wie beim Bearbeiten, nur lesend: Ein Website-Kanal braucht Lesezugriff auf die Website, ein Kundenkanal den Kunden in deinem Bereich (ein kundengebundener API-Token erreicht nur seinen eigenen Kunden), ein Organisationskanal Lesezugriff auf die Organisation. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/notification-channels/42" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) `200 OK` ```json { "id": 42, "organizationId": 10, "customerId": 5, "websiteId": null, "type": "webhook", "category": "alert", "name": "Ops webhook", "config": { "webhookUrl": "https://hooks.example.com/t/1", "secret": "********" }, "delaySeconds": 0, "conditions": null, "allowedPackageTypes": null, "isActive": true, "verifiedAt": null, "createdAt": "2026-06-01T08:00:00.000Z" } ``` ## Häufige Fehler - `400 Bad Request` (`invalidChannelId`), wenn die ID keine positive Zahl ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden`, wenn der Kanal außerhalb deines Bereichs liegt - `404 Not Found` (`channelNotFound`), wenn der Kanal nicht existiert
### Benachrichtigungskanäle auflisten
URL: https://docs.uptimeify.io/de/api/notification-channels/list-notification-channels
Description: Gibt Benachrichtigungskanäle zurück, gescoped nach Organisation, Kunde oder Website.
Summary: `GET /api/notification-channels` ## Query Parameter | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `organizationId` | number | Nein | Scope auf Organisation | | `customerId` | number | Nein | Scope auf Kunde | | `websiteId` | number | Nein | Scope auf Website (inklusive Organisations- + Kundenkanäle) | | `envelope` | string | Nein | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/notification-channels?organizationId=1&envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "items": [ { "id": 1, "organizationId": 1, "customerId": null, "websiteId": null, "type": "email", "category": "direct", "name": "Ops Email", "config": { "email": "ops@deinkunde.com", "to": "Ops Team" }, "delaySeconds": 0, "conditions": null, "isActive": true, "allowedPackageTypes": null }, { "id": 2, "organizationId": 1, "customerId": null, "websiteId": null, "type": "slack", "category": "integration", "name": "Alerts Slack Channel", "config": { "webhookUrl": null, "hasWebhookUrl": true, "username": "Uptimeify" }, "delaySeconds": 0, "conditions": null, "isActive": true, "allowedPackageTypes": null } ], "total": 2, "page": 1, "perPage": 2 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Einträge); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Geheimnisse innerhalb von `config` werden nie zurückgegeben: Eine Slack-, Discord- oder Teams-Webhook-URL kommt als `null` zurück, daneben steht `hasWebhookUrl: true`, siehe „Kanaltypen und Config" auf der Übersichtsseite der Notification Channels. Eigene HTTP-Header (`config.headers`, `config.webhookHeaders`) behalten ihre Namen, die Werte kommen nie zurück: `{ "X-Api-Key": null }`, dazu `hasHeaders: true` in `config`. Die Werte werden verschlüsselt gespeichert. Bis zum 20.10.2026 kamen sie im Klartext zurück. ## Sichtbarkeit Ohne `websiteId` und ohne `customerId` hängt es davon ab, wer liest, welche Kanäle zurückkommen: - Ein **uneingeschränkter Leser** (Organisations-Admin, globaler Admin sowie ein organisationsgebundenes Agent-Token) erhält die Kanäle auf Organisationsebene, also jene mit `customerId: null` und `websiteId: null`. - Ein **kundengebundener Leser** (ein `readonly`-Benutzer oder ein `editor` mit expliziten Kundenzuweisungen, dazu das für ihn ausgestellte API- oder Agent-Token) erhält zusätzlich die Kanäle seiner eigenen Kunden. Kanäle eines anderen Kunden kommen nie zurück. Mit `customerId` kommen die Kanäle dieses Kunden plus die auf Organisationsebene zurück. Mit `websiteId` kommen zusätzlich die website-eigenen Override-Kanäle zurück. ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` wenn du auf Kanäle außerhalb deines Scopes zugreifst
### Benachrichtigungskanal testen
URL: https://docs.uptimeify.io/de/api/notification-channels/test-notification-channel
Description: Testet die Konfiguration eines Benachrichtigungskanals. Sendet optional eine echte Testnachricht.
Summary: `POST /api/notification-channels/test` ## Anfrage (Request Body) | Field | Type | Required | Default | Description | |-------|------|----------|---------|-------------| | `type` | string | Ja | - | `webhook`, `slack`, `discord`, `pagerduty`, `pushover`, `opsgenie` | | `config` | object | Ja | `{}` | Kanal-Config mit Geheimnissen | | `organizationId` | number | Nein | aus Session | Organisations-Scope | | `customerId` | number | Nein | null | Kunden-Scope | | `websiteId` | number | Nein | null | Website-Scope | | `channelId` | number | Nein | - | Bestehender Kanal, der getestet wird. Ein Header in `config` mit Wert `null` oder `""` nimmt dann den gespeicherten Wert dieses Kanals (braucht Bearbeitungsrecht am Kanal). Ohne `channelId` fällt ein solcher Header weg. | | `dryRun` | boolean | Nein | false | Falls true, wird nur validiert (kein tatsächliches Senden) | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/notification-channels/test" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "type": "webhook", "config": { "url": "https://deinkunde.com/webhook", "method": "POST", "timeout": 15 }, "dryRun": false }' ``` ## Antwort (Response) ```json { "success": true, "mode": "send", "message": "Webhook delivered successfully", "validation": { "ok": true, "errors": [], "warnings": [] }, "request": { "url": "https://deinkunde.com/webhook", "method": "POST", "timeoutSeconds": 15, "headers": {}, "bodyPreview": "...", "bodySize": 256 }, "response": { "reachable": true, "ok": true, "statusCode": 200, "statusText": "OK", "durationMs": 150, "headers": {}, "bodyPreview": null, "bodySize": null } } ``` HTTP-429-Antworten werden als „erreichbar, aber rate-limitiert" behandelt (success: true). ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `400 Bad Request` wenn die Config für den angegebenen Typ ungültig ist - `400 Bad Request`, wenn ein eigener Header in `config.headers` / `config.webhookHeaders` nicht erlaubt ist: `Host` antwortet `webhookHostHeaderForbidden`; ein Name, der kein gültiger HTTP-Headername ist, ein Wert mit Zeilenumbruch oder anderem Steuerzeichen und die Header, die der Versand selbst setzt (`Content-Length`, `Transfer-Encoding`, `Connection`, `Keep-Alive`, `Upgrade`, `TE`, `Trailer`, `Expect`, `Proxy-Connection`), antworten `invalidRequestBody` mit dem Header in `issues[].path`. `Authorization` ist erlaubt.
### Benachrichtigungskanal aktualisieren
URL: https://docs.uptimeify.io/de/api/notification-channels/update-notification-channel
Description: Aktualisiert einen Benachrichtigungskanal.
Summary: `PATCH /api/notification-channels/:id` Die Config wird mit den bestehenden Geheimnissen **zusammengeführt (merged)**, wobei verschlüsselte Felder, die nicht übergeben werden, erhalten bleiben, solange der Kanal seinen `type` behält. **Header:** `config.headers` / `config.webhookHeaders` ersetzen die gespeicherte Liste (ein nicht genannter Header wird entfernt). Ein Header mit Wert `null` oder `""` behält seinen gespeicherten Wert, so lassen sich die Namen aus einer Leseantwort zurückschicken, ohne die Werte zu kennen. Neue Werte werden verschlüsselt gespeichert. **Ein Wechsel des `type`** verhält sich anders: Die gespeicherte Config gehört zum alten Kanaltyp, sie wird komplett verworfen und die Config wird **aus der `config` dieser Anfrage neu aufgebaut**. Ein Typwechsel braucht deshalb zwingend `config` (sonst `400`), und Geheimnisse des alten Typs werden nicht übernommen. ## Anfrage (Request Body) (alle optional) | Feld | Typ | Beschreibung | |-------|------|-------------| | `type` | string | Kanaltyp, einer der [unterstützten Typen](/de/api/notification-channels/create-notification-channel#kanaltypen). Erfordert `config`. | | `name` | string | Anzeigename, 1 bis 100 Zeichen | | `config` | object\|string | Mit bestehenden Geheimnissen zusammengeführt (gleicher Typ) oder ersetzt die Config vollständig (Typwechsel). JSON-Objekt oder JSON-String mit höchstens 20 kB. | | `delaySeconds` | number | Verzögerung vor dem Senden, Ganzzahl 0 bis 86400 | | `conditions` | object\|string\|null | Alert-Bedingungen, JSON-Objekt oder JSON-String mit höchstens 20 kB | | `allowedPackageTypes` | string[]\|null | Pakettypen, auf die dieser Kanal angewendet wird, max. 50 Einträge | | `isActive` | boolean | Ob der Kanal aktiv ist | `delaySeconds` läuft für diesen Kanal auf einer eigenen Uhr, beginnend in dem Moment, in dem dieser Kanal benachrichtigen würde, unabhängig von jedem anderen Kanal am selben Alarm. Beginnt in dieser Zeit ein Wartungsfenster oder ist die Störung bis dahin bereits behoben, wird auf diesem Kanal nichts mehr zugestellt. `priority` ist aus der Kanalkonfiguration entfernt. Eine Anfrage, die das Feld noch mitschickt, wird weiterhin angenommen, das Feld wird einfach ignoriert, sodass bestehende Integrationen unverändert weiterlaufen. ## Beispiel (cURL) ```bash curl -X PATCH "$BASE_URL/api/notification-channels/1" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "Updated Email Channel", "isActive": true }' ``` ## Häufige Fehler - `400 Bad Request` mit `data.code` `invalidRequestBody`, wenn ein `email`- oder `sms`-Kanal einen Empfänger trägt, den der Zustellweg nie annehmen könnte. Geprüft werden bei `type: email` die Schlüssel `config.to` und `config.email`, bei `type: sms` die Schlüssel `config.to`, `config.phoneNumbers` und `config.phoneNumber`; eine kommagetrennte Zeichenkette und ein Array gelten beide als Liste, jeder Eintrag wird geprüft, und die Meldung nennt den ersten beanstandeten Wert. Eine Mailadresse braucht genau ein `@` mit Inhalt auf beiden Seiten und ohne Leerzeichen, die Form `Name ` ist erlaubt; eine SMS-Nummer muss E.164 sein: ein `+`, eine Ziffer 1-9, dann 7 bis 14 weitere Ziffern, ohne Leerzeichen, Bindestriche oder Klammern. Das sind die Regeln des Zustellwegs selbst, ein hier abgewiesener Wert hätte also nie einen Alarm empfangen. Ein Kanal OHNE eigenen Empfänger bleibt gültig: die Zustellung fällt dann auf die hinterlegte Adresse des Kunden oder der Organisation zurück. Geprüft werden nur `email` und `sms`; bei jedem anderen Typ bedeuten diese Schlüssel etwas anderes. - `400 Bad Request` mit `data.code` `smsCountryNotAllowed`, wenn ein `sms`-Kanal eine Nummer außerhalb von EU/EWR, Schweiz und Vereinigtem Königreich trägt. Alarm-SMS gehen nur in diese Länder; geprüft wird die Ländervorwahl (`+49`, `+44`, `+353`, ...). Der Alarm-Worker prüft dieselbe Liste vor dem Versand noch einmal: ein älterer Kanal mit einem anderen Land wird übersprungen und steht als…
### Verbundene Apps (OAuth-Verbindungen)
URL: https://docs.uptimeify.io/de/api/oauth-connections
Description: Liste und widerrufe die OAuth-/MCP-Apps, die mit deinem Konto verbunden sind, z. B. Claudes Remote-MCP-Connector.
Summary: Mit Uptimeify kannst du Drittanbieter-Apps (wie Claude Desktop / Claude.ai) per [MCP-OAuth](/de/api/mcp) verbinden. Mit diesen beiden Endpunkten kann der angemeldete Nutzer seine eigenen Verbindungen auflisten und widerrufen. Sie stehen hinter der Seite **Einstellungen → Verbundene Apps** im Dashboard. Beide Endpunkte sind **session-authentifiziert** (Browser-Cookie), nicht token-basiert: sie gehören nicht zur `wsm_`-/`wsma_`-API-Token-Oberfläche, und jede Operation ist strikt auf die eigenen Verbindungen des Aufrufers beschränkt. ## So verbinden sich Clients Ein Client meldet sich auf einem von zwei Wegen an: mit einem **Client ID Metadata Document** (CIMD, bevorzugt), bei dem die `client_id` eine HTTPS-Adresse ist, unter der der Client seine eigenen Metadaten bereitstellt, oder über die **dynamische Client-Registrierung** unter `/api/auth/oauth2/register`. Die Metadaten des Autorisierungsservers unter `/.well-known/oauth-authorization-server` nennen alle Endpunkte; Autorisierung und Token-Tausch liegen unter `/api/auth/oauth2/`. Access-Tokens sind signierte JWTs, gebunden an die Ressource `https://uptimeify.io/mcp`, und eine Stunde gültig. Mit `offline_access` bekommt der Client zusätzlich ein Refresh-Token, sieben Tage gültig und bei jeder Verwendung ersetzt. Ein Widerruf wirkt sofort, auch für ein Access-Token, das noch nicht abgelaufen ist. ## Scopes Eine Verbindung trägt Scopes, und jeder davon deckt genau einen Bereich deiner Monitoring-Daten ab. Insgesamt gibt es sechzehn: acht Lese-Scopes, den Sammel-Alias `mcp:read` für drei davon und sieben Schreib-Scopes, mit denen die Verbindung Daten in diesem Bereich ändern statt nur ansehen darf. ### Lese-Scopes | Scope | Deckt ab | Werkzeuge | | --- | --- | --- | | `mcp:monitors:read` | Deine Monitore und deren aktuellen Zustand | `list_monitors`, `monitor_status` | | `mcp:incidents:read` | Vorfälle über deine Monitore hinweg | `list_incidents` | | `mcp:checks:read` | Prüfhistorie und Uptime-Werte | `check_history`, `uptime_summary` | | `mcp:alerts:read` | Benachrichtigungskanäle, Eskalationskonfiguration, Alarmhistorie | `list_alert_channels`, `alert_history` | | `mcp:statuspages:read` | Statusseiten und Wartungsfenster | `list_status_pages`, `list_maintenance_windows` | | `mcp:organization:read` | Organisationsprofil, Kunden und Nutzer | `get_organization`, `list_users`, `list_customers` | | `mcp:billing:read` | Abrechnung und SMS-Verbrauch | `billing_summary` | | `mcp:im:read` | Incident Management: Vorfälle mit Verlauf, wer Rufbereitschaft hat, Teams und Dienstpläne, Personen nur mit Namen | `list_im_incidents`, `get_im_incident`, `who_is_on_call`, `list_im_teams`, `get_im_team`, `list_im_schedules` und `get_im_schedule` | | `mcp:read` | Sammel-Alias, deckt die drei Betriebsbereiche darüber ab | die fünf Tools dieser drei Bereiche | `mcp:read` ist der Scope, den ein Client anfragt, wenn er Lesezugriff ohne Bereichsangabe will. Er ist auf die drei Betriebsbereiche eingefroren, die es bei seiner Einführung gab (Monitore, Vorfälle, Prüfhistorie), und wächst mit keinem neuen Bereich mit: die fünf neueren Lesebereiche (Alarme, Statusseiten, Organisation, Abrechnung, Incident Management) müssen namentlich angefragt werden, erst dann bietet die Zustimmungsseite sie an. Verbindungen aus der Zeit vor den feinen Scopes tragen ihn ebenfalls und bleiben unverändert. ### Schreib-Scopes | Scope | Deckt ab | | --- | --- | | `mcp:monitors:write` | Monitore anlegen, ändern und löschen, einschließlich des Löschens eines Monitors samt Verlauf | | `mcp:incidents:write` | Vorfälle anlegen, ändern und löschen, einschließlich Vorfallsmeldungen, die Abonnenten erhalten | | `mcp:maintenance:write` | Wartungsfenster anlegen, ändern und löschen; während eines Fensters werden Alarme für die betroffenen Monitore unterdrückt | | `mcp:statuspages:write` | Statusseiten anlegen, ändern und löschen, einschließlich Gestaltung und eigener Domains; Abonnentenadressen bleiben unerreichbar | | `mcp:alerts:write…
### Organisation & Abrechnung
URL: https://docs.uptimeify.io/de/api/organization
Description: Pfadbasierte Organisations-Endpunkte verwenden organizationPublicId-UUIDs.
Summary: ## Endpunkte - [Organisations-Details abrufen](/de/api/organization/get-organization-details) - [Organisation aktualisieren](/de/api/organization/update-organization) - [Paket-Konfigurationen auflisten](/de/api/organization/list-package-configs) - [Paket-Konfiguration erstellen/aktualisieren](/de/api/organization/upsert-package-config) - [Paket-Konfiguration löschen](/de/api/organization/delete-package-config) - [Rechnungs-Details abrufen](/de/api/organization/get-billing-details) - [Rechnungs-Details aktualisieren](/de/api/organization/update-billing-details) - [Rechnungen auflisten](/de/api/organization/list-invoices) - [Audit-Log auflisten](/de/api/organization/list-audit-events) - [Fehlerliste und bekannte API-Fallen](/de/api/error-codes-and-known-pitfalls)
### Eigene Absenderdomain
URL: https://docs.uptimeify.io/de/api/organization-sender-domain
Description: Verschicke die E-Mails deiner Organisation mit deiner eigenen Domain über die Mail-Infrastruktur von Uptimeify, ohne eigenen SMTP-Server. Enterprise-Funktion, die Uptimeify je Organisation freischaltet. Nur für Admins.
Summary: Alarm-, Report- und Statusseiten-Mails deiner Organisation können mit deiner eigenen Domain (zum Beispiel `alerts@status.example.com`) über den Mailanbieter von Uptimeify rausgehen. Du trägst die Domain ein, legst die DNS-Einträge an, die die API zurückgibt, und sobald sie verifiziert sind, geht die Mail mit deiner Adresse raus. Das ist eine Enterprise-Funktion. Solange Uptimeify sie für deine Organisation nicht freigeschaltet hat, antwortet jeder Endpunkt auf dieser Seite mit `403` und `data.code` `senderDomainNotEnabled`. ## Welcher Absender verwendet wird 1. Dein eigener SMTP-Server, wenn einer eingerichtet ist ([Organisations-SMTP](/api/organization-smtp)). Er hat immer Vorrang. 2. Deine Absenderdomain, solange ihr `status` `verified` ist. 3. Sonst der Uptimeify-Absender. Das gilt auch, wenn eine Domain ihre Verifizierung später verliert: Die Mails kommen weiter an, dann vom Uptimeify-Absender, bis die DNS-Einträge wieder stimmen. Die Admins deiner Organisation bekommen dann einmal eine E-Mail. Mails zwischen Uptimeify und deiner Organisation (Rechnungen, Konto-Hinweise) kommen immer von Uptimeify. ## Authentifizierung und Rechte Rolle `admin`. Gesperrt für API-Tokens mit Scopes, kundengebundene Tokens und Agenten-Tokens: nimm ein Token ohne Scopes oder eine Sitzung. ```bash BASE_URL="https://uptimeify.io" TOKEN="" ``` ## Das Absenderdomain-Objekt | Feld | Typ | Beschreibung | |------|-----|--------------| | `domain` | string | Die Absenderdomain, kleingeschrieben. | | `fromEmail` | string | Absenderadresse, liegt immer auf `domain`. | | `fromName` | string | Anzeigename des Absenders. | | `replyTo` | string\|null | Antwortadresse. | | `status` | string | `pending` (DNS-Einträge noch nicht verifiziert), `verified` (Mails gehen mit dieser Domain raus), `failed` (war verifiziert, ist es nicht mehr). | | `dnsRecords` | array | Die anzulegenden Einträge: `type`, `hostname`, `fqdn`, `content`, `status` (`active`, `pending`, `failed`), `purpose`, `required` (für die Verifizierung nötig). | | `lastCheckedAt` | string\|null | Letzte Prüfung, ISO 8601 UTC. | | `verifiedAt` | string\|null | Wann die Domain zuletzt verifiziert wurde. | | `lastError` | string\|null | Was die letzte Prüfung gemeldet hat, solange nicht verifiziert. | | `createdAt`, `updatedAt` | string | ISO 8601 UTC. | ## Absenderdomain abrufen `GET /api/organization/sender-domain` ```bash curl "$BASE_URL/api/organization/sender-domain" -H "Authorization: Bearer $TOKEN" ``` ```json { "domain": "status.example.com", "fromEmail": "alerts@status.example.com", "fromName": "Example Alerts", "replyTo": null, "status": "pending", "dnsRecords": [ { "type": "CNAME", "hostname": "lm1._domainkey", "fqdn": "lm1._domainkey.status.example.com", "content": "lm1._domainkey.example.lmta.net", "status": "pending", "purpose": "dkim_primary", "required": true } ], "lastCheckedAt": null, "verifiedAt": null, "lastError": null, "createdAt": "2026-11-09T10:00:00.000Z", "updatedAt": "2026-11-09T10:00:00.000Z" } ``` `404` mit `data.code` `senderDomainNotConfigured`, solange keine Domain eingetragen ist. ## Absenderdomain festlegen `PUT /api/organization/sender-domain` Trägt die Domain ein oder ändert sie. Eine neue Domain startet als `pending` mit neuen `dnsRecords`; eine vorherige Domain wird entfernt. Dieselbe Domain noch einmal zu schicken ändert nur die Absenderfelder und behält die Verifizierung. | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `domain` | string | ja | Ein Domainname. Empfohlen ist eine Subdomain wie `status.example.com`. Wird kleingeschrieben, ein Punkt am Ende fällt weg. | | `fromEmail` | string | ja | Absenderadresse. Muss genau auf `domain` liegen (`alerts@status.example.com`, nicht `alerts@example.com`). | | `fromName` | string | ja | Anzeigename, 1-200 Zeichen. | | `replyTo` | string\|null | nein | Antwortadresse; `null` leert sie. | Unbekannte Felder werden abgewiesen. ```bash curl -X PUT "$BASE_URL/api/organization/s…
### Organisations-SMTP
URL: https://docs.uptimeify.io/de/api/organization-smtp
Description: Konfiguriere eigene SMTP-Einstellungen, damit die Benachrichtigungs-E-Mails deiner Organisation über deinen eigenen Mailserver versendet werden. Alle SMTP-Endpunkte erfordern die Admin-Rolle.
Summary: ## Authentifizierung Alle Endpunkte akzeptieren API-Bearer-Tokens oder Session-Cookies: ```bash BASE_URL="https://uptimeify.io" TOKEN="" ``` ## Endpunkte - [SMTP-Verbindung testen](/de/api/organization-smtp/test-smtp) - [SMTP-Versandprotokolle abrufen](/de/api/organization-smtp/get-smtp-logs)
### SMTP-Versandprotokolle abrufen
URL: https://docs.uptimeify.io/de/api/organization-smtp/get-smtp-logs
Description: Gibt die letzten SMTP-Versandereignis-Logs aus Redis zurück. Nur für Admins.
Summary: `GET /api/organization/smtp/logs` ## Query Parameter | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `limit` | number | 100 | Maximale Anzahl zurückzugebender Ereignisse (1-500) | | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/organization/smtp/logs?limit=50&envelope=items" \ -H "Cookie: $SESSION_COOKIE" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "items": [ { "type": "smtp_send", "timestamp": "2026-04-15T12:00:00.000Z", "to": "admin@deinkunde.com", "subject": "Website Down: deinkunde.com", "status": "sent" } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (`{ "events": [...] }`); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. Gibt eine leere Liste zurück (`"items": []`; in der bisherigen Form `{ "events": [] }`), wenn keine Logs vorhanden sind oder bei Redis-Fehlern (fail-open). ## Häufige Fehler - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` wenn du kein Admin bist
### SMTP-Verbindung testen
URL: https://docs.uptimeify.io/de/api/organization-smtp/test-smtp
Description: Testet die SMTP-Konfiguration durch Versand einer Test-E-Mail. Alle Parameter sind optional. Wenn weggelassen, werden die gespeicherten Konfigurationswerte verwendet. So kannst du neue Zugangsdaten testen, bevor du sie speicherst. Nur für Admins.
Summary: `POST /api/organization/smtp/test` Der Test aktualisiert außerdem die Felder `lastTestedAt`, `lastTestStatus` und `lastTestError` der SMTP-Konfiguration. ## Anfrage (Request Body): alle optional | Field | Type | Description | |-------|------|-------------| | `toEmail` | string | Empfänger-E-Mail-Adresse (max. 320 Zeichen). Standardwert ist die E-Mail des aktuellen Benutzers. | | `subject` | string | E-Mail-Betreff (1-200 Zeichen). Standardwert ist `SMTP Test ()`. | | `message` | string | E-Mail-Text (1-2000 Zeichen). Standardwert ist eine Standard-Testnachricht. | | `host` | string\|null | SMTP-Server-Hostname (1-255 Zeichen). Überschreibt die gespeicherte Konfiguration. | | `port` | number\|null | SMTP-Server-Port (1-65535). Überschreibt die gespeicherte Konfiguration. | | `username` | string\|null | SMTP-Benutzername (1-200 Zeichen). Überschreibt die gespeicherte Konfiguration. | | `password` | string\|null | SMTP-Passwort (1-500 Zeichen). Überschreibt die gespeicherte Konfiguration (wird nicht gespeichert). | | `tlsMode` | string\|null | `ssl`, `starttls` oder `none`. Überschreibt die gespeicherte Konfiguration. | | `fromName` | string\|null | Anzeigename des Absenders (1-200 Zeichen). Überschreibt die gespeicherte Konfiguration. | | `fromEmail` | string\|null | Absender-E-Mail-Adresse (max. 320 Zeichen). Überschreibt die gespeicherte Konfiguration. | | `replyTo` | string\|null | Reply-To-E-Mail-Adresse (max. 320 Zeichen). Überschreibt die gespeicherte Konfiguration. | ## Beispiel (cURL): Mit gespeicherter Konfiguration ```bash curl -X POST "$BASE_URL/api/organization/smtp/test" \ -H "Cookie: $SESSION_COOKIE" \ -H "Content-Type: application/json" \ -d '{}' ``` ## Beispiel (cURL): Neue Zugangsdaten testen ```bash curl -X POST "$BASE_URL/api/organization/smtp/test" \ -H "Cookie: $SESSION_COOKIE" \ -H "Content-Type: application/json" \ -d '{ "host": "smtp.deinkunde.com", "port": 587, "tlsMode": "starttls", "username": "alerts@deinkunde.com", "password": "secret-password", "fromName": "Uptimeify Alerts", "fromEmail": "alerts@deinkunde.com", "toEmail": "admin@deinkunde.com" }' ``` ## Antwort (Erfolg) ```json { "success": true, "messageId": "" } ``` ## Häufige Fehler - `400 Password must be re-entered when the SMTP host changes` (`data.code: smtpPasswordRequiredForNewHost`) wenn der Request einen `host` schickt, der vom gespeicherten abweicht, aber kein `password`: das gespeicherte Passwort geht nur an den gespeicherten Host - `400 Missing recipient email (toEmail)` wenn kein Empfänger angegeben ist und der Benutzer keine E-Mail hat - `400 SMTP config incomplete (host/port required)` wenn Host oder Port fehlt - `400 SMTP config incomplete (username required)` wenn ein Benutzername benötigt wird, aber fehlt - `400 SMTP password missing (username is set)` wenn ein Passwort benötigt wird, aber fehlt - `400 SMTP config incomplete (fromEmail required)` wenn fromEmail fehlt - `403 Forbidden` wenn du kein Admin bist - `502 Failed to send SMTP test email` wenn die SMTP-Verbindung fehlschlägt
### Report-Default übertragen
URL: https://docs.uptimeify.io/de/api/organization/apply-report-default
Description: Schreibt das monthlyReportsDefault eines Pakets einmalig auf jeden Kunden, der aktuell dieses Paket hat.
Summary: `POST /api/package-configs/:packageType/apply-report-default` Die Organisation kommt aus deiner Sitzung bzw. deinem API-Token. Der Pfad `POST /api/organizations/:id/package-configs/:packageType/apply-report-default` tut dasselbe für die Organisation `:id`; er ist veraltet und entfällt am 18.01.2027. Das `monthlyReportsDefault` aus [Paket-Konfiguration erstellen/aktualisieren](/de/api/organization/upsert-package-config) ist eine **Vorlage**: Sie legt nur bei ab jetzt neu angelegten Kunden `monthlyReportsEnabled` fest. Das Speichern der Paket-Konfiguration überschreibt bereits bestehende Kunden auf diesem Paket bewusst nie, ein Konfigurations-Save darf keine Kundendaten stillschweigend verändern. Dieser Endpunkt ist die explizite Einmal-Aktion für den anderen Fall: das aktuelle `monthlyReportsDefault` des Pakets jetzt sofort auf jeden Kunden übertragen, der dieses Paket bereits hat. Es handelt sich um ein einzelnes `UPDATE` über alle betroffenen Kunden, nicht um eine Schleife mit Fehler-Isolation pro Kunde wie bei [Sammelaktionen](/de/api/customers/bulk-actions): Es wird eine einzige Boolean-Spalte geschrieben, ohne Kaskade und ohne Nebeneffekte, daher bringt eine Isolation pro Zeile hier nichts. Entweder wird die gesamte Menge geschrieben, oder die Anfrage schlägt fehl, bevor irgendetwas geschrieben wurde. ## Query-Parameter `organizationId` (globale Admins) `organizationId` (positive Ganzzahl, optional): überträgt das Default in dieser Organisation statt in deiner eigenen. Eine fremde Organisation dürfen nur globale Admins angeben, alle anderen bekommen `403 forbidden`. Die eigene Organisation anzugeben wirkt wie der Aufruf ohne Parameter. Das ist der Nachfolger für die Organisation `:id` des veralteten Pfads. ## Pfad-Parameter `:id` (nur veralteter Pfad) `:id` ist die **numerische** `id` der Organisation, dasselbe ganzzahlige `id`-Feld, das [Organisations-Details abrufen](/de/api/organization/get-organization-details) zurückgibt. Das ist enger gefasst als bei den benachbarten Paket-Konfigurations-Routen, die zusätzlich `:organizationPublicId` (eine UUID) auflösen. Dieser Endpunkt tut das nicht: Er parst das Pfad-Segment direkt mit `Number(...)` und lehnt alles ab, was keine positive Ganzzahl ist, mit `400 invalidRequestBody`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/package-configs/pro/apply-report-default" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Kein Request Body. ## Antwort (Response) ```json { "updated": 42 } ``` `updated` ist die Anzahl der geschriebenen Kunden-Zeilen. Ein Kunde „hat" das Paket, wenn seine `packageId` mit der ID dieser Paket-Konfiguration übereinstimmt, oder, bei Kunden ohne zugewiesene ID, wenn sein `packageType`-String übereinstimmt. Kunden, die zufällig nur denselben `packageType`-String tragen, ohne diese konkrete Konfiguration zu halten, sind nicht enthalten. ## Häufige Fehler - `400 invalidRequestBody` `:id` ist keine positive Ganzzahl, oder `:packageType` fehlt - `400 invalidOrganizationId` `organizationId` ist keine positive Ganzzahl - `400 organizationIdRequired` Sitzung bzw. Token hat keine Organisation (Pfad ohne `:id`) - `401 unauthorized` du bist nicht angemeldet - `403 forbidden` du bist kein Admin dieser Organisation und kein Global Admin - `403 customerScopedTokenForbidden` beim Aufruf mit einem kundengescopten API-Token; dies ist eine organisationsweite Aktion und erfordert ein organisationsgescoptes Token oder eine Session - `404 notFound` es existiert keine Paket-Konfiguration mit diesem `packageType` für diese Organisation Hinweis zur Berechtigung: - Schreibzugriff ist erforderlich (Org-Admin der Ziel-Organisation, oder Global-Admin). - Ein kundengescoptes API-Token wird grundsätzlich abgelehnt. Dieser Endpoint schreibt über alle Kunden hinweg, die das Paket halten; es gibt also keine Kunden-Dimension, auf die er sich einschränken ließe. Ein auf einen einzelnen Kunden gebundenes Token…
### Geplante Kontingent-Änderung abbrechen
URL: https://docs.uptimeify.io/de/api/organization/cancel-pending-quota-change
Description: Bricht eine Kontingent-Reduzierung ab, die zum Ende des laufenden Abrechnungszeitraums geplant war, die Organisation behält ihren aktuellen Tarif. Antwortet mit cancelled:false statt 404, wenn nichts geplant ist.
Summary: `DELETE /api/organizations/:organizationPublicId/pending-quota-change` ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" ORG_ID="" curl -X DELETE "$BASE_URL/api/organizations/$ORG_ID/pending-quota-change" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Hinweise: - Dieser Endpunkt erwartet keinen Request Body. Er schließt die aktuell geplante Kontingent-Reduzierung der Organisation; mehr als eine gibt es nie. - Ab dem 1. Januar 2027 wird eine Kontingent-Reduzierung ohne `quotaChangeEffective: "immediately"` nicht sofort wirksam (bis dahin gilt eine Reduzierung bei monatlicher Abrechnung sofort, eine jährliche wird geplant): Sie wird zum Ende des laufenden Abrechnungszeitraums geplant und als `pendingQuotaChange` zurückgegeben (siehe [Organisation aktualisieren](/de/api/organization/update-organization) und [Organisations-Details abrufen](/de/api/organization/get-organization-details)). Dieser Endpunkt bricht sie ab, bevor sie greift. - **Nur so behältst du den aktuellen Tarif.** Die Richtung wird gegen den *aktuellen*, noch höheren Tarif der Organisation bestimmt. Denselben Tarif erneut per `PATCH` zu senden gilt deshalb als unveränderte Anfrage und lässt die geplante Reduzierung stehen. Nur eine echte Preiserhöhung ersetzt sie, und die ändert den Tarif, statt ihn wiederherzustellen. - Der Abbruch ist kostenlos und bis zum Wirksamwerden jederzeit möglich. Danach gibt es nichts mehr abzubrechen: Die Reduzierung ist dann der Tarif der Organisation, und der Weg zurück nach oben ist eine normale Kontingent-Erhöhung über [Organisation aktualisieren](/de/api/organization/update-organization). - Erfordert Schreibzugriff auf die Organisation (Organisations-Admin oder Global Admin) aus einer uneingeschränkten Session bzw. mit einem uneingeschränkten Token, dieselbe Autorisierung wie [Organisation aktualisieren](/de/api/organization/update-organization). Ein kundenspezifisch eingeschränktes API-Token kann diesen Endpunkt nicht aufrufen, auch nicht mit `admin`-Rolle: Der Abbruch verändert, was die Organisation ab der nächsten Periode zahlt. ## Antwort (Response) ```json { "cancelled": true } ``` | Wert | Bedeutung | | --- | --- | | `true` | Es war eine Reduzierung geplant und sie wurde abgebrochen. Die Organisation behält ihren aktuellen Tarif. | | `false` | Es war nichts geplant, also hat sich nichts geändert. **Das ist ein Erfolg, kein Fehler**, der Endpunkt ist bewusst idempotent, damit ein wiederholter Aufruf (doppelt geklickter Button, wiederholte Anfrage) keinen Fehlschlag meldet. | ## Häufige Fehler - `401 Unauthorized` (`data.code: unauthorized`) wenn du nicht angemeldet bist - `400 Invalid Organization identifier` wenn `:organizationPublicId` weder eine Legacy-Integer-ID noch eine gültige UUID-Public-ID ist - `403 Forbidden` (`data.code: forbidden`) wenn du keinen Schreibzugriff auf die Organisation hast - `403 Forbidden` (`data.code: customerScopedTokenForbidden`) beim Aufruf mit einem kundenspezifisch eingeschränkten API-Token; dies ist eine organisationsweite Aktion und erfordert ein organisationsweites Token oder eine Session - `404 Organization not found` (ohne `data.code`) wenn `:organizationPublicId` zu keiner existierenden Organisation auflöst Einen Fehler „nichts abzubrechen" gibt es bewusst nicht, dieser Fall ist `200` mit `cancelled: false`. Siehe [Fehlerliste](/de/api/error-codes-and-known-pitfalls) für die vollständige Liste.
### Paket-Konfiguration löschen
URL: https://docs.uptimeify.io/de/api/organization/delete-package-config
Description: Löscht eine Paket-Konfiguration der Organisation. Das ist nur möglich, wenn aktuell keine Kunden diesem Paket zugeordnet sind. Das Paket wird direkt über den Pfad-Parameter aufgelöst. Werte wie test1 funktionieren also, solange sie exakt dem gespeicherten packageType entsprechen.
Summary: `DELETE /api/package-configs/:packageType` ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X DELETE "$BASE_URL/api/package-configs/pro" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Hinweise: - Die Organisation wird automatisch aus deiner authentifizierten Session bzw. deinem API-Token abgeleitet. - Die Legacy-Route `DELETE /api/organizations/:organizationPublicId/package-configs/:packageType` bleibt aus Kompatibilitätsgründen weiterhin verfügbar. - Der plurale org-lose Alias `DELETE /api/organizations/package-configs/:packageType` wird ebenfalls unterstützt. - Global Admins brauchen für die org-lose Route einen aktiven Organisationskontext in der Session. - Die Prüfung „noch in Verwendung" wertet die Paket-Zuordnung des Kunden aus, nicht den Paketnamen. Kunden, die lediglich denselben `packageType`-String tragen, ohne dieser Konfiguration zugeordnet zu sein, blockieren die Löschung nicht. ## Antwort (Response) ```json { "success": true } ``` ## Häufige Fehler - `404 Package not found` wenn die Konfiguration nicht existiert - `409 Package is still in use by customers` wenn Kunden diesem Paket zugeordnet sind - `400 Package type is required` wenn `:packageType` fehlt - `400 Organization ID is required in the authenticated session` wenn aus Session/Token keine Organisation abgeleitet werden kann - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Organisation hast Hinweis zur Berechtigung: - Schreibzugriff ist erforderlich (Org-Admin oder Global-Admin).
### Datenexport herunterladen
URL: https://docs.uptimeify.io/de/api/organization/download-data-export
Description: Erzeugt eine kurzlebige Download-URL für einen fertigen Organisations-Datenexport.
Summary: `GET /api/organization/data-export/{exportId}/download` Gibt eine vorsignierte URL für das Export-ZIP zurück. Die URL gilt 5 Minuten; der Object-Key selbst wird nie preisgegeben und der Storage-Bucket ist nicht durchsuchbar. Die Export-ID zu kennen ist also kein Zugriff, ein authentifizierter Administrator der besitzenden Organisation zu sein schon. ## Query-Parameter | Parameter | Typ | Beschreibung | | --- | --- | --- | | `redirect` | `1` | Antwortet mit `302` auf die vorsignierte URL statt mit JSON. Praktisch für `curl -L` und Browser-Links. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" EXPORT_ID="0f0f2f6a-2b3b-4a2f-9a7c-3e5f8c1d2b44" # Direkt in die Datei curl -L -o export.zip \ "$BASE_URL/api/organization/data-export/$EXPORT_ID/download?redirect=1" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort (Response) ```json { "url": "https://..your-objectstorage.com/data-exports/org-12/0f0f2f6a-...zip?X-Amz-Signature=...", "expiresInSeconds": 300, "sizeBytes": 18446721, "filename": "uptimeify-export-0f0f2f6a-2b3b-4a2f-9a7c-3e5f8c1d2b44.zip" } ``` Jeder Aufruf erhöht `downloadCount` und aktualisiert `lastDownloadedAt` am Export-Datensatz. ## Häufige Fehler - `400 User must belong to an organization` wenn aus Session oder Token keine Organisation abgeleitet werden kann - `400 Invalid Export identifier` wenn `{exportId}` nicht die Form einer UUID hat - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` wenn deine Rolle die Organisation nicht verwalten darf - `404 Export not found` wenn die ID nicht zu deiner Organisation gehört - `409 Export is not downloadable` (`data.code: exportNotReady`) solange der Export in der Warteschlange, in Arbeit oder fehlgeschlagen ist - `410 Export download window has expired` (`data.code: exportExpired`) nach Ablauf der 7 Tage
### Audit-Log exportieren
URL: https://docs.uptimeify.io/de/api/organization/export-audit-log
Description: Lädt das Audit-Log deiner Organisation für einen Zeitraum als CSV-Datei, Anmeldungen eingeschlossen.
Summary: `GET /api/organization/audit/export` Liefert das Audit-Log deiner Organisation für einen Zeitraum als CSV-Datei. Das Log hält administrative Aktionen fest (jede Änderung über Dashboard oder API, mit altem und neuem Wert, wo die Aktion ihn erfasst) und Anmelde-Ereignisse: erfolgreiche und fehlgeschlagene Anmeldungen bestehender Konten, Abmeldungen, Passwort-Resets, Passwortänderungen und beendete Sitzungen. Einträge bleiben 12 Monate gespeichert und lassen sich über die Anwendung weder ändern noch löschen. Aufrufen dürfen nur Administratoren der Organisation, mit Sitzung oder einem organisationsweiten API-Token, dessen Aussteller Admin ist. Verbundene Anwendungen (MCP-Agenten) nicht. Jeder Export steht selbst im Audit-Log. ## Query-Parameter | Parameter | Typ | Beschreibung | | --- | --- | --- | | `from` | ISO 8601 UTC | Beginn, inklusive. Standard: 30 Tage vor `to`. | | `to` | ISO 8601 UTC | Ende, exklusive. Standard: jetzt. | Ein Export umfasst höchstens 366 Tage und höchstens 100.000 Einträge. Einen längeren Zeitraum teilst du auf mehrere Exporte auf. Der Export enthält nur Einträge, die noch gespeichert sind. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -o audit-log.csv \ "$BASE_URL/api/organization/audit/export?from=2026-01-01T00:00:00.000Z&to=2026-04-01T00:00:00.000Z" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `200` mit `Content-Type: text/csv; charset=utf-8`, `Content-Disposition` als Anhang und `Cache-Control: no-store`. Die Zeilen sind nach Zeit sortiert, die älteste zuerst; Einträge mit gleichem Zeitpunkt behalten eine feste Reihenfolge. Die Datei ist UTF-8 ohne BOM: In Excel öffnest du sie über Daten > Aus Text/CSV, damit Umlaute richtig erscheinen. ```csv "time","actor","agent","action","auth","summary","target","changes","ip","user_agent","request_id" "2026-03-02T08:14:03.512Z","admin@example.com","no","auth.login.succeeded","password","Signed in","user:Xk2f9","","","","" "2026-03-02T08:15:40.101Z","admin@example.com","no","websites.update","","Website updated","website:46","[{""field"":""checkInterval"",""from"":5,""to"":1}]","","","9b1e2c4a" ``` | Spalte | Inhalt | | --- | --- | | `time` | Zeitpunkt, ISO 8601 UTC | | `actor` | E-Mail-Adresse des handelnden Nutzers oder seine ID; leer bei fehlgeschlagener Anmeldung und angefordertem Passwort-Reset | | `agent` | `yes`, wenn eine verbundene Anwendung (MCP-Agent) im Namen des Nutzers gehandelt hat | | `action` | Ereignistyp, zum Beispiel `websites.update` oder `auth.login.failed` | | `auth` | Nur bei Anmelde-Ereignissen: Methode und bei fehlgeschlagener Anmeldung der Grund-Code als `methode:grund` (zum Beispiel `password:INVALID_EMAIL_OR_PASSWORD`), sonst nur die Methode (`password`, `password_mfa`, `sso`); bei allen anderen Ereignissen leer | | `summary` | Kurzbeschreibung (englisch) | | `target` | Betroffenes Objekt als `typ:id`, bei Anmelde-Ereignissen das Konto | | `changes` | Geänderte Felder als JSON (`field`, `from`, `to`); Geheimnisse nur als geändert | | `ip`, `user_agent` | Nur wenn eine verbundene Anwendung (MCP-Agent) gehandelt hat; sonst leer, auch bei Anmelde-Ereignissen | | `request_id` | Korrelations-ID der Anfrage | Jede Zelle steht in Anführungszeichen. Beginnt eine Zelle mit `=`, `+`, `-` oder `@`, auch nach führendem Leerraum, steht ein `'` davor, damit Tabellenkalkulationen sie als Text zeigen und nicht als Formel ausführen. ## Häufige Fehler - `400 Invalid query` (`data.code: invalidRequestBody`), wenn `from` oder `to` kein ISO-8601-Zeitpunkt in UTC ist (Endung `Z`) - `400` (`data.code: invalidDateRange`), wenn `from` nicht vor `to` liegt - `400` (`data.code: auditExportRangeTooLarge`), wenn der Zeitraum länger als 366 Tage ist oder mehr als 100.000 Einträge enthält - `400 User must belong to an organization`, wenn sich aus Sitzung oder Token keine Organisation ergibt - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden`, wenn deine Rolle nicht Admin ist
### Rechnungs-Details abrufen
URL: https://docs.uptimeify.io/de/api/organization/get-billing-details
Description: Gibt Rechnungsinformationen und Zahlungsmethoden der Organisation aus deiner authentifizierten Session zurück.
Summary: `GET /api/organization/billing` ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/organization/billing" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Hinweise: - Die Organisation wird automatisch aus deiner authentifizierten Session bzw. deinem API-Token abgeleitet. - Die Legacy-Route `GET /api/organizations/:organizationPublicId/billing` bleibt aus Kompatibilitätsgründen weiterhin verfügbar. - Der plurale org-lose Alias `GET /api/organizations/billing` wird ebenfalls unterstützt. - Global Admins brauchen für die org-lose Route einen aktiven Organisationskontext in der Session. ## Antwort (Response) ```json { "billingEmail": "billing@deinkunde.com", "paymentMethod": "mollie" } ``` ## Häufige Fehler - `400 Organization ID is required in the authenticated session` wenn aus Session/Token keine Organisation abgeleitet werden kann - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Organisation hast
### Organisations-Details abrufen
URL: https://docs.uptimeify.io/de/api/organization/get-organization-details
Description: Gibt Details der Organisation aus deiner authentifizierten Session zurück.
Summary: `GET /api/organization` ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/organization" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Hinweise: - Die Organisation wird automatisch aus deiner authentifizierten Session bzw. deinem API-Token abgeleitet. - Die Legacy-Route `GET /api/organizations/:organizationPublicId` bleibt aus Kompatibilitätsgründen weiterhin verfügbar. - Der plurale org-lose Alias `GET /api/organizations` wird ebenfalls unterstützt. - Global Admins brauchen für die org-lose Route einen aktiven Organisationskontext in der Session. - `emailLanguage` (`de`, `en` oder `da`) ist die Standardsprache der Organisation für E-Mails und SMS. Jedes Mitglied erhält das Feld; Kunden ohne eigene `emailLanguage` folgen ihr. - `contractEmail` ist die Adresse, an die Ankündigungen zu Änderungen an AGB, AVV und Datenschutzerklärung gehen; `null` heißt, alle Admins erhalten sie. Wie die anderen Abrechnungsfelder nur für Organisations-Admins und Global Admins, andere Mitglieder erhalten `null`. - Abrechnungsfelder, darunter die Rechnungsadresse (`companyName`, `street`, `postalCode`, `city`, `country`), `vatId`, die `quota*`-Felder und `pendingQuotaChange`, sind nur für Organisations-Admins und Global Admins enthalten. Andere Mitglieder erhalten die Antwort ohne sie. ## Antwort (Response) ```json { "id": 1, "name": "Meine Org", "emailLanguage": "de", "companyName": "Meine Firma GmbH", "street": "Musterstr. 1", "postalCode": "12345", "city": "Berlin", "country": "DE", "vatId": "DE123456789", "billingEmail": "billing@deinkunde.com", "contractEmail": "vertrag@deinkunde.com", "createdAt": "2023-01-01T00:00:00.000Z", "pendingQuotaChange": { "effectiveAt": "2026-08-01T00:00:00.000Z", "quotaWebsitesLimit": 25, "quotaSmsIncluded": 100, "quotaMonthlyPriceCents": 6900 } } ``` `pendingQuotaChange` beschreibt eine Kontingent-Reduzierung, die beauftragt wurde, aber erst zum Ende des laufenden Abrechnungszeitraums wirksam wird (eine Reduzierung mit `quotaChangeEffective: "period_end"`, dem Standard). Ohne geplante Änderung ist das Feld `null`, der Normalfall. | Feld | Bedeutung | | --- | --- | | `effectiveAt` | Der erste Zeitpunkt, ab dem der neue Tarif gilt: bei monatlicher Abrechnung der Beginn des nächsten Monats (ab dem 1. Januar 2027 um 00:00 Uhr Europe/Berlin, z. B. `2027-01-31T23:00:00.000Z` für den 1. Februar; für bis zum 31. Dezember 2026 geplante Reduzierungen 00:00 UTC), bei jährlicher das Ende der bezahlten Laufzeit. | | `quotaWebsitesLimit` | Das Monitor-Limit, das ab dann gilt. `null` bedeutet kein Limit. | | `quotaSmsIncluded` | Das inkludierte SMS-Kontingent, das ab dann gilt. | | `quotaMonthlyPriceCents` | Der Monatspreis, der ab dann gilt, in Cent. | Solange eine Änderung geplant ist, beschreiben die `quota*`-Felder der Organisation weiterhin den **aktuellen, höheren** Tarif, genau darum geht es in der Klausel, und abgerechnet wird die ganze Periode zu diesem Tarif. Zum Abbrechen dient [Geplante Kontingent-Änderung abbrechen](/de/api/organization/cancel-pending-quota-change), zum Heraufsetzen [Organisation aktualisieren](/de/api/organization/update-organization). ## Häufige Fehler - `400 Organization ID is required in the authenticated session` wenn aus Session/Token keine Organisation abgeleitet werden kann - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Organisation hast
### Audit-Log auflisten
URL: https://docs.uptimeify.io/de/api/organization/list-audit-events
Description: Gibt das Audit-Log deiner Organisation zurück: wer wann was getan hat, filterbar nach Zeitraum, Bereich und Ergebnis.
Summary: `GET /api/organization/audit` Gibt die protokollierten Aktionen deiner Organisation zurück, neueste zuerst. Ohne `since` umfasst die Liste die letzten 30 Tage. Einträge bleiben 12 Monate gespeichert; ältere innerhalb dieser Frist über `since` oder den [Export](/de/api/organization/export-audit-log). ## Zugriff Nur Organisations-Admins, per Sitzung oder organisationsweitem API-Token, dessen Aussteller Admin ist. Andere Rollen erhalten `403 forbidden`. Agent-Tokens (verbundene Apps) werden für diesen Pfad abgewiesen. Die Organisation ergibt sich aus Sitzung oder Token; das Log einer anderen Organisation ist nicht lesbar. ## Query-Parameter | Parameter | Standard | Beschreibung | |-----------|----------|--------------| | `since` | 30 Tage vor jetzt | Unix-Zeit in Millisekunden, Untergrenze inklusiv. Ein früherer Wert liest weiter zurück. | | `until` | keiner | Unix-Zeit in Millisekunden, Obergrenze inklusiv: ein Eintrag genau zu `until` ist enthalten. | | `limit` | `100` | 1 bis 500. | | `offset` | `0` | 0 bis 50000. | | `sortBy` | `ts` | `ts`, `actor`, `status`, `summary` oder `durationMs`. | | `sortOrder` | `desc` | `asc` oder `desc`. | | `q` | keiner | Textfilter ohne Rücksicht auf Groß/Klein über Bereich, Zusammenfassung und E-Mail oder Nutzer-ID des Handelnden. | | `area` | keiner | Genauer Bereich, z. B. `websites`. | | `success` | keiner | `true` oder `false`. Einträge ohne Ergebnis fallen dann heraus. | | `envelope` | keiner | `items` antwortet `{ items, total, page, perPage }`. | `total` zählt die Einträge nach allen Filtern. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/organization/audit?since=1759276800000&limit=50&envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "items": [ { "id": "4f1c2a9e-8b7d-4c3e-9f20-6a5b4c3d2e1f", "ts": 1761126000000, "organizationId": 1, "area": "websites", "summary": "Websites updated", "actor": { "email": "admin@deine-agentur.de", "userId": "u_123" }, "success": true, "durationMs": 42, "type": "websites.update", "method": "PATCH", "route": "/api/websites/[id]", "statusCode": 200, "resourceType": "websites", "resourceId": "17", "changes": [{ "field": "name", "from": "Shop", "to": "Shop (live)" }] } ], "total": 1, "page": 1, "perPage": 50 } ``` | Feld | Beschreibung | |------|--------------| | `ts` | Unix-Zeit in Millisekunden. | | `summary` | Kurzbeschreibung auf Englisch. | | `route` | Routen-Vorlage, nie der rohe Pfad. | | `actor` | Wer gehandelt hat, oder `null`. | | `ipAddress`, `userAgent` | Nur bei Anfragen über eine verbundene App (MCP-Agent) erfasst. | | `agent` | Gesetzt, wenn eine verbundene App im Namen des Handelnden gehandelt hat. | | `auth` | `{ method, reason }`, nur bei Anmelde-Ereignissen (`type` beginnt mit `auth.`). `method`: `password`, `password_mfa` oder `sso` bei einer Anmeldung; `one`, `others` oder `all` bei `auth.sessions.revoked`; sonst `null`. `reason`: Fehlercode einer fehlgeschlagenen Anmeldung (z. B. `INVALID_EMAIL_OR_PASSWORD`), sonst `null`. | | `changes` | Was zu was wurde, wo die Aktion es festhält. Geheime Werte werden nicht protokolliert (`redacted: true`). | **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }` (`perPage` ist `limit`, `page` ist `floor(offset / limit) + 1`). Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form `{ "events": [...], "pagination": { "limit", "offset", "total" } }`; sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. ## Anmelde-Ereignisse Neben Anfragen protokolliert das Log diese `type`-Werte: `auth.login.succeeded`, `auth.login.failed` (nur bei bekanntem Konto; `actor` ist `null`), `auth.logout`, `auth.password_reset.requested`, `auth.password_reset.completed`, `auth.password.changed`, `auth.sessions.revoked` und `app_link.redeemed` (Anmeldung in der App per QR-Code). Der Typ `audit.export` hält jeden [Export des Audit-…
### Datenexporte auflisten
URL: https://docs.uptimeify.io/de/api/organization/list-data-exports
Description: Gibt die letzten Datenexport-Anfragen deiner Organisation mit Status, Größe, Retention-Fenster und Ablaufdatum zurück.
Summary: `GET /api/organization/data-export` Gibt die 20 jüngsten Export-Anfragen zurück, neueste zuerst. Poll diesen Endpunkt (oder `GET /api/organization/data-export/{exportId}`), solange ein Export `queued` oder `generating` ist. ## Antwort (Response) ```json { "exports": [ { "id": "0f0f2f6a-2b3b-4a2f-9a7c-3e5f8c1d2b44", "status": "ready", "format": "json_csv", "includeCheckHistory": true, "recipientEmails": ["admin@deineagentur.com"], "sizeBytes": 18446721, "retentionCutoff": "2025-03-30T09:12:44.101Z", "expiresAt": "2026-08-06T09:19:02.884Z", "downloadCount": 1, "lastDownloadedAt": "2026-07-30T10:02:11.900Z", "errorMessage": null, "manifest": { "generatedAt": "2026-07-30T09:12:52.006Z", "retentionCutoff": "2025-03-30T09:12:44.101Z", "includeCheckHistory": true, "packages": [ { "packageType": "fullservice", "displayName": "Full Service", "dataRetentionMonths": 16, "cutoff": "2025-03-30T09:12:44.101Z" } ], "sections": [ { "path": "customers/customers", "rows": 42 }, { "path": "monitors/websites", "rows": 311 }, { "path": "checks/website-checks", "rows": 100000, "truncated": true } ], "redactedFields": ["passwords and passphrases", "webhook secrets and signing keys"] }, "createdAt": "2026-07-30T09:12:44.101Z", "startedAt": "2026-07-30T09:12:45.010Z", "completedAt": "2026-07-30T09:19:02.884Z" } ], "cooldownHours": 6 } ``` ## Status-Werte | Status | Bedeutung | | --- | --- | | `queued` | Angenommen, wartet auf den Builder | | `generating` | Das Bundle wird gebaut | | `ready` | Herunterladbar bis `expiresAt` | | `failed` | Bau fehlgeschlagen; `errorMessage` nennt den Grund | | `expired` | Download-Fenster geschlossen, Datei gelöscht | ## Einzelner Export `GET /api/organization/data-export/{exportId}` liefert einen Export im gleichen Format (ohne die `exports`-Hülle). **Abgelöstes Feld:** `error` wird bis zum Entfall am 18.01.2027 weiter neben `errorMessage` geliefert. Lies `errorMessage`. ## Häufige Fehler - `400 User must belong to an organization` wenn aus Session oder Token keine Organisation abgeleitet werden kann - `400 Invalid Export identifier` wenn `{exportId}` nicht die Form einer UUID hat - `401 Unauthorized` wenn du nicht authentifiziert bist - `403 Forbidden` wenn du die Organisation nicht lesen darfst - `404 Export not found` wenn die ID nicht zu deiner Organisation gehört
### Rechnungen auflisten
URL: https://docs.uptimeify.io/de/api/organization/list-invoices
Description: Listet alle Rechnungen für die Organisation auf.
Summary: `GET /api/mollie/invoices` ## Query-Parameter | Parameter | Typ | Standard | Beschreibung | |---|---|---|---| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET \ "$BASE_URL/api/mollie/invoices?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Hinweise: - Die Organisation wird automatisch aus deiner authentifizierten Session bzw. deinem API-Token abgeleitet. - Die Legacy-Route `GET /api/organizations/:organizationPublicId/mollie/invoices` bleibt aus Kompatibilitätsgründen weiterhin verfügbar. - Die `pdfUrl`-Werte in der Response verwenden die org-lose Download-Route `/api/invoices/:invoiceId/pdf`. - Der Download eines PDFs über `pdfUrl` antwortet mit `502` (`data.code: invoiceProviderFailed`), wenn der Buchhaltungsanbieter einen Fehler meldet oder nicht erreichbar ist, und mit `404` (`data.code: invoiceNotFound`), wenn es die Rechnung nicht gibt. Beides liegt nicht an deiner Sitzung, melde dich deshalb nicht ab. - Global Admins brauchen für die org-lose Route einen aktiven Organisationskontext in der Session. ## Antwort (Response) ```json { "items": [ { "id": "inv_123456", "reference": "RE-2024-001", "status": "paid", "issuedAt": "2024-01-15T10:00:00.000Z", "netAmount": { "value": "29.99", "currency": "EUR" }, "pdfUrl": "/api/invoices/inv_123456/pdf" }, { "id": "inv_123455", "reference": "RE-2023-128", "status": "paid", "issuedAt": "2023-12-15T10:00:00.000Z", "netAmount": { "value": "29.99", "currency": "EUR" }, "pdfUrl": "/api/invoices/inv_123455/pdf" } ], "total": 2, "page": 1, "perPage": 2 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (`{ "invoices": [...] }`); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. ## Häufige Fehler - `400 Organization ID is required in the authenticated session` wenn aus Session/Token keine Organisation abgeleitet werden kann - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Not authorized` wenn du keinen Zugriff auf die Organisation hast - `403 Only organization admins can view invoices` (`data.code: forbidden`) für Editoren, Readonly-Nutzer und Responder der Organisation; Rechnungen tragen Rechnungsadresse, USt-ID und Beträge
### Paket-Konfigurationen auflisten
URL: https://docs.uptimeify.io/de/api/organization/list-package-configs
Description: Gibt alle Paket-Konfigurationen der Organisation aus deiner authentifizierten Session zurück. Jede Konfiguration enthält zusätzlich usedByCustomerCount.
Summary: `GET /api/package-configs` ## Query-Parameter | Parameter | Typ | Standard | Beschreibung | | --- | --- | --- | --- | | `summary` | string | - | Auf `1` gesetzt ergänzt jede Konfiguration um ein `summary`-Objekt mit Nutzungszahlen. Jeder andere Wert (oder das Weglassen) liefert die schlichte Liste. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/package-configs" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Hinweise: - Die Organisation wird automatisch aus deiner authentifizierten Session bzw. deinem API-Token abgeleitet. - Die Legacy-Route `GET /api/organizations/:organizationPublicId/package-configs` bleibt aus Kompatibilitätsgründen weiterhin verfügbar. - Global Admins brauchen für die org-lose Route einen aktiven Organisationskontext in der Session. - `usedByCustomerCount` zählt die Kunden, die dieser Konfiguration tatsächlich zugeordnet sind, nicht die Kunden, deren `packageType`-String zufällig ihrem Namen entspricht. ## Antwort (Response) ```json [ { "id": 10, "packageType": "pro", "maxUrls": 100, "maxStatusPages": null, "dataRetentionMonths": 12, "checkIntervalMinutes": 1, "checkLocations": 3, "notificationDelayMinutes": 0, "reminderDelayMinutes": 10, "alertConsecutiveChecks": 3, "alertLocationThreshold": "majority", "alertLocationThresholdCount": 2, "alertReminderInterval": 60, "enableSslCheck": true, "enableHttpsCheck": true, "enableStatusCheck": true, "enableSizeCheck": true, "enableResponseTimeCheck": true, "enableKeywordCheck": false, "enableEmailAlerts": true, "enableSmsAlerts": true, "enableWebhookAlerts": true, "enableIntegrationAlerts": true, "enablePostRequestEscalation": false, "enableMaintenanceWindows": true, "enablePdfReports": true, "notes": null, "createdAt": "2026-02-26T12:00:00.000Z", "updatedAt": "2026-02-26T12:00:00.000Z", "usedByCustomerCount": 4 } ] ``` ## Antwort mit `summary=1` ```bash curl -X GET "$BASE_URL/api/package-configs?summary=1" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Jeder Eintrag trägt dieselben Felder wie oben, dazu ein `summary`-Objekt: ```json [ { "id": 10, "packageType": "pro", "maxUrls": 100, "maxStatusPages": null, "usedByCustomerCount": 4, "summary": { "customers": 4, "monitorsActive": 37, "capacity": 400, "statusPages": 3, "statusPageCapacity": 20 } } ] ``` - `customers`: die dieser Konfiguration zugeordneten Kunden; identisch mit `usedByCustomerCount`. - `monitorsActive`: alle nicht deaktivierten Monitore dieser Kunden, jeder Typ zählt (Website, DNS, Domain, ICMP, SMTP, SSH, FTP, IMAP/POP); dieselbe Zahl, gegen die das Paketlimit geprüft wird. - `capacity`: `customers × maxUrls`. Hat die Konfiguration kein eigenes `maxUrls`, gilt der Standard ihres Pakettyps; `0` heißt, dass beides unbekannt ist. - `statusPages`: alle Statusseiten dieser Kunden, veröffentlicht oder nicht; dieselbe Zahl, gegen die das Statusseitenlimit je Kunde geprüft wird. Seiten ohne Kunde zählen nie. - `statusPageCapacity`: `customers × maxStatusPages`, oder `null`, wenn die Konfiguration kein Statusseitenlimit hat (unbegrenzt). ## Häufige Fehler - `400 Organization ID is required in the authenticated session` wenn aus Session/Token keine Organisation abgeleitet werden kann - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keinen Zugriff auf die Organisation hast
### Bericht erstellen
URL: https://docs.uptimeify.io/de/api/organization/reports/create-report
Description: Erstellt eine organisationsweite Berichtskonfiguration. Erfordert einen Tarif mit Organisationsberichten und freies Berichtskontingent.
Summary: `POST /api/organization/reports` Erstellt einen wiederkehrenden Organisationsbericht. Die Organisation wird aus Ihrer authentifizierten Sitzung oder Ihrem API-Token abgeleitet. Erfordert die Rolle **admin** der Organisation (API-Tokens gelten als Organisations-Admins). Nur-Lese-Benutzer können keine Berichte erstellen. ## Request-Body | Feld | Typ | Erforderlich | Hinweise | |---|---|---|---| | `name` | string | ja | 1-200 Zeichen. | | `enabled` | boolean | nein | Standard `true`. | | `frequency` | `"daily" \| "weekly" \| "monthly"` | nein | Standard `monthly`. | | `weekday` | integer 0-6 | bei `weekly` | 0 = Sonntag. | | `dayOfMonth` | integer 1-28 | bei `monthly` | Auf 28 begrenzt. | | `sendHour` | integer 0-23 | nein | Standard `2`, in `timezone`. | | `timezone` | string | nein | IANA-Zeitzone, Standard `Europe/Berlin`. | | `scopeMode` | `"all" \| "customers" \| "tags"` | nein | Standard `all`. | | `scopeCustomerIds` | integer[] | bei `customers` | Müssen zu Ihrer Organisation gehören. | | `scopeTagIds` | integer[] | bei `tags` | Müssen zu Ihrer Organisation gehören. | | `inclusionMode` | `"all" \| "problems" \| "threshold"` | nein | Standard `all`. | | `problemSignals` | object | nein | `{ incident, downtimeMinutes, sslDaysLt, responseBreach }`. | | `thresholdUptimeLt` | number | bei `threshold` | z. B. `99.9`. | | `thresholdResponseGt` | integer (ms) | bei `threshold` | | | `sendWhenEmpty` | boolean | nein | „Alles in Ordnung"-Bericht senden, wenn keine Website zutrifft. Standard `false`. | | `sections` | object | nein | Sechs Booleans zum Ein-/Ausschalten der Abschnitte. | | `monitorTypes` | string[] | nein | Welche Monitor-Typen der Bericht umfasst. Ein oder mehrere aus `website`, `dns`, `dnsbl`, `domain`, `icmp`, `smtp`, `ssh`, `tcp`, `ftp`, `imap`. Standard: alle 10. Muss mindestens einen Eintrag enthalten. | | `sectionsByType` | object | nein | Abschnitts-Umschalter pro Typ: `{ "": { "": boolean } }`. Welche `sectionKey`s zulässig sind, hängt vom Typ ab: siehe [Abschnitts-Schlüssel pro Monitor-Typ](#abschnitts-schlüssel-pro-monitor-typ) unten. Wird ein für seinen Typ unzulässiger Abschnitts-Schlüssel gesendet, schlägt die Anfrage mit `400 Bad Request` fehl. | | `groupByCustomer` | boolean | nein | Untergliedert die Tabelle jedes Monitor-Typs zusätzlich nach Kunde. Standard `false`. | | `includeStatusPages` | boolean | nein | Hängt am Ende den Abschnitt Statusseiten an (Veröffentlichung, Kunde, Komponenten, Vorfälle inklusive der über Statusseiten-Regeln des Incident Managements, Wartungen, Abonnenten). Umfang `customers` zeigt die Seiten dieser Kunden, Umfang `tags` die Seiten, die mindestens einen Monitor mit einem der Tags zeigen, als Komponente oder als Monitor des Seitenkunden. Standard `true`. | | `format` | `"email" \| "email_pdf"` | nein | Standard `email_pdf`. | | `recipientEmails` | string[] | nein | Empfänger auf Agenturseite (max. 50). | | `recipientUserIds` | string[] | nein | Benutzer-IDs der Teammitglieder (max. 50). | ### Abschnitts-Schlüssel pro Monitor-Typ | Monitor-Typ | Zulässige `sectionKey`s | |---|---| | `website`, `dns`, `icmp`, `smtp`, `ssh`, `tcp`, `ftp`, `imap` | `fleetSummary`, `worstPerformers`, `perMonitorTable`, `incidentLog` | | `website` (zusätzlich) | `sslExpiry` | | `dnsbl` | `dnsblStatus` | | `domain` | `domainExpiry` | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/organization/reports" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "Wöchentlicher Ops-Bericht", "frequency": "weekly", "weekday": 1, "scopeMode": "all", "inclusionMode": "problems", "format": "email_pdf", "recipientEmails": ["ops@agentur.io"] }' ``` ## Antwort ```json { "id": "3f1c9c1e-8d2a-4c7e-9b1a-2d5f6a7b8c90", "name": "Wöchentlicher Ops-Bericht", "enabled": true, "frequency": "weekly", "monitorTypes": ["website", "dns", "dnsbl", "domain", "icmp", "smtp", "ssh", "tcp", "ftp", "imap"],…
### Bericht löschen
URL: https://docs.uptimeify.io/de/api/organization/reports/delete-report
Description: Löscht eine Berichtskonfiguration der Organisation samt Zeitplan endgültig. Vergangene Bericht-Läufe werden nicht gelöscht.
Summary: `DELETE /api/organization/reports/:id` Löscht eine Berichtskonfiguration. `:id` ist die `id` des Berichts (eine UUID). Die Organisation wird aus Ihrer authentifizierten Sitzung oder Ihrem API-Token abgeleitet, und der Bericht muss zu ihr gehören. Erfordert die Rolle **admin** der Organisation (API-Tokens gelten als Organisations-Admins). Nur-Lese-Benutzer können keine Berichte löschen. Dadurch werden künftige geplante Läufe des Berichts gestoppt. Bereits erzeugte [Bericht-Läufe](/de/api/organization/reports/list-report-runs) für diesen Bericht bleiben davon unberührt und weiterhin abrufbar. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" REPORT_ID="3f1c9c1e-8d2a-4c7e-9b1a-2d5f6a7b8c90" curl -X DELETE "$BASE_URL/api/organization/reports/$REPORT_ID" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort ```json { "success": true } ``` ## Häufige Fehler - `401 Unauthorized`: nicht authentifiziert. - `403 Forbidden` (`forbidden`): kein Organisations-Admin. - `404 Not Found` (`notFound`): es existiert kein Bericht mit dieser ID für Ihre Organisation. - `400 Invalid Report identifier`: `:id` hat nicht die Form einer UUID. Bericht-IDs sind immer UUIDs, eine numerische ID wird hier nicht angenommen.
### Bericht-PDF herunterladen
URL: https://docs.uptimeify.io/de/api/organization/reports/download-report-pdf
Description: Liefert das archivierte PDF eines Bericht-Laufs direkt im Response-Body.
Summary: `GET /api/organization/report-runs/:id/pdf` Liefert das PDF, das für einen Bericht-Lauf archiviert wurde, direkt im Response-Body. `:id` ist die `id` des Laufs (eine UUID), wie sie von [Bericht-Läufe auflisten](/de/api/organization/reports/list-report-runs) zurückgegeben wird. Der Lauf muss zu Ihrer Organisation gehören. Verfügbar für jede Organisationsrolle, auch für **Nur-Lese**-Benutzer. Ein auf einzelne Kunden beschränkter Aufrufer (kundengebundenes Token oder Login) erreicht nur Berichte mit Umfang `customers`, deren Kunden alle in seinem Umfang liegen; jeder andere Bericht antwortet `404`. Die Bytes werden serverseitig aus dem Object Storage gelesen und an Sie zurückgegeben; das Objekt selbst wird nie als URL offengelegt, die Sitzungs-/Token-Prüfung bei diesem Aufruf ist damit die gesamte Zugriffskontrolle für die Datei. Nur erfolgreich abgeschlossene Läufe mit `format: "email_pdf"` archivieren ein PDF. Prüfen Sie `hasPdf` beim Lauf, bevor Sie diesen Endpoint aufrufen. Läufe mit `format: "email"` sowie fehlgeschlagene oder übersprungene Läufe haben kein PDF und liefern `404`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" RUN_ID="9a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d" curl -X GET "$BASE_URL/api/organization/report-runs/$RUN_ID/pdf" \ -H "Authorization: Bearer $TOKEN" \ -o bericht.pdf ``` ## Antwort `200 OK` mit den PDF-Bytes als Response-Body. `Content-Type: application/pdf`, `Content-Disposition: attachment; filename="report-.pdf"` (`` wird aus dem Perioden-Label des Laufs abgeleitet, z. B. `report-08-2026.pdf`), `Cache-Control: private, max-age=300`, `X-Content-Type-Options: nosniff`. ## Häufige Fehler - `401 Unauthorized`: nicht authentifiziert. - `403 Forbidden` (`forbidden`): kein Zugriff auf diese Organisation. - `404 Not Found` (`reportRunNotFound`): es existiert kein Lauf mit dieser ID für Ihre Organisation. - `404 Not Found` (`reportRunNoPdf`): der Lauf hat kein archiviertes PDF (Nur-E-Mail-Bericht, oder die Erzeugung ist fehlgeschlagen bzw. wurde übersprungen). - `404 Not Found` (`reportPdfNotFound`): der Lauf-Datensatz hat einen PDF-Pfad, aber das Objekt konnte nicht aus dem Object Storage gelesen werden. - `400 Invalid Report run identifier`: `:id` hat nicht die Form einer UUID. Lauf-IDs sind immer UUIDs, eine numerische ID wird hier nicht angenommen.
### Bericht abrufen
URL: https://docs.uptimeify.io/de/api/organization/reports/get-report
Description: Gibt eine einzelne Berichtskonfiguration der Organisation anhand ihrer Public ID zurück.
Summary: `GET /api/organization/reports/:id` Gibt eine einzelne Berichtskonfiguration zurück. `:id` ist die `id` des Berichts (eine UUID), wie sie von [Bericht erstellen](/de/api/organization/reports/create-report) oder [Berichte auflisten](/de/api/organization/reports/list-reports) zurückgegeben wird. Der Bericht muss zu Ihrer Organisation gehören. Verfügbar für jede Organisationsrolle, auch für **Nur-Lese**-Benutzer. Ein auf einzelne Kunden beschränkter Aufrufer (kundengebundenes Token oder Login) erreicht nur Berichte mit Umfang `customers`, deren Kunden alle in seinem Umfang liegen; jeder andere Bericht antwortet `404`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" REPORT_ID="3f1c9c1e-8d2a-4c7e-9b1a-2d5f6a7b8c90" curl -X GET "$BASE_URL/api/organization/reports/$REPORT_ID" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort ```json { "id": "3f1c9c1e-8d2a-4c7e-9b1a-2d5f6a7b8c90", "name": "Wöchentlicher Ops-Bericht", "enabled": true, "frequency": "weekly", "weekday": 1, "dayOfMonth": null, "sendHour": 2, "timezone": "Europe/Berlin", "scopeMode": "all", "scopeCustomerIds": [], "scopeTagIds": [], "inclusionMode": "problems", "problemSignals": { "incident": true, "downtimeMinutes": 5, "sslDaysLt": 14, "responseBreach": true }, "thresholdUptimeLt": null, "thresholdResponseGt": null, "sendWhenEmpty": false, "sections": { "fleetSummary": true, "worstPerformers": true, "perSiteTable": true, "incidentLog": true, "sslExpiry": true, "groupByCustomer": false }, "monitorTypes": ["website", "dns", "dnsbl", "domain", "icmp", "smtp", "ssh", "tcp", "ftp", "imap"], "sectionsByType": {}, "groupByCustomer": false, "includeStatusPages": true, "format": "email_pdf", "recipientEmails": ["ops@agentur.io"], "recipientUserIds": [], "createdAt": "2026-06-01T02:00:00.000Z", "updatedAt": "2026-06-01T02:00:00.000Z" } ``` ## Häufige Fehler - `401 Unauthorized`: nicht authentifiziert. - `403 Forbidden` (`forbidden`): kein Zugriff auf diese Organisation. - `404 Not Found` (`notFound`): es existiert kein Bericht mit dieser ID für Ihre Organisation. - `400 Invalid Report identifier`: `:id` hat nicht die Form einer UUID. Bericht-IDs sind immer UUIDs, eine numerische ID wird hier nicht angenommen.
### Bericht-Läufe auflisten
URL: https://docs.uptimeify.io/de/api/organization/reports/list-report-runs
Description: Gibt die Erzeugungs-/Zustellhistorie der Organisationsberichte zurück, optional gefiltert auf einen einzelnen Bericht.
Summary: `GET /api/organization/report-runs` Listet Bericht-Läufe der Organisation, neueste zuerst. Ein Lauf wird bei jeder Erzeugung eines Berichts angelegt: geplant oder über [Bericht sofort senden](/de/api/organization/reports/send-report-now). Die Organisation wird aus Ihrer authentifizierten Sitzung oder Ihrem API-Token abgeleitet. Verfügbar für jede Organisationsrolle, auch für **Nur-Lese**-Benutzer. Ein auf einzelne Kunden beschränkter Aufrufer (kundengebundenes Token oder Login) sieht nur Berichte mit Umfang `customers`, deren Kunden alle in seinem Umfang liegen; Berichte über alle Kunden oder über Tags fehlen in der Liste. ## Query-Parameter | Feld | Typ | Erforderlich | Hinweise | |---|---|---|---| | `reportId` | string (uuid) | nein | Beschränkt auf Läufe eines Berichts. Löst sich die ID nicht auf einen Bericht Ihrer Organisation auf, ist die Liste leer. | | `limit` | integer | nein | Standard `50`, begrenzt auf `200`. | | `offset` | integer | nein | Standard `0`. | | `envelope` | string | nein | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/organization/report-runs?reportId=3f1c9c1e-8d2a-4c7e-9b1a-2d5f6a7b8c90&limit=20&envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort ```json { "items": [ { "id": "9a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d", "reportId": "3f1c9c1e-8d2a-4c7e-9b1a-2d5f6a7b8c90", "reportName": "Wöchentlicher Ops-Bericht", "periodStart": "2026-05-25T00:00:00.000Z", "periodEnd": "2026-06-01T00:00:00.000Z", "periodLabel": "25. Mai - 1. Juni 2026", "status": "sent", "trigger": "schedule", "sentAt": "2026-06-01T02:00:12.000Z", "recipients": ["ops@agentur.io"], "hasPdf": true, "summary": { "sitesIncluded": 42, "incidents": 3 }, "createdAt": "2026-06-01T02:00:00.000Z" } ], "total": 1, "page": 1, "perPage": 20 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (ein blankes Array derselben Einträge); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. `status` ist einer von `pending`, `generating`, `sent`, `failed`, `skipped_empty`. `trigger` ist `schedule` oder `manual`. `hasPdf` ist nur `true`, wenn für diesen Lauf ein PDF archiviert wurde. Nutzen Sie es, um zu entscheiden, ob [Bericht-PDF herunterladen](/de/api/organization/reports/download-report-pdf) aufgerufen werden soll. ## Häufige Fehler - `401 Unauthorized`: nicht authentifiziert. - `403 Forbidden` (`forbidden`): kein Zugriff auf diese Organisation. - `400 Invalid Report identifier`: der Query-Parameter `reportId` wurde gesendet, hat aber nicht die Form einer UUID. Ein formgerechtes `reportId`, zu dem kein Bericht gehört, liefert stattdessen eine leere Liste.
### Berichte auflisten
URL: https://docs.uptimeify.io/de/api/organization/reports/list-reports
Description: Gibt alle Berichtskonfigurationen der Organisation zurück.
Summary: `GET /api/organization/reports` Listet die wiederkehrenden Berichtskonfigurationen der Organisation, neueste zuerst. Die Organisation wird aus Ihrer authentifizierten Sitzung oder Ihrem API-Token abgeleitet. Verfügbar für jede Organisationsrolle, auch für **Nur-Lese**-Benutzer. Ein auf einzelne Kunden beschränkter Aufrufer (kundengebundenes Token oder Login) sieht nur Berichte mit Umfang `customers`, deren Kunden alle in seinem Umfang liegen; Berichte über alle Kunden oder über Tags fehlen in der Liste. ## Query-Parameter | Parameter | Typ | Standard | Beschreibung | |---|---|---|---| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/organization/reports?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort ```json { "items": [ { "id": "3f1c9c1e-8d2a-4c7e-9b1a-2d5f6a7b8c90", "name": "Wöchentlicher Ops-Bericht", "enabled": true, "frequency": "weekly", "weekday": 1, "dayOfMonth": null, "sendHour": 2, "timezone": "Europe/Berlin", "scopeMode": "all", "scopeCustomerIds": [], "scopeTagIds": [], "inclusionMode": "problems", "problemSignals": { "incident": true, "downtimeMinutes": 5, "sslDaysLt": 14, "responseBreach": true }, "thresholdUptimeLt": null, "thresholdResponseGt": null, "sendWhenEmpty": false, "sections": { "fleetSummary": true, "worstPerformers": true, "perSiteTable": true, "incidentLog": true, "sslExpiry": true, "groupByCustomer": false }, "monitorTypes": ["website", "dns", "dnsbl", "domain", "icmp", "smtp", "ssh", "tcp", "ftp", "imap"], "sectionsByType": {}, "groupByCustomer": false, "includeStatusPages": true, "format": "email_pdf", "recipientEmails": ["ops@agentur.io"], "recipientUserIds": [], "createdAt": "2026-06-01T02:00:00.000Z", "updatedAt": "2026-06-01T02:00:00.000Z" } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (`{ "reports": [...] }`); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. ## Häufige Fehler - `401 Unauthorized`: nicht authentifiziert. - `403 Forbidden` (`forbidden`): kein Zugriff auf diese Organisation.
### Bericht sofort senden
URL: https://docs.uptimeify.io/de/api/organization/reports/send-report-now
Description: Stellt eine sofortige, außerplanmäßige Erzeugung und Zustellung eines Organisationsberichts in die Warteschlange.
Summary: `POST /api/organization/reports/:id/send-now` Stellt einen manuellen Lauf einer Berichtskonfiguration in die Warteschlange, unabhängig von deren `frequency`/`sendHour`-Zeitplan. `:id` ist die `id` des Berichts (eine UUID). Die Organisation wird aus Ihrer authentifizierten Sitzung oder Ihrem API-Token abgeleitet, und der Bericht muss zu ihr gehören. Erfordert die Rolle **admin** der Organisation (API-Tokens gelten als Organisations-Admins). Nur-Lese-Benutzer können keinen Versand auslösen. Ein manueller Versand läuft auch, wenn der Bericht ausgeschaltet ist (`enabled: false`), und legt einen Lauf an; der Schalter gilt nur für den Zeitplan. Dieser Endpoint stellt den Job nur in die Warteschlange. Er wartet nicht auf Erzeugung oder Zustellung. Fragen Sie [Bericht-Läufe auflisten](/de/api/organization/reports/list-report-runs) (gefiltert nach `reportId`) ab, um den resultierenden Lauf zu sehen, sobald dessen `status` über `pending` hinausgeht. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" REPORT_ID="3f1c9c1e-8d2a-4c7e-9b1a-2d5f6a7b8c90" curl -X POST "$BASE_URL/api/organization/reports/$REPORT_ID/send-now" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort ```json { "queued": true, "jobId": "orgreport-manual-3f1c9c1e-8d2a-4c7e-9b1a-2d5f6a7b8c90-1b6e..." } ``` ## Häufige Fehler - `401 Unauthorized`: nicht authentifiziert. - `403 Forbidden` (`forbidden`): kein Organisations-Admin. - `404 Not Found` (`notFound`): es existiert kein Bericht mit dieser ID für Ihre Organisation. - `400 Invalid Report identifier`: `:id` hat nicht die Form einer UUID. Bericht-IDs sind immer UUIDs, eine numerische ID wird hier nicht angenommen.
### Bericht aktualisieren
URL: https://docs.uptimeify.io/de/api/organization/reports/update-report
Description: Aktualisiert eine Berichtskonfiguration der Organisation. Alle Felder sind optional; mindestens eines muss angegeben werden.
Summary: `PATCH /api/organization/reports/:id` Aktualisiert eine Berichtskonfiguration teilweise. `:id` ist die `id` des Berichts (eine UUID). Die Organisation wird aus Ihrer authentifizierten Sitzung oder Ihrem API-Token abgeleitet, und der Bericht muss zu ihr gehören. Erfordert die Rolle **admin** der Organisation (API-Tokens gelten als Organisations-Admins). Nur-Lese-Benutzer können keine Berichte aktualisieren. Senden Sie nur die Felder, die Sie ändern möchten. Die feldübergreifende Validierung (Zeitplan und Scope) wird gegen das **zusammengeführte** Ergebnis erneut ausgeführt. Ein `PATCH`, der nur `frequency` auf `weekly` setzt, ohne auch `weekday` mitzusenden, schlägt fehl, wenn der bestehende Bericht kein `weekday` gesetzt hat. ## Request-Body Dieselben Felder wie bei [Bericht erstellen](/de/api/organization/reports/create-report), alle optional, mindestens ein Feld muss aber vorhanden sein: | Feld | Typ | Hinweise | |---|---|---| | `name` | string | 1-200 Zeichen. | | `enabled` | boolean | | | `frequency` | `"daily" \| "weekly" \| "monthly"` | | | `weekday` | integer 0-6 \| null | Praktisch erforderlich, wenn die resultierende `frequency` `weekly` ist. | | `dayOfMonth` | integer 1-28 \| null | Praktisch erforderlich, wenn die resultierende `frequency` `monthly` ist. | | `sendHour` | integer 0-23 | | | `timezone` | string | IANA-Zeitzone. | | `scopeMode` | `"all" \| "customers" \| "tags"` | | | `scopeCustomerIds` | integer[] | Müssen zu Ihrer Organisation gehören. | | `scopeTagIds` | integer[] | Müssen zu Ihrer Organisation gehören. | | `inclusionMode` | `"all" \| "problems" \| "threshold"` | | | `problemSignals` | object | `{ incident, downtimeMinutes, sslDaysLt, responseBreach }`. | | `thresholdUptimeLt` | number \| null | | | `thresholdResponseGt` | integer (ms) \| null | | | `sendWhenEmpty` | boolean | | | `sections` | object | Sechs Booleans zum Ein-/Ausschalten der Abschnitte. | | `monitorTypes` | string[] | Ein oder mehrere aus `website`, `dns`, `dnsbl`, `domain`, `icmp`, `smtp`, `ssh`, `tcp`, `ftp`, `imap`. Darf nicht als leeres Array gesendet werden. | | `sectionsByType` | object | Abschnitts-Umschalter pro Typ: `{ "": { "": boolean } }`. Welche `sectionKey`s zulässig sind, hängt vom Typ ab: siehe [Abschnitts-Schlüssel pro Monitor-Typ](/de/api/organization/reports/create-report#abschnitts-schlüssel-pro-monitor-typ). Wird ein für seinen Typ unzulässiger Abschnitts-Schlüssel gesendet, schlägt die Anfrage mit `400 Bad Request` fehl. | | `groupByCustomer` | boolean | Untergliedert die Tabelle jedes Monitor-Typs zusätzlich nach Kunde. | | `includeStatusPages` | boolean | Hängt am Ende den Abschnitt Statusseiten an (Veröffentlichung, Kunde, Komponenten, Vorfälle inklusive der über Statusseiten-Regeln des Incident Managements, Wartungen, Abonnenten). Umfang `customers` zeigt die Seiten dieser Kunden, Umfang `tags` die Seiten, die mindestens einen Monitor mit einem der Tags zeigen, als Komponente oder als Monitor des Seitenkunden. | | `format` | `"email" \| "email_pdf"` | | | `recipientEmails` | string[] | Max. 50. | | `recipientUserIds` | string[] | Max. 50. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" REPORT_ID="3f1c9c1e-8d2a-4c7e-9b1a-2d5f6a7b8c90" curl -X PATCH "$BASE_URL/api/organization/reports/$REPORT_ID" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "enabled": false, "recipientEmails": ["ops@agentur.io", "cs@agentur.io"] }' ``` ## Antwort ```json { "id": "3f1c9c1e-8d2a-4c7e-9b1a-2d5f6a7b8c90", "name": "Wöchentlicher Ops-Bericht", "enabled": false, "frequency": "weekly", "weekday": 1, "dayOfMonth": null, "sendHour": 2, "timezone": "Europe/Berlin", "scopeMode": "all", "inclusionMode": "problems", "monitorTypes": ["website", "dns", "dnsbl", "domain", "icmp", "smtp", "ssh", "tcp", "ftp", "imap"], "sectionsByType": {}, "groupByCustomer": false, "includeStatusPages": true, "format": "email_pdf", "recipientEmails": ["ops@agentu…
### Datenexport anfordern
URL: https://docs.uptimeify.io/de/api/organization/request-data-export
Description: Stellt einen vollständigen Export der Inhalte deiner Organisation als JSON und CSV in die Warteschlange, als ZIP zum Download, angekündigt per E-Mail.
Summary: `POST /api/organization/data-export` Startet einen vollständigen Export von allem, was deine Organisation in Uptimeify hat: Kunden, Monitore aller Typen, Vorfälle und Vorfalls-Updates, Wartungsfenster, Benachrichtigungskanäle, Tags, Statusseiten, Reports samt Lauf-Historie, Abrechnungsdaten, Teammitglieder, API-Token-Metadaten, Incident-Management-Konfiguration und -Historie sowie, sofern du nicht abwählst, die rohe Check-Historie hinter deinen Monitoren. Die Anfrage antwortet sofort mit `202 Accepted`. Das Bundle entsteht im Hintergrund; sobald es fertig ist, geht eine E-Mail mit Download-Link an die Empfänger, und der Export erscheint in `GET /api/organization/data-export` als `ready`. ## Request-Body | Feld | Typ | Default | Beschreibung | | --- | --- | --- | --- | | `includeCheckHistory` | boolean | `true` | Rohe Check-Zeilen einschließen. Das ist der Löwenanteil des Bundles; `false` liefert einen reinen Konfigurations-Export. | | `recipientEmails` | string[] | Administratoren der Organisation | Wer die „Export ist fertig"-E-Mail bekommt. Jede Adresse muss zu einem Mitglied dieser Organisation gehören. Maximal 20. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/organization/data-export" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "includeCheckHistory": true }' ``` ## Antwort (Response) ```json { "id": "0f0f2f6a-2b3b-4a2f-9a7c-3e5f8c1d2b44", "status": "queued", "format": "json_csv", "includeCheckHistory": true, "recipientEmails": ["admin@deineagentur.com"], "sizeBytes": null, "retentionCutoff": null, "expiresAt": null, "downloadCount": 0, "lastDownloadedAt": null, "errorMessage": null, "manifest": null, "createdAt": "2026-07-30T09:12:44.101Z", "startedAt": null, "completedAt": null } ``` **Abgelöstes Feld:** `error` wird bis zum Entfall am 18.01.2027 weiter neben `errorMessage` geliefert. Lies `errorMessage`. ## Was im Bundle steckt Ein ZIP mit beiden Formaten plus Index: - `manifest.json`, jeder Bereich mit Zeilenanzahl, Retention-Grenze pro Paket und Vollständigkeits-Flags - `README.txt`, was enthalten, was geschwärzt, was unvollständig ist - `json/.json`, Datensätze in voller Tiefe - `csv/.csv`, dieselben Datensätze, flach und tabellenfertig Drei Regeln begrenzen den Inhalt: - **Retention.** Zeitreihen (Check-Historie, Alarm-Zustellungen, SMS-Log) reichen so weit zurück, wie die Datenvorhaltung der Pakete deiner Kunden es hergibt. Ältere Zeilen werden nicht zurückgehalten, es gibt sie nicht mehr. - **Zugangsdaten.** Passwörter, Webhook-Secrets, Integrations- und Ingest-Tokens, API-Token-Hashes und SMTP-Passwörter werden durch `[redacted]` ersetzt. Eigene Header (`headers`, `webhookHeaders`, `customHeaders`) behalten ihre Namen, jeder Wert wird durch `[redacted]` ersetzt. Der restliche Datensatz wird vollständig exportiert. - **Audit-Log.** `organization/audit-log` enthält administrative Aktionen und Anmelde-Ereignisse der letzten 12 Monate: wer was getan hat; bei Anmeldungen und verbundenen Anwendungen auch von welcher IP und mit welchem User-Agent. Ältere Einträge gibt es nicht mehr. Der `note` des Bereichs in `manifest.json` nennt den Zeitraum. Einen Zeitraum als CSV-Datei holst du über [Audit-Log exportieren](/de/api/organization/export-audit-log). Die rohe Check-Historie ist pro Monitor-Typ gekappt (standardmäßig die 100.000 neuesten Zeilen). Ein gekappter Bereich trägt `truncated` in `manifest.json`; den Rest holst du pro Monitor über `GET /api/websites/{id}/check-history?format=csv` und die entsprechenden Endpunkte der anderen Monitor-Typen. `truncated` markiert außerdem einen Bereich, dessen Quelle während des Exports nicht lesbar war. Ein solcher Bereich trägt einen `note`, der mit `INCOMPLETE` beginnt, und null Zeilen, das ist ausdrücklich keine Aussage darüber, dass der Bereich leer wäre. Fordere einen neuen Export an, um es erneut zu versuchen. ## Limits - Ein Export gleichzeitig pro Organi…
### Rechnungs-Details aktualisieren
URL: https://docs.uptimeify.io/de/api/organization/update-billing-details
Description: Aktualisiert Rechnungsinformationen der Organisation aus deiner authentifizierten Session.
Summary: `PATCH /api/organization/billing` ## Anfrage (Request Body) ```json { "billingEmail": "billing@deinkunde.com" } ``` ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X PATCH "$BASE_URL/api/organization/billing" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -H "Accept: application/json" \ -d '{ "billingEmail": "billing@deinkunde.com" }' ``` ## Hinweise - Dieses Endpoint akzeptiert aktuell nur `billingEmail`. - Die Organisation wird automatisch aus deiner authentifizierten Session bzw. deinem API-Token abgeleitet. - Die Legacy-Route `PATCH /api/organizations/:organizationPublicId/billing` bleibt aus Kompatibilitätsgründen weiterhin verfügbar. - Der plurale org-lose Alias `PATCH /api/organizations/billing` wird ebenfalls unterstützt. - Global Admins brauchen für die org-lose Route einen aktiven Organisationskontext in der Session. ## Häufige Fehler - `400 Invalid request body` wenn der Payload nicht zum Schema passt - `400 Organization ID is required in the authenticated session` wenn aus Session/Token keine Organisation abgeleitet werden kann - `401 Unauthorized` wenn du nicht angemeldet bist - `403 Forbidden` wenn du keine Admin-Berechtigung zum Aktualisieren der Rechnungsinformationen hast ## Antwort (Response) Gibt die aktualisierten Rechnungsdetails zurück. Siehe [Fehlerliste](/de/api/error-codes-and-known-pitfalls) für Fehlerantworten.
### Organisation aktualisieren
URL: https://docs.uptimeify.io/de/api/organization/update-organization
Description: Aktualisiert die Organisation aus deiner authentifizierten Session.
Summary: `PATCH /api/organization` ## Anfrage (Request Body) ```json { "name": "Neuer Name", "companyName": "Neuer Firmenname", "street": "Neue Straße", "postalCode": "54321", "city": "Neue Stadt", "country": "US", "vatId": "US123", "countryCode": "AT", "billingEmail": "neu@deinkunde.com", "contractEmail": "vertrag@deinkunde.com", "requireMfaAdmins": true, "requireMfaEditors": false, "requireMfaReadonly": false, "requireMfaCustomers": false, "defaultNotificationChannels": { "email": true, "sms": false, "webhook": true, "integrations": false }, "defaultNotificationTargets": { "email": "both", // customer, organization, both "sms": "organization", "webhook": "organization", "integrations": "customer" } } ``` ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X PATCH "$BASE_URL/api/organization" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -H "Accept: application/json" \ -d '{ "name": "Neuer Name", "billingEmail": "neu@deinkunde.com" }' ``` Hinweise: - Die Organisation wird automatisch aus deiner authentifizierten Session bzw. deinem API-Token abgeleitet. - Die Legacy-Route `PATCH /api/organizations/:organizationPublicId` bleibt aus Kompatibilitätsgründen weiterhin verfügbar. - Der plurale org-lose Alias `PATCH /api/organizations` wird ebenfalls unterstützt. - Global Admins brauchen für die org-lose Route einen aktiven Organisationskontext in der Session. - `contractEmail` (E-Mail-Adresse oder `null`) erhält Ankündigungen zu Änderungen an AGB, AVV und Datenschutzerklärung. Ist sie gesetzt, geht die Ankündigung nur an diese Adresse und an keinen Admin; `null` schickt sie wieder an alle Admins der Organisation. - `countryCode` ist das Abrechnungsland der Organisation als ISO-3166-1-Alpha-2-Code (zwei Buchstaben, bei der Eingabe unabhängig von Groß-/Kleinschreibung, gespeichert und zurückgegeben immer in Großbuchstaben). Er bestimmt die umsatzsteuerliche Behandlung: Reverse Charge nach AGB § 10.2 setzt voraus, dass hier ein EU-Mitgliedsstaat außer Deutschland steht. - Das Setzen von `vatId` oder `countryCode` (eines der beiden, egal ob in derselben Anfrage oder getrennt) setzt `vatIdStatus` auf `unverified` zurück. Ein vorheriges `valid`-Ergebnis überlebt eine Änderung an keinem der beiden Felder, validiere nach der Änderung erneut mit [USt-IdNr. validieren](/de/api/organization/validate-vat-id), um die Reverse-Charge-Berechtigung wiederherzustellen. - **Kontingent-Änderungen sind nicht symmetrisch.** Eine Änderung mit **höherem** `quotaMonthlyPriceCents` als bisher wird sofort wirksam; der Differenzbetrag wird anteilig für den Rest des laufenden Abrechnungszeitraums berechnet. Eine Änderung mit **niedrigerem** Preis wird **nicht** sofort wirksam: Standardmäßig wird sie zum Ende des laufenden Abrechnungszeitraums geplant, und für den nicht genutzten Teil des höheren Plans gibt es keine Rückvergütung (mit `quotaChangeEffective`, siehe unten, gilt sie stattdessen sofort). Das gilt ab dem 1. Januar 2027; bis zum 31. Dezember 2026 gilt eine Reduzierung bei monatlicher Abrechnung standardmäßig sofort mit anteiliger Gutschrift. Bis dahin behält die Organisation ihren aktuellen Tarif, und alle Kontingent-Felder der Organisation beschreiben weiterhin diesen Tarif. Die Richtung entscheidet allein der Preis, nie das Monitor-Limit. Ein Tarif, der bei *mehr* Monitoren weniger kostet, ist also trotzdem eine Reduzierung. - Eine geplante Reduzierung wird als `pendingQuotaChange` zurückgegeben, hier wie bei [Organisations-Details abrufen](/de/api/organization/get-organization-details); ohne geplante Änderung ist das Feld `null`. Pro Organisation gibt es höchstens eine geplante Änderung: Eine zweite Reduzierung ersetzt die erste, eine Erhöhung hebt sie auf (sonst würdest du an der Periodengrenze stillschweigend wieder heruntergestuft). Zum Abbrechen ohne Tarifwechsel dient [Geplante Kontingent-Änderung abbrechen](/de/api/organization/cancel-pending-quota-change), denselben Tarif hier erneu…
### Paket-Konfiguration erstellen/aktualisieren
URL: https://docs.uptimeify.io/de/api/organization/upsert-package-config
Description: Erstellt eine neue Paket-Konfiguration (über :packageType) oder aktualisiert eine bestehende. packageType ist ein frei wählbarer Bezeichner der Organisation. Customer-Endpoints können später genau diesen Key verwenden.
Summary: `PATCH /api/package-configs/:packageType` Hier werden u.a. Alerting-Defaults wie `alertConsecutiveChecks` sowie Feature-Flags wie `enableEmailAlerts` gepflegt. Die Alarm-Flags (`enableEmailAlerts`, `enableSmsAlerts`, `enableWebhookAlerts`, `enableIntegrationAlerts`) entscheiden nur, welche Kanäle deiner Organisation zu Kunden dieses Pakets alarmieren. Kanäle, die ein Kunde selbst anlegt, erreichen ihn immer. Ist beim Kunden ein eigener `enable*Alerts`-Wert gesetzt, ersetzt er für diesen Kunden das Paket. ## Anfrage (Request Body) Alle Felder sind optional. Wenn du im UI einen lesbaren Namen anzeigen willst, kannst du zusätzlich `displayName` setzen und den technischen `packageType` stabil halten. ```json { "displayName": "Pro Care", "maxUrls": 100, "maxStatusPages": 5, "dataRetentionMonths": 12, "checkIntervalMinutes": 1, "checkLocations": 3, "notificationDelayMinutes": 0, "reminderDelayMinutes": 10, "alertConsecutiveChecks": 3, "alertLocationThreshold": "majority", "alertLocationThresholdCount": 2, "alertReminderInterval": 60, "enableEmailAlerts": true, "enableSmsAlerts": true, "enableWebhookAlerts": true, "enableIntegrationAlerts": true, "enablePostRequestEscalation": false, "enableMaintenanceWindows": true, "enablePdfReports": true, "monthlyReportsDefault": true, "allowSelfService": true, "maxSelfServiceUrls": 10, "notes": "Default für PRO-Kunden" } ``` `notes` (Text bis 4096 Zeichen oder `null`) ist eine freie interne Notiz. Weglassen behält die bisherige Notiz, `null` oder ein leerer Text löscht sie. ### Monitor-Ownership-Standards `allowSelfService` (Standard `false`) und `maxSelfServiceUrls` (Standard `0`) sind die Paket-Standards für das [Managed-vs.-Self-Service](/de/monitoring/managed-vs-self-service)-Modell. Jeder Kunde des Pakets erbt sie, sofern der Kunde keinen eigenen non-`null`-Override trägt (siehe [Kunden aktualisieren](/de/api/customers/update-customer)). `maxSelfServiceUrls` begrenzt die **Gesamtzahl** der Self-Service-Monitore eines Kunden über alle Monitor-Typen. Die `enable*`-Alarm-Flags fungieren zugleich als vererbte Kanal-Typ-Policy desselben Modells. ### Statusseiten je Kunde `maxStatusPages` (Ganzzahl oder `null`, Standard `null` = unbegrenzt) begrenzt, wie viele Statusseiten ein Kunde dieses Pakets haben darf. Eine weitere Seite für einen solchen Kunden anzulegen oder eine Seite zu ihm umzuhängen antwortet mit `409` und `data.code: statusPageLimitReached`, die Grenze steht in `data.max`. Seiten ohne Kunde zählen nie, und die Organisation selbst hat kein Limit. `null` hebt die Grenze auf. ### `alertConsecutiveChecks` Eine ganze Zahl zwischen **1 und 10**; Werte außerhalb dieses Bereichs werden mit `400` und `data.code` `invalidRequestBody` abgelehnt. Der Wert bestimmt, wie viele Standorte einen Fehler sehen müssen, bevor ein Vorfall öffnet, der fehlschlagende Standort eingerechnet. Schlägt eine Prüfung fehl, prüfen die nächsten Standorte innerhalb von Sekunden nach: `1` öffnet den Vorfall beim ersten Fehler ohne Bestätigung, `2` wartet auf die Bestätigung durch einen weiteren Standort und so weiter. Neue Pakete starten mit **2** (vor dem 30.10.2026 war der Standard 1; bestehende Werte bleiben unverändert). Der Wert begrenzt zugleich, wie viele erfolgreiche Zyklen nötig sind, damit sich ein Vorfall wieder schließt. Ein sehr großer Wert verzögert also nicht nur die Alarmierung, sondern auch die Auflösung: bei einem 5-Minuten-Takt hielte der Wert 999 einen Vorfall über 83 Stunden durchgehend grüner Prüfungen hinweg offen. Die Obergrenze entspricht der, die das Dashboard seit jeher durchsetzt. ### `monthlyReportsDefault` `monthlyReportsDefault` (boolean, Standard `true`) ist eine **Vorlage**, kein Live-Schalter: Sie legt beim Anlegen eines neuen Kunden dessen `monthlyReportsEnabled` fest. Ein bereits bestehender Kunde wird dadurch nie überschrieben, sein eigener Wert gilt immer, sobald er gesetzt ist. Um einen geänderten Default auch auf Kunden zu übertragen, die **bereits** auf diesem Paket sind, rufe…
### USt-IdNr. validieren
URL: https://docs.uptimeify.io/de/api/organization/validate-vat-id
Description: Validiert die für die Organisation gespeicherte Umsatzsteuer-Identifikationsnummer gegen das EU-Register VIES und speichert das Ergebnis. Nur eine gültige USt-IdNr. aus einem anderen EU-Mitgliedsstaat qualifiziert die Organisation für die Reverse-Charge-Abrechnung nach AGB § 10.2.
Summary: `POST /api/organizations/:organizationPublicId/vat-id/validate` ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" ORG_ID="" curl -X POST "$BASE_URL/api/organizations/$ORG_ID/vat-id/validate" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` Hinweise: - Dieser Endpoint erwartet keinen Request Body. Er validiert genau das, was aktuell als `vatId` und `countryCode` an der Organisation gespeichert ist, setze beides vorher mit [Organisation aktualisieren](/de/api/organization/update-organization), falls nötig. - Die Validierung ist eine bewusste, eigenständige Aktion und kein Nebeneffekt beim Speichern der Organisation. Der EU-Dienst VIES ist langsam und pro Mitgliedsstaat gelegentlich nicht erreichbar, ein `PATCH` auf die Organisation darf daran nicht scheitern oder hängen bleiben. Das Speichern einer neuen `vatId` oder eines neuen `countryCode` setzt `vatIdStatus` auf `unverified` zurück; erst dieser Endpoint macht daraus wieder ein Ergebnis. - Reverse Charge nach AGB § 10.2 greift nur, wenn das Land der Organisation ein EU-Mitgliedsstaat außer Deutschland ist, eine USt-IdNr. gespeichert ist und `vatIdStatus` exakt `valid` lautet. Jede andere Kombination wird zum Standard-Steuersatz abgerechnet. - Erfordert Schreibzugriff auf die Organisation (Org-Admin oder Global-Admin) aus einer uneingeschränkten Session oder einem uneingeschränkten Token, dieselbe Berechtigung wie bei [Organisation aktualisieren](/de/api/organization/update-organization). Ein kundengescoptes API-Token kann diesen Endpoint nicht aufrufen, selbst mit Admin-Rolle. ## Antwort (Response) ```json { "vatIdStatus": "valid", "vatIdValidatedAt": "2026-07-30T09:15:00.000Z", "vatIdValidationNote": null, "taxTreatment": "reverse_charge" } ``` `vatIdStatus` ist einer von: | Wert | Bedeutung | | --- | --- | | `unverified` | Noch nicht validiert, oder die gespeicherte `vatId`/`countryCode` hat sich seit der letzten Validierung geändert (siehe oben). Dieser Endpoint liefert diesen Wert nie zurück, er ist der Default vor jeder Validierung. | | `valid` | VIES hat die USt-IdNr. bestätigt. Nur dieser Status gewährt Reverse Charge. | | `invalid` | VIES hat die USt-IdNr. abgelehnt, ihr Länderpräfix gehört keinem EU-Umsatzsteuerland an, oder er stimmt nicht mit dem gespeicherten `countryCode` der Organisation überein. | | `unavailable` | VIES konnte kein Ergebnis liefern, Timeout, HTTP-Fehler, oder ein Mitgliedsstaat, dessen Register sich selbst als nicht erreichbar meldet (`MS_UNAVAILABLE`). Bewusst getrennt von `invalid`: Ein Ausfall darf niemals als „die USt-IdNr. ist falsch“ gelesen werden, da das einem berechtigten Kunden zu Unrecht den Reverse Charge entziehen würde. Später erneut versuchen. | `taxTreatment` gibt die daraus resultierende Abrechnungsart an und ist entweder `standard` oder `reverse_charge`. `vatIdValidationNote` ist eine kurze, lesbare Begründung (z. B. warum eine Prüfung `invalid` oder `unavailable` ergeben hat); bei einem `valid`-Ergebnis `null`. ## Häufige Fehler - `401 Unauthorized` (`data.code: unauthorized`) wenn du nicht angemeldet bist - `400 Invalid Organization identifier` wenn `:organizationPublicId` weder eine Legacy-Integer-ID noch eine gültige UUID-Public-ID ist - `403 Forbidden` (`data.code: forbidden`) wenn du keinen Schreibzugriff auf die Organisation hast - `403 Forbidden` (`data.code: customerScopedTokenForbidden`) wenn mit einem kundengescopten API-Token aufgerufen wird; dies ist eine organisationsweite Aktion und erfordert ein organisationsgescoptes Token oder eine Session - `404 Organization not found` (kein `data.code`) wenn `:organizationPublicId` zu keiner bestehenden Organisation aufgelöst werden kann - `404 Organization not found` (`data.code: organizationNotFound`) wenn die Organisation in dem kurzen Zeitfenster zwischen der Auflösung von `:organizationPublicId` und der eigenen Prüfung des Endpoints gelöscht wird, ein Sonderfall, nicht die übliche Not-Foun…
### Service-Status
URL: https://docs.uptimeify.io/de/api/service-status
Description: Öffentlicher, unauthentifizierter Endpunkt mit Uptimeifys eigener Plattform-Verfügbarkeit, Check- und Alert-Delivery-Quoten, Komponenten-Status und die hash-verketteten eingefrorenen Monatswerte.
Summary: `GET /api/service-status` Keine Authentifizierung nötig. Liefert keine Kundendaten, nur die eigenen Delivery-Kennzahlen der Plattform, den Status der veröffentlichten Komponenten und die eingefrorenen Monatswerte dahinter. ## Beispiel (cURL) ```bash curl -X GET "https://uptimeify.io/api/service-status" \ -H "Accept: application/json" ``` ## Antwort (Response) ```json { "checkDelivery": { "pct": 99.97, "coveragePct": 99.94, "announcedMaintenanceMinutes": 0, "insufficientData": false, "windowDays": 90 }, "alertDelivery": { "pct": 97.31, "sampleSize": 2454, "endpointFailures": 140, "latencyP90Ms": 1727, "latencySampleSize": 812, "insufficientData": false, "latencyInsufficientData": false }, "components": [ { "key": "de-fra", "displayName": "Frankfurt (DE)", "state": "operational", "coveragePct": 99.94 }, { "key": "alerting", "displayName": "Alert Delivery", "state": "operational", "coveragePct": 100 } ], "frozenMonths": [ { "month": "2026-06-01", "sliKind": "check_delivery", "scopeKey": "mesh", "numerator": 4318204, "denominator": 4319850, "unknownUnits": 612, "rowHash": "9f2c1a7e4b8d0f3a6c5e2b1d8a7f4e9c0b3d6a1f8e5c2b9d7a4f1e8c5b2d9a6f" }, { "month": "2026-06-01", "sliKind": "measurement_coverage", "scopeKey": "mesh", "numerator": 43176, "denominator": 43200, "unknownUnits": 24, "rowHash": "4d1b8e0cc0a2f7593e6b4c1d8a05f2e7b9c3d6a1f8e5c2b9d7a4f1e8c5b2d9a6" } ] } ``` Hinweise: - `checkDelivery.pct` und `alertDelivery.pct` sind rollierende `windowDays`-Werte (aktuell 90 Tage), auf zwei Nachkommastellen gekappt, nie aufgerundet. - **`checkDelivery.pct` zählt geplante ZYKLEN, keine einzelnen Prüfungen.** Jeder Monitor ist einmal pro Prüfintervall fällig, das ist ein Zyklus. Ein Zyklus gilt als ausgeliefert, wenn zu diesem Monitor mindestens eine Prüfzeile vorliegt, von **irgendeinem** unserer Standorte, innerhalb seiner Minute plus zwei Minuten Toleranz; abgezogen wird ausschließlich ein Zyklus, der nirgends eine Prüfung erzeugt hat. `numerator` und `denominator` einer `check_delivery`-Zeile sind damit ganze Zyklus-Anzahlen: erfüllte über fällige. **Welcher Standort einen Zyklus ausgeführt hat, geht in diese Zahl nicht ein.** Der Scheduler prüft pro Zyklus von einem rotierenden Standort aus und nicht von allen gleichzeitig; ein Standort, der noch nicht an der Reihe war, hat nichts versäumt, und seinen Anteil als Fehlmenge zu verbuchen hat Ausfälle ausgewiesen, die es nicht gegeben hat. Der Verlust eines Standorts erscheint stattdessen in `components[]` (je Komponente und mit eigenem `coveragePct`). - **`unknownUnits` steckt in KEINEM Nenner auf diesem Endpunkt.** Jede Quote wird über das gemessen, was die Plattform tatsächlich belegen kann: `denominator` ist die Erwartung über die erfassten Einheiten, `unknownUnits` die Erwartung über die nie erfassten, eine Lücke im minütlichen Recorder, ein hängengebliebener Rollup. Beides sind getrennte Achsen, weil „wir waren nicht verfügbar" und „wir konnten nicht messen" zwei verschiedene Tatsachen sind: Die zweite in die erste einzurechnen, veröffentlicht einen Ausfall, den es nicht gegeben hat, und macht die Zahl zum Maß für die Zuverlässigkeit des Recorders statt für die des Dienstes. - **`coveragePct` ist die zweite Hälfte jeder Aussage und wird nie weggelassen.** Es ist der Anteil des Fensters, den die Plattform belegen kann, `0`-`100`, auf zwei Nachkommastellen gekappt; `null` nur dann, wenn im Fenster noch gar nichts geschuldet war. `checkDelivery.coveragePct` gilt für das gesamte Prüfnetz, `components[].coveragePct` je Komponente; für eine nie gemessene Komponente ist es `null`. Die konservative Lesart (der Anteil des Fensters, der positiv als ausgeliefert bestätigt ist) ist das Produkt beider Werte: `pct x coveragePct / 100`. - **`checkDelivery.announcedMaintenanceMinutes` ist angekündigte Wartung der Plattform, aus beiden Zahlen herausgenommen.** Minuten innerhalb einer Wartung, die wir Kunden vorher angekündigt haben, zählen weder als ausgeliefert noch als Messlücke: Sie fallen aus `p…
### Statusseiten
URL: https://docs.uptimeify.io/de/api/status-pages
Description: Statusseiten ermöglichen es, den Betriebsstatus überwachter Dienste für Kunden oder die Öffentlichkeit transparent darzustellen.
Summary: Sie können öffentlich zugänglich oder auf Kundenmitglieder beschränkt sein. Eigene Domains werden per DNS-Verifizierung eingebunden. ## Authentifizierung Alle Beispiele setzen einen Bearer-Token voraus: ```bash BASE_URL="https://uptimeify.io" TOKEN="" ``` ## Endpunkte - [Statusseiten auflisten](/de/api/status-pages/list-status-pages) - [Statusseite erstellen](/de/api/status-pages/create-status-page) - [Statusseite aktualisieren](/de/api/status-pages/update-status-page) - [Statusseite löschen](/de/api/status-pages/delete-status-page) - [Öffentliche Statusseite abfragen](/de/api/status-pages/get-public-status-page) - [Statusseite abfragen](/de/api/status-pages/get-status-page) - [Design abfragen](/de/api/status-pages/get-status-page-design) - [Design aktualisieren](/de/api/status-pages/update-status-page-design) - [Abonnenten auflisten](/de/api/status-pages/list-subscribers) - [Abonnenten löschen](/de/api/status-pages/delete-subscriber) - [Abonnenten exportieren](/de/api/status-pages/export-subscribers) - [Eigene Domain hinzufügen](/de/api/status-pages/add-status-page-domain) - [Statusseiten-Domain abfragen](/de/api/status-pages/get-status-page-domain) - [Diagnose der Statusseiten-Domain](/de/api/status-pages/get-status-page-domain-diagnostics) - [Eigene Domain entfernen](/de/api/status-pages/remove-status-page-domain) - [Statusseiten-Domain verifizieren](/de/api/status-pages/verify-status-page-domain) - [Statusseiten-Domain aktivieren](/de/api/status-pages/activate-status-page-domain) - [Statusseiten-Modul abfragen](/de/api/status-pages/get-status-page-module) - [Statusseiten-Modul aktivieren](/de/api/status-pages/activate-status-page-module) - [Komponenten auflisten](/de/api/status-pages/list-status-page-components) - [Komponente erstellen](/de/api/status-pages/create-status-page-component) - [Komponente aktualisieren](/de/api/status-pages/update-status-page-component) - [Komponente löschen](/de/api/status-pages/delete-status-page-component) - [Komponenten sortieren](/de/api/status-pages/reorder-status-page-components) - [Komponentengruppen auflisten](/de/api/status-pages/list-status-page-component-groups) - [Komponentengruppe erstellen](/de/api/status-pages/create-status-page-component-group) - [Komponentengruppe aktualisieren](/de/api/status-pages/update-status-page-component-group) - [Komponentengruppe löschen](/de/api/status-pages/delete-status-page-component-group) - [Wartungen auflisten](/de/api/status-pages/list-status-page-maintenance) - [Wartung planen](/de/api/status-pages/create-status-page-maintenance) - [Wartung abfragen](/de/api/status-pages/get-status-page-maintenance) - [Wartung aktualisieren](/de/api/status-pages/update-status-page-maintenance) - [Wartung löschen](/de/api/status-pages/delete-status-page-maintenance) - [Wartung absagen](/de/api/status-pages/cancel-status-page-maintenance) - [Wartung beenden](/de/api/status-pages/complete-status-page-maintenance) - [Wartungs-Update veröffentlichen](/de/api/status-pages/post-status-page-maintenance-update) - [Statusseiten-Vorlagen auflisten](/de/api/status-pages/list-status-page-templates) - [Statusseiten-Vorlage erstellen](/de/api/status-pages/create-status-page-template) - [Statusseiten-Vorlage abfragen](/de/api/status-pages/get-status-page-template) - [Statusseiten-Vorlage aktualisieren](/de/api/status-pages/update-status-page-template) - [Statusseiten-Vorlage löschen](/de/api/status-pages/delete-status-page-template) ## Kunde, Komponenten und Gruppen Eine Statusseite gehört entweder zu einem Kunden (`customerId`) oder, ohne Kunde (`customerId: null`), zur ganzen Organisation. Eine Seite ohne Kunde sehen und verwalten nur organisationsweite Rollen und API-Token: kundengebundene Nutzer und Token bekommen sie nicht in Listen und erhalten auf ihren Komponenten- und Gruppen-Endpunkten `403`. Was eine Seite zeigt: - **Komponenten**: ausdrückliche Zeilen, jeweils ein Monitor (`sourceKind: monitor`) oder ein von Hand gepflegter Eintrag (`sourceKind: m…
### Statusseiten-Domain aktivieren
URL: https://docs.uptimeify.io/de/api/status-pages/activate-status-page-domain
Description: Aktiviert eine verifizierte eigene Domain für eine Statusseite. Org-weit nur Admin, kundengebunden nach der Eigentumsklasse der Seite.
Summary: `POST /api/status-pages/domains/activate` **Zugriff:** Organisationsweite Aufrufer brauchen die Rolle `admin` (ein organisationsweites `editor` oder `readonly` bekommt `403 forbidden`). Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens folgen der Eigentumsklasse der Seite, an der die Domain hängt: erlaubt auf `self_service`-Seiten, auf `managed`-Seiten nur mit der Ausnahme `canEditManaged` des Kunden, sonst `403` mit `data.code: managed_by_organization`. Eine Domain ohne Statusseite gibt es für einen kundengebundenen Aufrufer nicht: `404` (`domainNotFound`). ## Request-Body | Feld | Typ | Pflicht | Standard | Beschreibung | |------|-----|---------|----------|--------------| | `domainId` | number | Ja | - | Die ID der verifizierten Domain, die aktiviert werden soll | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/status-pages/domains/activate" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "domainId": 42 }' ``` ## Antwort ```json { "activated": true, "domain": { "id": 42, "hostname": "status.deinkunde.com", "status": "active", "role": "status_page", "isPrimary": false, "verificationToken": "abc123-def456-ghi789", "verifiedAt": "2026-05-01T12:00:00.000Z", "lastVerificationError": null, "lastVerificationErrorAt": null, "createdAt": "2026-05-01T11:00:00.000Z", "updatedAt": "2026-05-01T12:30:00.000Z" } } ``` ## Häufige Fehler - `401 Unauthorized`, wenn nicht authentifiziert - `403 Forbidden`, wenn du organisationsweit ohne die Rolle Admin aufrufst - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und die Seite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `404 Not Found` (`domainNotFound`), wenn du kundengebunden aufrufst und die Domain an keiner Statusseite hängt - `400 Bad Request`, wenn die Domain noch nicht verifiziert ist - `409 Conflict` (`domainAlreadyClaimed`), wenn eine andere Organisation diesen Hostnamen inzwischen verifiziert oder aktiviert hat. Wer das ist, wird nicht genannt.
### Statusseiten-Modul aktivieren
URL: https://docs.uptimeify.io/de/api/status-pages/activate-status-page-module
Description: Schaltet das Statusseiten-Modul für deine Organisation ein. Idempotent.
Summary: `POST /api/status-pages/module/activate` Der einzige Weg, das Statusseiten-Modul einzuschalten. Kein Request-Body. Ein zweiter Aufruf bei schon eingeschaltetem Modul ändert nichts und antwortet mit `alreadyEnabled: true`. Die Aktivierung steht im Audit-Protokoll der Organisation. Einen Endpunkt zum Ausschalten gibt es nicht. ## Gesperrte Organisationen Statusseiten sind kostenlos und bleiben verfügbar, wenn die Abrechnung ein Konto sperrt. Eine aus Abrechnungsgründen gesperrte Organisation (Testphase abgelaufen, Testphase oder Abo gekündigt, offene Rechnung) darf diesen Endpunkt weiter aufrufen. Er schaltet das Modul ein und macht die Organisation wieder `active`, als reine Statusseiten-Organisation: Statusseiten, eigene Domains und Abo-Benachrichtigungen laufen, Monitoring und Incident Management bleiben pausiert, die geplante Datenlöschung entfällt. Wer wieder ein Paket bucht, bekommt das Monitoring zurück. Eine vom Uptimeify-Support gesperrte Organisation bleibt gesperrt und bekommt `423`. ## Zugriff Nur Organisations-`admin`. Kundengebundene API-Token werden abgewiesen. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/status-pages/module/activate" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort `200 OK` ```json { "enabled": true, "activatedAt": "2026-10-27T09:00:00.000Z", "alreadyEnabled": false } ``` ## Häufige Fehler - `400 Bad Request` (`userMustBelongToOrg`), wenn dein Konto zu keiner Organisation gehört - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn du kein Organisations-Admin bist - `403 Forbidden` (`customerScopedTokenForbidden`) bei einem kundengebundenen API-Token - `423 Locked` (`organizationSuspended`), wenn der Uptimeify-Support die Organisation gesperrt hat oder ihre Datenlöschung schon läuft
### Eigene Domain hinzufügen
URL: https://docs.uptimeify.io/de/api/status-pages/add-status-page-domain
Description: Fügt einer bestehenden Statusseite einen eigenen Hostnamen hinzu und gibt den für die Verifizierung nötigen DNS-TXT-Eintrag zurück. Org-weit Admin oder Editor, kundengebunden nach der Eigentumsklasse der Seite.
Summary: `POST /api/status-pages/domains` **Zugriff:** Organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor` (organisationsweites `readonly` bleibt lesend). Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens folgen stattdessen der Eigentumsklasse der Seite: erlaubt auf `self_service`-Seiten, auf `managed`-Seiten nur mit der Ausnahme `canEditManaged` des Kunden, sonst `403` mit `data.code: managed_by_organization`. ## Request-Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `statusPageId` | number \| string | Ja | Die ID oder publicId der Statusseite | | `hostname` | string | Ja | Der eigene Hostname (z.B. `status.deinkunde.com`) | ## Beispiel (cURL) ```bash curl -X POST "$BASE_URL/api/status-pages/domains" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "statusPageId": 1, "hostname": "status.deinkunde.com" }' ``` ## Antwort ```json { "domain": { "id": 42, "hostname": "status.deinkunde.com", "status": "pending", "role": "status_page", "verificationToken": "abc123-def456-ghi789", "verifiedAt": null, "lastVerificationError": null, "lastVerificationErrorAt": null, "createdAt": "2026-05-01T11:00:00.000Z", "updatedAt": "2026-05-01T11:00:00.000Z", "statusPageId": 1 }, "dns": { "txtName": "_verify-status.status.deinkunde.com", "txtValue": "abc123-def456-ghi789" } } ``` Dieselbe Form wie [Domain abfragen](/de/api/status-pages/get-status-page-domain): `domain.statusPageId` ist die numerische ID der Statusseite, der die Domain hinzugefügt wurde, auch wenn die Anfrage sie per publicId genannt hat. ## Häufige Fehler - `401 Unauthorized`, wenn nicht authentifiziert - `403 Forbidden`, wenn du organisationsweit ohne die Rolle Admin oder Editor aufrufst - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und die Seite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `404 Not found`, wenn die Statusseite nicht existiert - `409 Conflict`, wenn die Statusseite schon eine Domain hat (`domainAlreadyExists`) oder deine Organisation bereits einen Eintrag für diesen Hostnamen hat (`hostnameAlreadyInUse`) - `400 Bad Request`, wenn der Hostname ungültig (`invalidHostname`) oder reserviert ist (`hostnameReserved`: die Plattform-Hosts und alles unterhalb von `uptimeify.io`) Ein Hostname ist erst belegt, wenn er **verifiziert** oder **aktiv** ist. Die unverifizierte Anfrage einer anderen Organisation blockiert deine nicht; entschieden wird beim [Verifizieren](/de/api/status-pages/verify-status-page-domain). Eine `pending`-Anfrage, die nie verifiziert wird, wird nach 7 Tagen entfernt.
### Wartung absagen
URL: https://docs.uptimeify.io/de/api/status-pages/cancel-status-page-maintenance
Description: Sagt eine bevorstehende Wartung ab und informiert die Abonnenten.
Summary: `POST /api/status-pages/maintenances/{id}/cancel` Sagt eine bevorstehende Wartung (`state: scheduled`) ab. Sie verschwindet von der öffentlichen Seite; Abonnenten, die die Ankündigung bekommen haben (`notifyOnSchedule`), erhalten `maintenance_cancelled`, Erinnerung und Beginn gehen nicht mehr raus. Eine laufende Wartung beendest du mit [Wartung beenden](/de/api/status-pages/complete-status-page-maintenance). ## Zugriff Organisationsweite Aufrufer: `admin` und `editor` (organisationsweites `readonly` bleibt lesend). Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens folgen der Eigentumsklasse jeder beteiligten Seite (bei einer neuen Wartung jede Seite in `statusPageIds`, sonst jede Seite, mit der die Wartung verknüpft ist): erlaubt auf `self_service`-Seiten, auf `managed`-Seiten nur mit der Ausnahme `canEditManaged` des Kunden, sonst `403` mit `data.code: managed_by_organization`. Eine Wartung ohne Statusseite folgt weiter der Rolle (`admin` oder `editor`). Ein kundengebundener Nutzer oder API-Token erreicht nur Wartungen, deren Statusseiten alle zu einem Kunden in seinem Bereich gehören; eine Seite ohne Kunde (`customerId: null`) ist Org-weiten Rollen vorbehalten. Eine Wartung einer anderen Organisation antwortet `404` (`statusPageMaintenanceNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Protokoll der Organisation. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/status-pages/maintenances/12/cancel" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `200 OK` mit der Wartung, jetzt `state: cancelled` und mit `cancelledAt`. ## Häufige Fehler - `400 Bad Request` (`invalidIdentifier`), wenn eine ID weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und eine beteiligte Statusseite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageMaintenanceNotFound`), wenn die Wartung nicht existiert oder zu einer anderen Organisation gehört - `409 Conflict` (`statusPageMaintenanceClosed`), wenn die Wartung nicht bevorsteht (läuft, abgeschlossen oder schon abgesagt)
### Wartung beenden
URL: https://docs.uptimeify.io/de/api/status-pages/complete-status-page-maintenance
Description: Beendet eine laufende Wartung sofort.
Summary: `POST /api/status-pages/maintenances/{id}/complete` Beendet eine laufende Wartung (`state: in_progress`) sofort: `scheduledUntil` wird die aktuelle Zeit. Abonnenten bekommen `maintenance_completed` (mit `notifyOnComplete`) innerhalb einer Minute, wie bei einem geplanten Ende. ## Zugriff Organisationsweite Aufrufer: `admin` und `editor` (organisationsweites `readonly` bleibt lesend). Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens folgen der Eigentumsklasse jeder beteiligten Seite (bei einer neuen Wartung jede Seite in `statusPageIds`, sonst jede Seite, mit der die Wartung verknüpft ist): erlaubt auf `self_service`-Seiten, auf `managed`-Seiten nur mit der Ausnahme `canEditManaged` des Kunden, sonst `403` mit `data.code: managed_by_organization`. Eine Wartung ohne Statusseite folgt weiter der Rolle (`admin` oder `editor`). Ein kundengebundener Nutzer oder API-Token erreicht nur Wartungen, deren Statusseiten alle zu einem Kunden in seinem Bereich gehören; eine Seite ohne Kunde (`customerId: null`) ist Org-weiten Rollen vorbehalten. Eine Wartung einer anderen Organisation antwortet `404` (`statusPageMaintenanceNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Protokoll der Organisation. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/status-pages/maintenances/12/complete" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `200 OK` mit der Wartung, jetzt `state: completed`. ## Häufige Fehler - `400 Bad Request` (`invalidIdentifier`), wenn eine ID weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und eine beteiligte Statusseite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageMaintenanceNotFound`), wenn die Wartung nicht existiert oder zu einer anderen Organisation gehört - `409 Conflict` (`statusPageMaintenanceClosed`), wenn die Wartung nicht läuft
### Statusseite erstellen
URL: https://docs.uptimeify.io/de/api/status-pages/create-status-page
Description: Erstellt eine neue Statusseite. Erfordert die Rolle `admin` oder `editor`; kundengebundene Nutzer und Tokens (auch `readonly`) legen selbstverwaltete Seiten ihrer Kunden an.
Summary: `POST /api/status-pages` ## Request-Body | Feld | Typ | Pflicht | Standard | Beschreibung | |------|-----|---------|----------|--------------| | `customerId` | number | Nein | - | Kunden-ID (muss zu deiner Organisation gehören). Weglassen für eine Seite der ganzen Organisation, ohne Kunde; die dürfen nur organisationsweite Rollen und API-Token anlegen. | | `includeCustomerMonitors` | boolean | Nein | `false` | Jeden Monitor des Kunden, außer denen in `hiddenMonitors`, automatisch hinter den ausdrücklichen Komponenten anzeigen, auch später angelegte Monitore. Ohne Kunde wirkungslos. Bis 28. Oktober 2026 war der Standard `true` für eine Seite mit Kunde; wer das beibehalten will, sendet `true`. | | `managementType` | string | Nein | `managed` | `managed` oder `self_service`, wie bei Monitoren. Wählen dürfen nur Organisations-Admins; kundengebundene Nutzer und Tokens legen immer `self_service`-Seiten an. | | `name` | string | Ja | - | Anzeigename (1-120 Zeichen). Slug wird aus dem Namen generiert. | | `slug` | string | Nein | auto | URL-Slug (1-120 Zeichen, auto-normalisiert auf Kleinbuchstaben-Bindestriche) | | `description` | string | Nein | null | Beschreibung (max. 1000 Zeichen) | | `visibility` | string | Nein | `public` | `public`, `customer_members_only`, `password_protected` (jeder mit dem Seitenpasswort, siehe unten) oder `sso_members_only` (wie `customer_members_only`, zusätzlich muss die Sitzung über das Single Sign-on deiner Organisation entstanden sein) | | `accessPassword` | string | Nein | - | Seitenpasswort, 8-200 Zeichen. Pflicht bei `visibility: password_protected`. Nur schreibbar: gespeichert als bcrypt-Hash und nie zurückgegeben; Antworten zu Statusseiten zeigen nur `hasPassword` und `accessPasswordSetAt`. | | `ipAllowlist` | array | Nein | `[]` | IPv4-/IPv6-Adressen oder CIDR-Bereiche (z. B. `203.0.113.0/24`, `2001:db8::/32`), höchstens 50. Nur Besucher aus diesen Netzen sehen die Seite, zusätzlich zur `visibility`. Gespeichert normalisiert als `addr/prefix` (`203.0.113.7` wird `203.0.113.7/32`), ohne Doppelte. `[]` = keine IP-Beschränkung. | | `isPublished` | boolean | Nein | true | Ob die Seite öffentlich sichtbar ist | | `smsSubscriptionsEnabled` | boolean | Nein | `false` | SMS-Abos auf der öffentlichen Seite anbieten. Jede SMS geht vom SMS-Kontingent deiner Organisation ab und stoppt am SMS-Deckel. Braucht SMS-Kontingent (sonst `403 smsQuotaRequired`). Besucher sehen die Option nur, solange die Plattform SMS senden kann und deine Organisation SMS-Kontingent hat. | | `pushSubscriptionsEnabled` | boolean | Nein | `false` | Browser-Push-Abos auf der öffentlichen Seite anbieten. Besucher sehen die Option nur, solange die Plattform VAPID-Schlüssel hat. | | `customDomainHostname` | string | Nein | null | Eigene Domain (3-253 Zeichen). Erzeugt einen ausstehenden DNS-Verifizierungseintrag. | | `hiddenMonitors` | array | Nein | `[]` | Monitore, die auf dieser Statusseite ausgeblendet werden. Jeder Eintrag ist `{ "type": "http"\|"dns"\|"icmp"\|"smtp"\|"ssh"\|"ftp"\|"imap_pop", "id": }`. Leer lassen oder `[]` senden, um alle Monitore anzuzeigen (Standard). Später hinzugefügte Monitore erscheinen automatisch. Maximal 500 Einträge. | **Private Seiten (seit 28. Oktober 2026).** - `password_protected`: Wer das Seitenpasswort kennt, sieht die Seite. Besucher schalten sie über den [verify-password-Endpunkt](/de/api/status-pages/get-public-status-page) frei, der ein Zugriffs-Cookie für 30 Tage setzt; ohne dieses Cookie antwortet die öffentliche Seite `401 passwordRequired`. Eine neue Seite mit `password_protected` ohne `accessPassword` wird mit `400 passwordRequired` abgewiesen. - `sso_members_only`: wie `customer_members_only` (angemeldete Mitglieder des Kunden, bei einer Seite ohne Kunde der Organisation), zusätzlich muss die Sitzung über das Single Sign-on deiner Organisation (OIDC oder SAML) entstanden sein. Ohne Anmeldung oder mit einer Anmeldung ohne SSO antwortet die öffentliche Seite `401 ssoRequired`.…
### Komponente erstellen
URL: https://docs.uptimeify.io/de/api/status-pages/create-status-page-component
Description: Fügt einer Statusseite einen Monitor, einen Drittanbieter oder eine von Hand gepflegte Komponente hinzu.
Summary: `POST /api/status-pages/{id}/components` ## Zugriff Organisations-`admin` und `editor`; kundengebundene Nutzer (auch `readonly`) und Tokens nur auf `self_service`-Seiten ihrer Kunden, oder auf `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein kundengebundener Nutzer oder API-Token erreicht nur Seiten eines Kunden in seinem Bereich; eine Seite ohne Kunde (`customerId: null`) beantwortet ihm `403` (`forbidden`). Eine Seite einer anderen Organisation antwortet `404` (`statusPageNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Protokoll der Organisation. ## Request-Body | Feld | Typ | Pflicht | Standard | Beschreibung | |------|-----|---------|----------|--------------| | `sourceKind` | string | Ja | - | `monitor` (Zustand kommt von einem Monitor), `dependency` (Zustand kommt von einem Drittanbieter, den wir beobachten) oder `manual` (du setzt den Zustand). | | `monitorType` | string | Bei `monitor` | - | `http`, `dns`, `icmp`, `smtp`, `ssh`, `tcp`, `ftp` oder `imap_pop`. Bei `manual` nicht erlaubt. | | `monitorId` | number | Bei `monitor` | - | Numerische Monitor-ID. Seite mit Kunde: ein Monitor dieses Kunden. Seite ohne Kunde: jeder Monitor deiner Organisation. Bei `manual` nicht erlaubt. | | `dependencySlug` | string | Bei `dependency` | - | Slug eines aktiven Anbieters aus `GET /api/public/dependencies`. Bei den anderen Arten nicht erlaubt. | | `manualStatus` | string | Nein | `operational` | Nur `manual`: `operational`, `degraded`, `partial_outage`, `major_outage` oder `maintenance`. | | `name` | string | Bei `manual` | Monitor- oder Anbietername | Anzeigename (1-120 Zeichen). | | `description` | string\|null | Nein | `null` | Max. 1000 Zeichen. | | `groupId` | number\|string\|null | Nein | `null` | ID oder `publicId` einer Gruppe dieser Seite. | | `sort` | number | Nein | hinter der letzten Komponente | Position, 0-100000. | | `showUptime` | boolean | Nein | `true` | Verfügbarkeitsbalken dieser Komponente anzeigen. | Ein Monitor kann auf derselben Seite nur einmal Komponente sein. `hiddenMonitors` blendet nie eine ausdrückliche Komponente aus. Wird ein Monitor gelöscht, verschwinden seine Komponenten automatisch von jeder Statusseite. Eine `dependency`-Komponente zeigt den Gesamtstatus, den wir für diesen Anbieter in unserer öffentlichen Abhängigkeits-Überwachung veröffentlichen: `operational`, `degraded`, `partial_outage`, `major_outage`, `maintenance` oder `unknown`, solange wir den Anbieter nicht sehen (als Warnung gezeigt, zählt aber nicht zum Gesamtzustand der Seite). Ein offener, mit der Komponente verknüpfter Vorfall hebt ihren Zustand an. Ein Anbieter kann auf derselben Seite nur einmal Komponente sein; eine Verfügbarkeitsleiste gibt es nicht. Ändert sich der Status des Anbieters, werden die Abonnenten der Seite (oder dieser Komponente) benachrichtigt wie bei einem Monitor-Vorfall. Weder Monitor noch Kunde sind nötig. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/status-pages/1/components" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "sourceKind": "monitor", "monitorType": "http", "monitorId": 101, "groupId": 3 }' ``` Eine manuelle Komponente: ```bash curl -X POST "$BASE_URL/api/status-pages/1/components" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "sourceKind": "manual", "name": "Payment provider", "description": "Card payments at checkout" }' ``` Ein Drittanbieter: ```bash curl -X POST "$BASE_URL/api/status-pages/1/components" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "sourceKind": "dependency", "dependencySlug": "stripe" }' ``` ## Antwort `201 Created` mit der neuen Komponente: ```json { "id": 7, "publicId": "0b6f3c1e-8d2a-4f5b-9c7e-1a2b3c4d5e6f", "statusPageId": 1, "groupId": 3, "sort": 0, "name": "Main Site", "description": null, "s…
### Komponentengruppe erstellen
URL: https://docs.uptimeify.io/de/api/status-pages/create-status-page-component-group
Description: Fügt einer Statusseite eine Komponentengruppe hinzu.
Summary: `POST /api/status-pages/{id}/groups` ## Zugriff Organisations-`admin` und `editor`; kundengebundene Nutzer (auch `readonly`) und Tokens nur auf `self_service`-Seiten ihrer Kunden, oder auf `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein kundengebundener Nutzer oder API-Token erreicht nur Seiten eines Kunden in seinem Bereich; eine Seite ohne Kunde (`customerId: null`) beantwortet ihm `403` (`forbidden`). Eine Seite einer anderen Organisation antwortet `404` (`statusPageNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Protokoll der Organisation. ## Request-Body | Feld | Typ | Pflicht | Standard | Beschreibung | |------|-----|---------|----------|--------------| | `name` | string | Ja | - | Überschrift der Gruppe (1-120 Zeichen). | | `sort` | number | Nein | hinter der letzten Gruppe | Position, 0-100000. | | `collapsed` | boolean | Nein | `false` | Auf der öffentlichen Seite zugeklappt starten. | Komponenten kommen über `groupId` in die Gruppe, bei [Komponente erstellen](/de/api/status-pages/create-status-page-component), [Komponente aktualisieren](/de/api/status-pages/update-status-page-component) oder [Komponenten sortieren](/de/api/status-pages/reorder-status-page-components). ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/status-pages/1/groups" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "Core services" }' ``` ## Antwort `201 Created` mit der neuen Gruppe: ```json { "id": 3, "publicId": "9e8d7c6b-5a4f-4e3d-8c2b-1a0f9e8d7c6b", "statusPageId": 1, "name": "Core services", "sort": 0, "collapsed": false, "createdAt": "2026-10-27T08:55:00.000Z", "updatedAt": "2026-10-27T08:55:00.000Z" } ``` ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`), wenn `name` fehlt oder ein Feld ungültig ist - `400 Bad Request` (`invalidIdentifier`), wenn eine ID im Pfad weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageNotFound`), wenn die Statusseite nicht existiert oder zu einer anderen Organisation gehört - `409 Conflict` (`statusPageLimitReached`, mit `data.max`), wenn die Seite schon 500 Gruppen hat
### Wartung planen
URL: https://docs.uptimeify.io/de/api/status-pages/create-status-page-maintenance
Description: Plant eine Wartung für Statusseiten und Komponenten, mit Ankündigung, Erinnerung, Beginn- und Ende-Nachricht.
Summary: `POST /api/status-pages/maintenances` `state` kommt aus der Uhr und wird nie gespeichert: `scheduled` vor `scheduledFor`, `in_progress` bis `scheduledUntil`, danach `completed`; `cancelled`, sobald abgesagt. Die Wartung beginnt und endet von selbst, dafür ist kein Aufruf nötig. Solange sie `in_progress` ist, zeigen ihre Komponenten auf der öffentlichen Seite `maintenance` (ein schlimmerer Zustand wie ein Ausfall bleibt); eine Wartung ohne Komponenten zeigt die ganze Seite in Wartung. Abonnenten der Statusseite (oder einer betroffenen Komponente) bekommen über ihren Kanal (E-Mail, Webhook, Slack, Teams) die Ereignisse `maintenance_scheduled` (beim Speichern und erneut, wenn ein bevorstehender Beginn verschoben wird), `maintenance_reminder`, `maintenance_started`, `maintenance_completed`, `maintenance_update` und `maintenance_cancelled`. Die Schalter unten bestimmen, welche davon verschickt werden; jedes Ereignis steht außerdem im RSS- und Atom-Feed der Seite. Der Versand beachtet die Abo-Verzögerung der Seite und wird zur Sendezeit entschieden: eine verschobene oder abgesagte Wartung verschickt ihre überholten Nachrichten nicht. Eine Wartung hier informiert die Besucher deiner Statusseiten. Sie pausiert keine Monitor-Alarme: dafür legst du im Monitoring ein [Wartungsfenster](/de/api/maintenance-windows) an, das auch auf Seiten mit diesen Monitoren erscheint. ## Zugriff Organisationsweite Aufrufer: `admin` und `editor` (organisationsweites `readonly` bleibt lesend). Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens folgen der Eigentumsklasse jeder beteiligten Seite (bei einer neuen Wartung jede Seite in `statusPageIds`, sonst jede Seite, mit der die Wartung verknüpft ist): erlaubt auf `self_service`-Seiten, auf `managed`-Seiten nur mit der Ausnahme `canEditManaged` des Kunden, sonst `403` mit `data.code: managed_by_organization`. Eine Wartung ohne Statusseite folgt weiter der Rolle (`admin` oder `editor`). Ein kundengebundener Nutzer oder API-Token erreicht nur Wartungen, deren Statusseiten alle zu einem Kunden in seinem Bereich gehören; eine Seite ohne Kunde (`customerId: null`) ist Org-weiten Rollen vorbehalten. Eine Wartung einer anderen Organisation antwortet `404` (`statusPageMaintenanceNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Protokoll der Organisation. ## Request-Body | Feld | Typ | Pflicht | Standard | Beschreibung | |------|-----|---------|----------|--------------| | `title` | string | Ja | - | Steht auf der Seite und in jeder Nachricht (1-200 Zeichen). | | `description` | string\|null | Nein | `null` | Was passiert und was Besucher merken (max. 5000 Zeichen). | | `scheduledFor` | string | Ja | - | Beginn, ISO 8601 mit Versatz (`Z` oder `+01:00`); gespeichert und zurückgegeben in UTC. | | `scheduledUntil` | string | Ja | - | Ende, nach `scheduledFor`. | | `statusPageIds` | array | Ja | - | Statusseiten (ID oder `publicId`, 1-10), die die Wartung zeigen. | | `componentIds` | array | Nein | `[]` | Betroffene Komponenten (ID oder `publicId`, bis 500) jeder Quelle: manuell, Monitor oder Drittanbieter. Jede muss zu einer der `statusPageIds` gehören. Eine Seite ohne genannte Komponente zeigt die Wartung seitenweit. | | `notifyOnSchedule` | boolean | Nein | `true` | Beim Speichern an Abonnenten ankündigen, und erneut, wenn ein bevorstehender Beginn verschoben wird. | | `reminderMinutesBefore` | number\|null | Nein | `null` | Abonnenten so viele Minuten (5-10080) vor dem Beginn erinnern; `null` schickt keine Erinnerung. | | `notifyOnStart` | boolean | Nein | `false` | Abonnenten bei Beginn benachrichtigen. | | `notifyOnComplete` | boolean | Nein | `true` | Abonnenten bei Ende benachrichtigen. | Unbekannte Felder werden abgewiesen. Eine Wartung, die ganz in der Vergangenheit liegt, wird ohne Ankündigung gespeichert. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/status-pag…
### Statusseiten-Vorlage erstellen
URL: https://docs.uptimeify.io/de/api/status-pages/create-status-page-template
Description: Legt eine Vorfall- oder Update-Vorlage an.
Summary: `POST /api/status-pages/templates` Eine Vorlage füllt das Formular für einen neuen öffentlichen Vorfall (`kind: incident`) oder für ein Update zu einem laufenden (`kind: update`) vor. Sie veröffentlicht selbst nichts; Vorfälle entstehen weiter mit [Vorfall anlegen](/de/api/monitoring/create-manual-incident). ## Zugriff Organisations-`admin` und `editor` mit uneingeschränktem Umfang: ein kundengebundener Login oder API-Token bekommt `403` (`customerScopedTokenForbidden`), weil eine Vorlage der ganzen Organisation gehört. Eine Vorlage einer anderen Organisation antwortet `404` (`statusPageTemplateNotFound`). Pfad-IDs nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Log der Organisation. ## Request-Body | Feld | Typ | Pflicht | Vorgabe | Beschreibung | |------|-----|---------|---------|--------------| | `kind` | string | Ja | - | `incident` (neuer Vorfall) oder `update` (Update zu einem laufenden). Später nicht änderbar. | | `name` | string | Ja | - | Steht in der Vorlagen-Auswahl, 1 bis 120 Zeichen. | | `title` | string oder null | Nein | `null` | Nur Vorfall-Vorlagen: der Titel des Vorfalls, bis 200 Zeichen. | | `body` | string | Ja | - | Der Text des Updates, 1 bis 5.000 Zeichen. | | `updateStatus` | string | Nein | `investigating` | Phase, mit der das Update beginnt: `investigating`, `identified`, `monitoring` oder `resolved`. | | `severity` | string oder null | Nein | `null` | Nur Vorfall-Vorlagen: `minor`, `major`, `critical` oder `maintenance`. | | `impact` | string oder null | Nein | `null` | Nur Vorfall-Vorlagen: `degraded`, `partial_outage`, `major_outage` oder `maintenance`. | | `statusPageIds` | array oder null | Nein | `null` | Nur Vorfall-Vorlagen: vorausgewählte Statusseiten (ID oder publicId), höchstens 10. Jede muss zu deiner Organisation gehören. | | `componentIds` | array oder null | Nein | `null` | Nur Vorfall-Vorlagen: Komponenten (ID oder publicId), höchstens 100; jede muss zu einer der `statusPageIds` gehören. | Eine Update-Vorlage (`kind: update`) nimmt nur `name`, `body` und `updateStatus`; die Felder für Vorfall-Vorlagen bleiben `null`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/status-pages/templates" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "kind": "incident", "name": "Payment provider down", "title": "Card payments failing", "body": "We are looking into failed card payments.", "severity": "major", "statusPageIds": [2], "componentIds": [8] }' ``` ## Antwort `201 Created` mit der neuen Vorlage: ```json { "id": 4, "publicId": "3f6c2a1b-8d4e-4b7a-9c1d-2e3f4a5b6c7d", "kind": "incident", "name": "Payment provider down", "title": "Card payments failing", "body": "We are looking into failed card payments.", "updateStatus": "investigating", "severity": "major", "impact": "partial_outage", "statusPageIds": [2], "componentIds": [8], "createdAt": "2026-10-27T09:00:00.000Z", "updatedAt": "2026-10-27T09:00:00.000Z" } ``` ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`), wenn ein Feld ungültig ist oder eine Update-Vorlage ein Feld nur für Vorfall-Vorlagen bekommt - `400 Bad Request` (`statusPageIdsRequired`), wenn `componentIds` ohne `statusPageIds` kommt - `400 Bad Request` (`statusPageComponentNotOnPage`), wenn eine Komponente zu einer Seite gehört, die nicht in `statusPageIds` steht - `404 Not Found` (`statusPageNotFound`, `statusPageComponentNotFound`), wenn es Seite oder Komponente in deiner Organisation nicht gibt - `409 Conflict` (`statusPageLimitReached`, mit `data.max`), wenn die Organisation schon 200 Vorlagen hat - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `403 Forbidden` (`forbidden`), wenn deine Rolle nicht schreiben darf - `403 Forbidden` (`customerScopedTokenForbidden`) für einen kundengebundenen Login oder Token
### Statusseite löschen
URL: https://docs.uptimeify.io/de/api/status-pages/delete-status-page
Description: Löscht eine Statusseite endgültig. Erfordert die Rolle `admin` oder `editor`.
Summary: `DELETE /api/status-pages/:id` ## Beispiel (cURL) ```bash curl -X DELETE "$BASE_URL/api/status-pages/1" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort ```json { "deleted": true, "id": 1 } ``` ## Häufige Fehler - `401 Unauthorized`, wenn nicht authentifiziert - `403 Forbidden` (`forbidden`), wenn die Rolle weder `admin` noch `editor` ist (z. B. `readonly`, Global Supporter) - `403 Forbidden` (`managed_by_organization`), wenn ein kundengebundenes Token eine `managed`-Seite ohne die Ausnahme `canEditManaged` des Kunden löscht - `404 Not found`, wenn die Statusseite nicht existiert
### Komponente löschen
URL: https://docs.uptimeify.io/de/api/status-pages/delete-status-page-component
Description: Entfernt eine Komponente von einer Statusseite.
Summary: `DELETE /api/status-pages/{id}/components/{componentId}` Entfernt die Komponente von der Seite. Der Monitor selbst bleibt unberührt. Schließt die Seite die Monitore des Kunden automatisch ein (`includeCustomerMonitors`), erscheint ein Monitor dieses Kunden dort auch nach dem Löschen seiner Komponente, sofern er nicht in `hiddenMonitors` steht. ## Zugriff Organisations-`admin` und `editor`; kundengebundene Nutzer (auch `readonly`) und Tokens nur auf `self_service`-Seiten ihrer Kunden, oder auf `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein kundengebundener Nutzer oder API-Token erreicht nur Seiten eines Kunden in seinem Bereich; eine Seite ohne Kunde (`customerId: null`) beantwortet ihm `403` (`forbidden`). Eine Seite einer anderen Organisation antwortet `404` (`statusPageNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Protokoll der Organisation. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X DELETE "$BASE_URL/api/status-pages/1/components/8" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `204 No Content` ohne Body. ## Häufige Fehler - `400 Bad Request` (`invalidIdentifier`), wenn eine ID im Pfad weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageNotFound`), wenn die Statusseite nicht existiert oder zu einer anderen Organisation gehört - `404 Not Found` (`statusPageComponentNotFound`), wenn es die Komponente auf dieser Seite nicht gibt
### Komponentengruppe löschen
URL: https://docs.uptimeify.io/de/api/status-pages/delete-status-page-component-group
Description: Löscht eine Komponentengruppe; ihre Komponenten bleiben ohne Gruppe auf der Seite.
Summary: `DELETE /api/status-pages/{id}/groups/{groupId}` Löscht nur die Gruppe. Ihre Komponenten bleiben auf der Seite, ohne Gruppe (`groupId: null`). ## Zugriff Organisations-`admin` und `editor`; kundengebundene Nutzer (auch `readonly`) und Tokens nur auf `self_service`-Seiten ihrer Kunden, oder auf `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein kundengebundener Nutzer oder API-Token erreicht nur Seiten eines Kunden in seinem Bereich; eine Seite ohne Kunde (`customerId: null`) beantwortet ihm `403` (`forbidden`). Eine Seite einer anderen Organisation antwortet `404` (`statusPageNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Protokoll der Organisation. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X DELETE "$BASE_URL/api/status-pages/1/groups/3" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `204 No Content` ohne Body. ## Häufige Fehler - `400 Bad Request` (`invalidIdentifier`), wenn eine ID im Pfad weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageNotFound`), wenn die Statusseite nicht existiert oder zu einer anderen Organisation gehört - `404 Not Found` (`statusPageComponentGroupNotFound`), wenn es die Gruppe auf dieser Seite nicht gibt
### Wartung löschen
URL: https://docs.uptimeify.io/de/api/status-pages/delete-status-page-maintenance
Description: Löscht eine Wartung von allen Seiten und aus dem Feed.
Summary: `DELETE /api/status-pages/maintenances/{id}` Löscht die Wartung mit ihren Updates und ihren Abo-Ereignissen: sie verschwindet von allen Seiten und aus dem Feed, noch nicht verschickte Nachrichten gehen nicht mehr raus. Wer sie in der Historie behalten will, sagt sie ab: [Wartung absagen](/de/api/status-pages/cancel-status-page-maintenance). ## Zugriff Organisationsweite Aufrufer: `admin` und `editor` (organisationsweites `readonly` bleibt lesend). Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens folgen der Eigentumsklasse jeder beteiligten Seite (bei einer neuen Wartung jede Seite in `statusPageIds`, sonst jede Seite, mit der die Wartung verknüpft ist): erlaubt auf `self_service`-Seiten, auf `managed`-Seiten nur mit der Ausnahme `canEditManaged` des Kunden, sonst `403` mit `data.code: managed_by_organization`. Eine Wartung ohne Statusseite folgt weiter der Rolle (`admin` oder `editor`). Ein kundengebundener Nutzer oder API-Token erreicht nur Wartungen, deren Statusseiten alle zu einem Kunden in seinem Bereich gehören; eine Seite ohne Kunde (`customerId: null`) ist Org-weiten Rollen vorbehalten. Eine Wartung einer anderen Organisation antwortet `404` (`statusPageMaintenanceNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Protokoll der Organisation. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X DELETE "$BASE_URL/api/status-pages/maintenances/12" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `204 No Content` ohne Body. Ein zweiter Aufruf antwortet `404`. ## Häufige Fehler - `400 Bad Request` (`invalidIdentifier`), wenn eine ID weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und eine beteiligte Statusseite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageMaintenanceNotFound`), wenn die Wartung nicht existiert oder zu einer anderen Organisation gehört
### Statusseiten-Vorlage löschen
URL: https://docs.uptimeify.io/de/api/status-pages/delete-status-page-template
Description: Löscht eine Vorlage. Daraus entstandene Vorfälle bleiben, wie sie sind.
Summary: `DELETE /api/status-pages/templates/{id}` Eine Vorlage füllt das Formular für einen neuen öffentlichen Vorfall (`kind: incident`) oder für ein Update zu einem laufenden (`kind: update`) vor. Sie veröffentlicht selbst nichts; Vorfälle entstehen weiter mit [Vorfall anlegen](/de/api/monitoring/create-manual-incident). ## Zugriff Organisations-`admin` und `editor` mit uneingeschränktem Umfang: ein kundengebundener Login oder API-Token bekommt `403` (`customerScopedTokenForbidden`), weil eine Vorlage der ganzen Organisation gehört. Eine Vorlage einer anderen Organisation antwortet `404` (`statusPageTemplateNotFound`). Pfad-IDs nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Log der Organisation. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X DELETE "$BASE_URL/api/status-pages/templates/4" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `204 No Content`, kein Body. Ein zweites DELETE antwortet `404`. ## Häufige Fehler - `400 Bad Request` (`invalidIdentifier`), wenn die ID weder Zahl noch UUID ist - `404 Not Found` (`statusPageTemplateNotFound`), wenn es die Vorlage nicht gibt oder sie einer anderen Organisation gehört - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `403 Forbidden` (`forbidden`), wenn deine Rolle nicht schreiben darf - `403 Forbidden` (`customerScopedTokenForbidden`) für einen kundengebundenen Login oder Token
### Abonnenten einer Statusseite löschen
URL: https://docs.uptimeify.io/de/api/status-pages/delete-subscriber
Description: Löscht einen Abonnenten und seine gespeicherten Einwilligungsnachweise unwiderruflich. Org-weit Admin oder Editor, kundengebunden nach der Eigentumsklasse der Seite.
Summary: `DELETE /api/status-pages/:id/subscribers/:subscriberId` **Zugriff:** Organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor` (organisationsweites `readonly` bleibt lesend). Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens folgen stattdessen der Eigentumsklasse der Seite: erlaubt auf `self_service`-Seiten, auf `managed`-Seiten nur mit der Ausnahme `canEditManaged` des Kunden, sonst `403` mit `data.code: managed_by_organization`. Das ist ein **echtes Löschen (Hard Delete)**, nicht das öffentliche Ein-Klick-Abmelden. Der öffentliche Abmelde-Link behält die Abonnenten-Zeile mit `status: "unsubscribed"` als Nachweis, dass keine weiteren E-Mails mehr verschickt werden dürfen. Dieser Endpunkt beantwortet dagegen Löschanfragen (DSGVO Art. 17) und entfernt die Zeile vollständig, inklusive E-Mail-Adresse, Zeitpunkt der Einwilligung, IP-Adresse und User-Agent. ## Pfad-Parameter | Parameter | Beschreibung | |-----------|-------------| | `id` | Statusseiten-ID oder `publicId` (UUID) | | `subscriberId` | Abonnenten-ID (positive Ganzzahl) | ## Beispiel (cURL) ```bash curl -X DELETE "$BASE_URL/api/status-pages/db58058e-4b58-4d97-a314-3bb8e279a182/subscribers/42" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort ```json { "ok": true } ``` ## Häufige Fehler - `401 Unauthorized`, wenn du nicht authentifiziert bist - `400 User must belong to an organization` (`data.code: userMustBelongToOrg`), wenn sich aus Session oder Token keine Organisation ableiten lässt - `403 Forbidden`, wenn du organisationsweit ohne die Rolle Admin oder Editor aufrufst, oder dein Kunden-Scope diese Statusseite nicht einschließt - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und die Seite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `400 Invalid Status page identifier`, wenn `id` keine gültige numerische ID oder UUID ist (kein `data.code`) - `404 Status page not found`, wenn `id` wohlgeformt ist, aber keine Statusseite dazu existiert (kein `data.code`) - `404 Status page not found` (`data.code: statusPageNotFound`), wenn `id` sich zu einer echten Statusseite auflöst, diese aber zu einer anderen Organisation gehört oder außerhalb deines Kunden-Scopes liegt - `400 Invalid subscriber id` (`data.code: invalidSubscriberId`), wenn `subscriberId` sich nicht als positive Ganzzahl parsen lässt - `404 Subscriber not found` (`data.code: subscriberNotFound`), wenn `subscriberId` nicht existiert oder zu einer anderen Statusseite als `id` gehört `id` wird aufgelöst und geprüft, bevor `subscriberId` überhaupt geparst wird, ein fehlerhaftes `id` ist also immer der Fehler, den du zuerst siehst.
### Abonnenten aller Statusseiten exportieren
URL: https://docs.uptimeify.io/de/api/status-pages/export-all-subscribers
Description: Lädt die Abonnenten der ausgewählten Statusseiten als CSV herunter, mit denselben Filtern wie die Liste. Org-weit Admin oder Editor, kundengebunden die Seiten, die du pflegen darfst.
Summary: `GET /api/status-pages/subscribers/export` **Zugriff:** Organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor`. Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens bekommen nur die Abonnenten der Seiten, die sie pflegen dürfen: `self_service`-Seiten und `managed`-Seiten von Kunden mit der Ausnahme `canEditManaged`. Abonnenten anderer Seiten fallen ohne Fehler weg. Dieselben Zeilen und Filter wie [Abonnenten aller Statusseiten auflisten](/de/api/status-pages/list-all-subscribers) (`statusPageId`, `statusPageIds`, `channel`, `status`, `search`), ohne Blättern. **Eine Seitenauswahl ist Pflicht.** Nenne die Seiten mit `statusPageIds` (IDs oder `publicId`s durch Komma getrennt, höchstens 50) oder `statusPageId`. Abonnenten verschiedener Seiten gehören oft verschiedenen Verantwortlichen, deshalb mischt ein Export die Seiten nie stillschweigend. Eine ausgewählte Seite außerhalb deines Umfangs liefert keine Zeilen. Jeder Export wird im Audit-Log deiner Organisation festgehalten (Zeilenanzahl und verwendete Filter, nie die Adressen selbst). ## Beispiel (cURL) ```bash curl "$BASE_URL/api/status-pages/subscribers/export?statusPageIds=db58058e-4b58-4d97-a314-3bb8e279a182&channel=email" \ -H "Authorization: Bearer $TOKEN" \ -o subscribers.csv ``` ## Antwort `200 OK` mit `Content-Type: text/csv; charset=utf-8` und `Content-Disposition: attachment; filename="status-page-subscribers.csv"`. ```csv "status_page","status_page_id","email","status","locale","created_at","confirmed_at","channel","target","component_ids" "Acme Status","db58058e-4b58-4d97-a314-3bb8e279a182","reader@example.com","confirmed","en","2026-08-01T12:00:00.000Z","2026-08-01T12:05:00.000Z","email","","" ``` `status_page_id` ist die `publicId` der Seite. `target` enthält wie in der Liste nur den Ursprung der Ziel-URL. `component_ids` sind durch Leerzeichen getrennt, leer für die ganze Seite. Jede Zelle steht in Anführungszeichen, ein führendes `=`, `+`, `-` oder `@` wird gegen Formel-Injection entschärft. ## Häufige Fehler Wie bei [Abonnenten aller Statusseiten auflisten](/de/api/status-pages/list-all-subscribers), dazu: - `400 Bad Request` (`data.code: invalidRequestBody`), wenn weder `statusPageIds` noch `statusPageId` angegeben ist
### Abonnenten einer Statusseite exportieren
URL: https://docs.uptimeify.io/de/api/status-pages/export-subscribers
Description: Lädt alle Abonnenten einer Statusseite als CSV herunter. Org-weit Admin oder Editor, kundengebunden nach der Eigentumsklasse der Seite.
Summary: `GET /api/status-pages/:id/subscribers/export` **Zugriff:** Organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor` (organisationsweites `readonly` bleibt lesend). Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens folgen stattdessen der Eigentumsklasse der Seite: erlaubt auf `self_service`-Seiten, auf `managed`-Seiten nur mit der Ausnahme `canEditManaged` des Kunden, sonst `403` mit `data.code: managed_by_organization`. Abonnenten-Adressen sind personenbezogene Daten, deshalb braucht das Lesen dasselbe Recht wie das Ändern der Seite. Anders als [Abonnenten auflisten](/de/api/status-pages/list-subscribers) ist der Export nicht begrenzt, er liefert alle Zeilen der Seite. Jeder Export wird im Audit-Log deiner Organisation festgehalten (nur Seiten-ID und Zeilenanzahl, nie die Adressen selbst), da es sich um einen Massenexport der personenbezogenen Daten deiner Abonnenten handelt. ## Pfad-Parameter | Parameter | Beschreibung | |-----------|-------------| | `id` | Statusseiten-ID oder `publicId` (UUID) | ## Beispiel (cURL) ```bash curl "$BASE_URL/api/status-pages/db58058e-4b58-4d97-a314-3bb8e279a182/subscribers/export" \ -H "Authorization: Bearer $TOKEN" \ -o subscribers.csv ``` ## Antwort `Content-Type: text/csv; charset=utf-8`, `Content-Disposition: attachment; filename="status-page--subscribers.csv"` (`` ist die numerische ID der Statusseite, nicht ihre `publicId`). ```csv "email","status","locale","created_at","confirmed_at","channel","target","component_ids" "reader@example.com","confirmed","en","2026-08-01T12:00:00.000Z","2026-08-01T12:05:00.000Z","email","","" "other@example.com","pending","de","2026-08-02T09:30:00.000Z","","email","","" "","confirmed","de","2026-10-27T09:00:00.000Z","2026-10-27T09:01:00.000Z","slack","https://hooks.slack.com/…","12 14" ``` `channel`, `target` und `component_ids` stehen hinter den ursprünglichen fünf Spalten. `target` ist nur der Ursprung eines Webhook-, Slack-, Teams- oder Push-Ziels, nie die ganze URL, bei SMS die maskierte Nummer (`+49…67`); `component_ids` ist eine durch Leerzeichen getrennte Liste, leer für die ganze Seite. Die Zeilen sind nach `created_at` absteigend sortiert, neueste zuerst. Jedes Feld ist in Anführungszeichen gesetzt, enthaltene Anführungszeichen werden gemäß RFC 4180 verdoppelt. Ein Wert, der sonst mit `=`, `+`, `-` oder `@` beginnen würde, oder mit diesen Zeichen, denen Whitespace vorangeht (Tab, Leerzeichen oder Wagenrücklauf), erhält ein führendes einfaches Anführungszeichen, sodass er als reiner Text und nicht als Formel ausgewertet wird. Die E-Mail-Adressen stammen von Website-Besuchern und sind damit nicht vertrauenswürdig, das schützt beim Öffnen der Datei in Excel oder Sheets vor CSV-/Formel-Injection. ## Häufige Fehler - `401 Unauthorized`, wenn du nicht authentifiziert bist - `400 User must belong to an organization` (`data.code: userMustBelongToOrg`), wenn sich aus Session oder Token keine Organisation ableiten lässt - `403 Forbidden`, wenn du organisationsweit ohne die Rolle Admin oder Editor aufrufst, oder dein Kunden-Scope diese Statusseite nicht einschließt - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und die Seite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `400 Invalid Status page identifier`, wenn `id` keine gültige numerische ID oder UUID ist (kein `data.code`) - `404 Status page not found`, wenn `id` wohlgeformt ist, aber keine Statusseite dazu existiert (kein `data.code`) - `404 Status page not found` (`data.code: statusPageNotFound`), wenn `id` sich zu einer echten Statusseite auflöst, diese aber zu einer anderen Organisation gehört oder außerhalb deines Kunden-Scopes liegt
### Öffentliche Statusseite abfragen
URL: https://docs.uptimeify.io/de/api/status-pages/get-public-status-page
Description: Zwei Endpunkte liefern die öffentliche Statusseiten-Ansicht:
Summary: - `GET /api/status-pages/public/:slug`: Abruf per URL-Slug - `GET /api/status-pages/public/by-id/:id`: Abruf per numerischer ID Keine Authentifizierung nötig für Seiten mit `visibility: public`. Für Seiten mit `visibility: customer_members_only` ist eine Kundenmitglieds-Authentifizierung erforderlich. Eine `customer_members_only`-Seite ohne Kunde steht jedem angemeldeten Mitglied ihrer Organisation offen. Seiten mit `visibility: sso_members_only` funktionieren wie `customer_members_only` und verlangen zusätzlich eine Sitzung aus dem Single Sign-on der Organisation: Ohne Anmeldung oder mit einer Anmeldung ohne SSO antworten beide Endpunkte `401 ssoRequired`. Seiten mit `visibility: password_protected` verlangen das Seitenpasswort: Ohne gültiges Zugriffs-Cookie antworten beide Endpunkte `401 passwordRequired`. Der Besucher schaltet die Seite so frei: `POST /api/status-pages/public/:slug/verify-password` ```json { "password": "das Seitenpasswort" } ``` Die Antwort ist `{ "ok": true }` und setzt das httpOnly-Cookie `sp_access_` (Pfad `/`, 30 Tage gültig, `SameSite=Lax`, `Secure`). Schick es bei späteren Anfragen an beide Endpunkte mit. Ein neues Passwort über [Statusseite aktualisieren](/de/api/status-pages/update-status-page) macht jedes vorher ausgegebene Cookie ungültig. Die Prüfung erlaubt 10 Versuche pro Minute je IP-Adresse und Seite; darüber antwortet sie `429` mit `data.retryAfter`. Fehler: `400 passwordRequired` (Passwort leer oder fehlt), `401 invalidPassword` (falsches Passwort), `404 statusPageNotFound` (keine veröffentlichte Seite mit diesem Slug, oder die Seite ist nicht passwortgeschützt). Eine Seite mit IP-Freigabeliste (`ipAllowlist`) antwortet Besuchern aus anderen Netzen mit `403 statusPageIpNotAllowed`, unabhängig von ihrer Sichtbarkeit. Das gilt für beide Abfragen und für die Passwortprüfung einer geschützten Seite (verify-password); das Passwort wird dann gar nicht erst geprüft. Maßgeblich ist die Adresse, die unser Reverse Proxy sieht, nicht ein vom Client mitgeschickter `X-Forwarded-For`-Header. Mit Zielgruppen (`audienceGroups`) fehlen in `components` die Komponenten der Gruppen, zu denen der Besucher nicht gehört (angemeldet mit einer bestätigten E-Mail-Adresse einer Domain der Gruppe; Admins und Editoren der Seite sehen alles), ebenso Vorfälle und Wartungen, die nur diese Komponenten betreffen; `overallStatus` und `overallState` ergeben sich aus dem, was der Besucher sieht. Antworten für eine Seite mit IP-Freigabeliste oder Zielgruppen tragen `Cache-Control: private, no-store`. Badge (`/status/:slug/badge.svg`), Embed-Widget (`/status/:slug/embed`), Atom-/RSS-Feeds und Abos gibt es nur für Seiten mit `visibility: public` ohne IP-Freigabeliste und ohne Zielgruppen; für jede andere Seite antworten sie `404` wie eine fehlende Seite. **Vorschau einer unveröffentlichten Seite.** `GET /api/status-pages/public/:slug` antwortet auch für eine Seite mit `isPublished: false`, wenn die Anfrage als Mitglied der eigenen Organisation der Seite angemeldet ist, mit Zugriff auf den Design-Editor (`admin`, `editor` oder `readonly`), und bei einer Seite mit Kunde dieser Kunde im eigenen Bereich liegt. Die Antwort ist dieselbe, mit `isPublished: false` und `Cache-Control: private, no-store`; die öffentliche Seite zeigt ein Banner „Vorschau, nicht öffentlich“. Alle anderen, auch Mitglieder fremder Organisationen und anonyme Besucher, bekommen `404 statusPageNotFound`. Die Abfrage per ID, Badge, Widget, Feeds und eigene Domains liefern nur veröffentlichte Seiten aus. ## Antwort ```json { "statusPage": { "id": 1, "name": "Production Status", "slug": "production-status", "description": "Real-time status of our production services", "visibility": "public", "isPublished": true, "showRecentIncidents": true, "showRecentMaintenance": true, "overallState": "degraded", "overallStatus": "partial_outage", "smsSubscriptionsEnabled": true, "pushPublicKey": "BOr3...base64url...", "productName": "Northwind Monitoring", "createdAt"…
### Statusseite abfragen
URL: https://docs.uptimeify.io/de/api/status-pages/get-status-page
Description: Gibt eine Statusseite per numerischer ID oder publicId zurück, in derselben Form wie ein Eintrag von „Statusseiten auflisten“.
Summary: `GET /api/status-pages/{id}` ## Zugriff Derselbe Zugriff und dieselbe Sichtbarkeit wie [Statusseiten auflisten](/de/api/status-pages/list-status-pages): Eine Seite außerhalb deines Bereichs antwortet `404`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/status-pages/1" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) `200 OK` ```json { "id": 1, "publicId": "cccccccc-cccc-4ccc-8ccc-cccccccccccc", "organizationId": 10, "customerId": 5, "includeCustomerMonitors": true, "managementType": "managed", "canEdit": true, "customerPublicId": "dddddddd-dddd-4ddd-8ddd-dddddddddddd", "customerName": "Acme GmbH", "name": "Acme Status", "slug": "acme", "description": null, "visibility": "public", "hasPassword": false, "accessPasswordSetAt": null, "isPublished": true, "showRecentIncidents": true, "showRecentMaintenance": true, "subscriptionsEnabled": false, "subscriptionDelayMinutes": 5, "smsSubscriptionsEnabled": false, "pushSubscriptionsEnabled": false, "monitorUpdatesEnabled": true, "designConfig": null, "hiddenMonitors": [], "ipAllowlist": [], "audienceGroups": [], "createdAt": "2026-06-01T08:00:00.000Z", "updatedAt": "2026-06-01T08:00:00.000Z", "customDomain": { "id": 12, "hostname": "status.acme.example", "status": "active", "verifiedAt": "2026-06-02T08:00:00.000Z", "lastVerificationError": null, "lastVerificationErrorAt": null, "verificationToken": "uptimeify-verify-abc123" } } ``` `customerId`, `customerPublicId` und `customerName` sind bei einer Seite ohne Kunde `null`. Eine solche Seite sehen nur organisationsweite Rollen und API-Token; ein kundengebundener Aufrufer sieht sie nicht. `includeCustomerMonitors` sagt, ob die Monitore des Kunden automatisch erscheinen. Die Komponenten einer Seite liest du mit [Komponenten auflisten](/de/api/status-pages/list-status-page-components) und [Komponentengruppen auflisten](/de/api/status-pages/list-status-page-component-groups). `canEdit` (seit 30. Oktober 2026) sagt, ob du diese Seite und was an ihr hängt ändern darfst (Einstellungen, Komponenten, eigene Domain, Abonnenten, Vorfälle, Wartungen). Organisationsweite Aufrufer: `true` mit der Rolle `admin` oder `editor`. Kundengebundene Nutzer und Tokens (auch mit der Rolle `readonly`): `true` für `self_service`-Seiten, für `managed`-Seiten nur, wenn der Kunde `canEditManaged` hat. Es ist dieselbe Regel, die die schreibenden Endpunkte anwenden, siehe [Wer eine Statusseite ändern darf](/de/api/status-pages). `ipAllowlist` und `audienceGroups` (seit 28. Oktober 2026) enthalten die IP-Freigabeliste der Seite (als `addr/prefix`) und ihre Zielgruppen (`name`, `emailDomains`, `componentIds` als numerische IDs); ohne Einstellung sind beide `[]`. **Kompatibilität:** Seit dem 27.10.2026 kann `customerId` in Antworten `null` sein (eine Seite der ganzen Organisation, ohne Kunde), ebenso `customerPublicId` und `customerName`, wo vorhanden. Ein Client, der annimmt, dass `customerId` immer eine Zahl ist, muss `null` behandeln. ## Häufige Fehler - `400 Bad Request`, wenn die ID weder Zahl noch UUID ist oder dein Konto keiner Organisation angehört - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden`, wenn deine Rolle keine Statusseiten lesen darf - `404 Not Found` (`statusPageNotFound`), wenn die Seite nicht existiert oder außerhalb deines Bereichs liegt
### Design abfragen
URL: https://docs.uptimeify.io/de/api/status-pages/get-status-page-design
Description: Gibt die aktuelle visuelle Designkonfiguration einer Statusseite zurück. Erfordert die Rolle `admin`, `editor` oder `readonly`.
Summary: `GET /api/status-pages/:id/design` ## Pfad-Parameter | Parameter | Beschreibung | |-----------|-------------| | `id` | Statusseiten-ID oder `publicId` (UUID) | ## Beispiel (cURL) ```bash curl "$BASE_URL/api/status-pages/db58058e-4b58-4d97-a314-3bb8e279a182/design" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort ```json { "designConfig": { "layout": "timeline", "colorScheme": "dark", "accentColor": "#f59e0b", "headerStyle": "simple", "fontFamily": "system", "cardRadius": "md", "pageWidth": "lg", "customTitle": "", "customSubtitle": "", "showPoweredBy": true, "showUptimeStats": true, "showServiceUrls": false, "showLastChecked": false, "showHistory": true, "historyDays": 30, "showIncidents": true, "incidentLimit": 5, "incidentDays": 30, "showMaintenance": true, "maintenanceLimit": 5, "maintenanceDays": 30, "customCss": "", "statusLabels": { "majorOutage": "Störung" } } } ``` Wenn noch kein Design gespeichert wurde, werden alle Felder mit den Standardwerten befüllt. ## Fehler - `401 Unauthorized`: nicht angemeldet - `403 Forbidden` (`forbidden`): Rolle weder `admin`, `editor` noch `readonly`, oder Global Supporter - `404 Not found`: Statusseite nicht gefunden
### Statusseiten-Domain abfragen
URL: https://docs.uptimeify.io/de/api/status-pages/get-status-page-domain
Description: Gibt eine eigene Domain einer Statusseite deiner Organisation zurück, in derselben Form { domain, dns } wie beim Hinzufügen.
Summary: `GET /api/status-pages/domains/{id}` ## Zugriff Derselbe Lesezugriff wie [Statusseiten auflisten](/de/api/status-pages/list-status-pages). Zurück kommen nur Domains deiner Organisation mit der Rolle `status_page`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/status-pages/domains/12" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) `200 OK` ```json { "domain": { "id": 12, "hostname": "status.acme.example", "status": "pending", "role": "status_page", "verificationToken": "uptimeify-verify-abc123", "verifiedAt": null, "lastVerificationError": null, "lastVerificationErrorAt": null, "createdAt": "2026-06-01T08:00:00.000Z", "updatedAt": "2026-06-01T08:00:00.000Z", "statusPageId": 7 }, "dns": { "txtName": "_verify-status.status.acme.example", "txtValue": "uptimeify-verify-abc123" } } ``` `domain.statusPageId` ist die ID der Statusseite, an der die Domain hängt, `null`, solange sie an keine Seite gebunden ist. `domain.lastVerificationError` ist die Diagnose der letzten fehlgeschlagenen [Verifizierung](/de/api/status-pages/verify-status-page-domain) (dieselben Felder wie die Fehlerdaten von `domainVerificationFailed`), mit `domain.lastVerificationErrorAt`; beide sind `null`, sobald eine Verifizierung gelungen ist. Eine Live-Prüfung von DNS und Zertifikat liefert [Diagnose der Statusseiten-Domain](/de/api/status-pages/get-status-page-domain-diagnostics). ## Häufige Fehler - `400 Bad Request` (`invalidDomainId`), wenn die ID keine positive Zahl ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden`, wenn deine Rolle keine Statusseiten lesen darf - `404 Not Found` (`domainNotFound`), wenn die Domain nicht existiert oder zu einer anderen Organisation gehört
### Diagnose der Statusseiten-Domain
URL: https://docs.uptimeify.io/de/api/status-pages/get-status-page-domain-diagnostics
Description: Live-Prüfung von DNS und Zertifikat einer eigenen Statusseiten-Domain: autoritative Nameserver, gesehener TXT-Eintrag, Propagation, Zertifikatsstatus, letzte fehlgeschlagene Verifizierung.
Summary: `GET /api/status-pages/domains/{id}/diagnostics` Prüft bei jedem Aufruf live und schreibt nichts. Gedacht für eine Domain, die sich nicht verifizieren lässt oder kein HTTPS ausliefert. ## Zugriff Derselbe Lesezugriff wie [Statusseiten-Domain abfragen](/de/api/status-pages/get-status-page-domain). ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/status-pages/domains/12/diagnostics" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort (Response) `200 OK` ```json { "domainId": 12, "hostname": "status.acme.example", "status": "active", "checkedAt": "2026-10-29T09:30:00.000Z", "verification": { "recordFound": true, "recordName": "_verify-status.status.acme.example", "expected": "uptimeify-verify-abc123", "lookup": "records", "observed": ["uptimeify-verify-abc123"], "nameservers": { "zone": "acme.example", "hosts": ["ns1.dns-provider.example", "ns2.dns-provider.example"] }, "authoritative": { "nameserver": "ns1.dns-provider.example", "lookup": "records", "observed": ["uptimeify-verify-abc123"] }, "propagation": "propagated" }, "certificate": { "state": "valid", "errorCode": null, "errorMessage": null, "issuer": "Let's Encrypt", "validFrom": "2026-10-01T00:00:00.000Z", "validTo": "2026-12-30T00:00:00.000Z", "daysUntilExpiry": 62 }, "lastVerificationError": null, "lastVerificationErrorAt": null } ``` | Feld | Bedeutung | |------|-----------| | `verification` | Die Live-Prüfung des TXT-Eintrags, `null`, wenn die Domain keinen Verifizierungstoken hat. Dieselben Felder wie die Fehlerdaten von `domainVerificationFailed` beim Verifizieren, dazu `recordFound` (`true`: der Token ist veröffentlicht, die Verifizierung würde gelingen). | | `verification.nameservers` | Die Zone, in die der Hostname delegiert ist, und ihre autoritativen Nameserver; `null`, wenn sich das nicht ermitteln ließ. | | `verification.authoritative` | Die Antwort eines dieser Nameserver, direkt gefragt, an allen Caches vorbei; `null`, wenn keiner gefragt werden konnte. Gefragt werden nur öffentliche Nameserver-Adressen. | | `verification.propagation` | `propagated` (unser Resolver sieht den Token), `propagating` (dein Nameserver hat ihn, unser Resolver noch nicht; nach Ablauf der TTL erneut versuchen), `not_published` (nicht einmal dein Nameserver hat ihn), `unknown` (kein Nameserver ließ sich fragen). | | `certificate.state` | Was ein Browser unter `https://` bekommt: `valid`, `invalid` (es wird ein Zertifikat ausgeliefert, die Prüfung schlägt fehl, Grund in `errorCode`), `handshake_failed` (kein TLS-Handshake: das Zertifikat wird eventuell noch ausgestellt, oder der CNAME zeigt noch nicht auf uns), `unreachable` (`errorCode` `not_resolved` oder `private_address`), `not_active` (die Domain ist noch nicht aktiviert, vorher wird kein Zertifikat ausgestellt, es wurde nichts geprüft). | | `certificate.errorCode` | `expired`, `not_yet_valid`, `hostname_mismatch`, `untrusted`, `not_resolved`, `private_address` oder `null`. | | `lastVerificationError`, `lastVerificationErrorAt` | Die letzte fehlgeschlagene Verifizierung, wie sie an der Domain gespeichert ist; `null` nach einer erfolgreichen. | ## Häufige Fehler - `400 Bad Request` (`invalidDomainId`), wenn die ID keine positive Zahl ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden`, wenn deine Rolle keine Statusseiten lesen darf - `404 Not Found` (`domainNotFound`), wenn die Domain nicht existiert oder zu einer anderen Organisation gehört
### Wartung abfragen
URL: https://docs.uptimeify.io/de/api/status-pages/get-status-page-maintenance
Description: Gibt eine geplante Wartung mit Seiten, Komponenten und Updates zurück.
Summary: `GET /api/status-pages/maintenances/{id}` `state` kommt aus der Uhr und wird nie gespeichert: `scheduled` vor `scheduledFor`, `in_progress` bis `scheduledUntil`, danach `completed`; `cancelled`, sobald abgesagt. Die Wartung beginnt und endet von selbst, dafür ist kein Aufruf nötig. Solange sie `in_progress` ist, zeigen ihre Komponenten auf der öffentlichen Seite `maintenance` (ein schlimmerer Zustand wie ein Ausfall bleibt); eine Wartung ohne Komponenten zeigt die ganze Seite in Wartung. ## Zugriff Organisations-`admin`, `editor` und `readonly`. Ein kundengebundener Nutzer oder API-Token sieht nur Wartungen, deren Statusseiten alle zu einem Kunden in seinem Bereich gehören. Eine Wartung einer anderen Organisation antwortet `404` (`statusPageMaintenanceNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/status-pages/maintenances/12" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `200 OK`: ```json { "id": 12, "publicId": "3f1c2a9e-5b7d-4c8e-9a1f-2b3c4d5e6f70", "organizationId": 4, "title": "Database upgrade", "description": "Checkout may be slow for a few minutes.", "scheduledFor": "2026-11-03T22:00:00.000Z", "scheduledUntil": "2026-11-03T23:00:00.000Z", "state": "scheduled", "notifyOnSchedule": true, "reminderMinutesBefore": 60, "notifyOnStart": false, "notifyOnComplete": true, "cancelledAt": null, "statusPageIds": [1], "componentIds": [7], "links": [ { "statusPageId": 1, "statusPagePublicId": "0b6f3c1e-8d2a-4f5b-9c7e-1a2b3c4d5e6f", "statusPageName": "Acme Status", "componentId": 7, "componentPublicId": "5a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d", "componentName": "Checkout" } ], "updates": [], "createdAt": "2026-10-28T09:00:00.000Z", "updatedAt": "2026-10-28T09:00:00.000Z" } ``` ## Häufige Fehler - `400 Bad Request` (`invalidIdentifier`), wenn eine ID weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageMaintenanceNotFound`), wenn die Wartung nicht existiert oder zu einer anderen Organisation gehört
### Statusseiten-Modul abfragen
URL: https://docs.uptimeify.io/de/api/status-pages/get-status-page-module
Description: Liefert, ob das Statusseiten-Modul für deine Organisation eingeschaltet ist.
Summary: `GET /api/status-pages/module` Statusseiten sind ein Modul, das jede Organisation einmal aktiviert. Solange es aus ist, antwortet jeder Statusseiten-Endpunkt außer diesem, [Statusseiten-Modul aktivieren](/de/api/status-pages/activate-status-page-module) und den öffentlichen Endpunkten mit `403` und `data.code: statusPagesModuleDisabled`. Organisationen, die bei Einführung des Moduls schon eine Statusseite hatten, wurden automatisch aktiviert. ## Zugriff Rollen `admin`, `editor` und `readonly` der Organisation. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/status-pages/module" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort `200 OK` ```json { "enabled": true, "activatedAt": "2026-10-27T09:00:00.000Z", "smsQuotaAvailable": true } ``` `activatedAt` ist `null`, solange das Modul nie aktiviert wurde. `smsQuotaAvailable` ist `true`, solange deine Organisation eine SMS senden kann (Inklusivvolumen übrig, oder Mehrnutzung an und unter dem SMS-Deckel). Solange es `false` ist, antwortet das Einschalten von `smsSubscriptionsEnabled` mit `403 smsQuotaRequired`, und öffentliche Seiten bieten kein SMS-Abo an; Seiten, die es schon an haben, behalten die Einstellung und ihre SMS-Abonnenten. ## Häufige Fehler - `400 Bad Request` (`userMustBelongToOrg`), wenn dein Konto zu keiner Organisation gehört - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden`, wenn deine Rolle keine Statusseiten lesen darf
### Statusseiten-Vorlage abfragen
URL: https://docs.uptimeify.io/de/api/status-pages/get-status-page-template
Description: Liefert eine Vorlage.
Summary: `GET /api/status-pages/templates/{id}` Eine Vorlage füllt das Formular für einen neuen öffentlichen Vorfall (`kind: incident`) oder für ein Update zu einem laufenden (`kind: update`) vor. Sie veröffentlicht selbst nichts; Vorfälle entstehen weiter mit [Vorfall anlegen](/de/api/monitoring/create-manual-incident). ## Zugriff Organisations-`admin`, `editor` und `readonly`, auch kundengebunden. Vorlagen gehören der ganzen Organisation. Eine Vorlage einer anderen Organisation antwortet `404` (`statusPageTemplateNotFound`). Pfad-IDs nehmen die numerische ID oder die `publicId`. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/status-pages/templates/4" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `200 OK`, dieselbe Form wie ein Eintrag von [Statusseiten-Vorlagen auflisten](/de/api/status-pages/list-status-page-templates): ```json { "id": 4, "publicId": "3f6c2a1b-8d4e-4b7a-9c1d-2e3f4a5b6c7d", "kind": "incident", "name": "Payment provider down", "title": "Card payments failing", "body": "We are looking into failed card payments.", "updateStatus": "investigating", "severity": "major", "impact": "partial_outage", "statusPageIds": [2], "componentIds": [8], "createdAt": "2026-10-27T09:00:00.000Z", "updatedAt": "2026-10-27T09:00:00.000Z" } ``` ## Häufige Fehler - `400 Bad Request` (`invalidIdentifier`), wenn die ID weder Zahl noch UUID ist - `404 Not Found` (`statusPageTemplateNotFound`), wenn es die Vorlage nicht gibt oder sie einer anderen Organisation gehört - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist
### Abonnenten aller Statusseiten auflisten
URL: https://docs.uptimeify.io/de/api/status-pages/list-all-subscribers
Description: Liefert die Abonnenten aller Statusseiten, die du verwalten darfst, in einer gefilterten, seitenweisen Liste. Org-weit Admin oder Editor, kundengebunden die Seiten, die du pflegen darfst.
Summary: `GET /api/status-pages/subscribers` **Zugriff:** Organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor`. Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens bekommen nur die Abonnenten der Seiten, die sie pflegen dürfen: `self_service`-Seiten und `managed`-Seiten von Kunden mit der Ausnahme `canEditManaged`. Abonnenten anderer Seiten fallen ohne Fehler weg. Dieselben Zeilen wie [Abonnenten auflisten](/de/api/status-pages/list-subscribers), über alle Seiten: genau die Statusseiten, deren Abonnentenliste du auch einzeln öffnen dürftest (deine Organisation, dein Kundenumfang; Seiten ohne Kunde nur mit organisationsweitem Umfang). Anlegen lassen sich Abonnenten über die API nicht: ein Abonnement entsteht erst, wenn der Empfänger es bestätigt hat (Double-Opt-in). Zum Entfernen dient [Abonnent löschen](/de/api/status-pages/delete-subscriber) mit der `statusPagePublicId` der Zeile. ## Query-Parameter | Parameter | Beschreibung | |-----------|-------------| | `page` | Seitennummer, Vorgabe `1` | | `perPage` | Zeilen je Seite, Vorgabe `50`, höchstens `200` | | `statusPageId` | Nur diese Statusseite (ID oder `publicId`). Eine unbekannte Seite oder eine außerhalb deines Umfangs ergibt eine leere Liste | | `statusPageIds` | Nur diese Statusseiten: IDs oder `publicId`s durch Komma getrennt, höchstens 50, zusammen mit `statusPageId`. Seiten außerhalb deines Umfangs liefern keine Zeilen | | `channel` | `email`, `sms`, `push`, `webhook`, `slack` oder `teams` | | `status` | `pending`, `confirmed`, `unsubscribed` oder `disabled` | | `search` | Sucht ohne Beachtung der Groß-/Kleinschreibung in E-Mail-Adresse und Name der Statusseite (höchstens 200 Zeichen) | ## Beispiel (cURL) ```bash curl "$BASE_URL/api/status-pages/subscribers?status=confirmed&perPage=100" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort ```json { "items": [ { "id": 43, "statusPageId": 7, "statusPagePublicId": "db58058e-4b58-4d97-a314-3bb8e279a182", "statusPageName": "Acme Status", "email": null, "channel": "slack", "target": "https://hooks.slack.com/…", "componentIds": [12], "componentNames": ["Checkout"], "status": "confirmed", "locale": "de", "createdAt": "2026-10-27T09:00:00.000Z", "confirmedAt": "2026-10-27T09:01:00.000Z" } ], "total": 1, "page": 1, "perPage": 100 } ``` Neueste zuerst. Die Felder bedeuten dasselbe wie bei [Abonnenten auflisten](/de/api/status-pages/list-subscribers): `email` ist bei den URL-Kanälen `null`, `target` enthält nur den Ursprung der Ziel-URL, nie die ganze URL. `componentNames` nennt die Namen zu `componentIds` in derselben Reihenfolge; beide sind `null`, wenn der Abonnent der ganzen Seite folgt. ## Häufige Fehler - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`data.code: forbidden`), wenn du organisationsweit ohne die Rolle Admin oder Editor aufrufst - `403 Forbidden` (`data.code: statusPagesModuleDisabled`), wenn das Statusseiten-Modul für deine Organisation nicht aktiv ist - `400 Bad Request` (`data.code: invalidRequestBody`), wenn `page`, `perPage`, `channel`, `status` oder `search` ungültig ist oder `statusPageIds` mehr als 50 Seiten nennt - `400 Invalid Status page identifier` (`data.code: invalidIdentifier`), wenn `statusPageId` oder ein Eintrag von `statusPageIds` weder numerische ID noch UUID ist
### Komponentengruppen auflisten
URL: https://docs.uptimeify.io/de/api/status-pages/list-status-page-component-groups
Description: Gibt alle Komponentengruppen einer Statusseite zurück, sortiert nach sort.
Summary: `GET /api/status-pages/{id}/groups` Gruppen fassen [Komponenten](/de/api/status-pages/list-status-page-components) auf der öffentlichen Seite unter einer Überschrift zusammen. Die Liste enthält alle Gruppen der Seite auf einer einzigen Ergebnisseite, sortiert nach `sort`, dann `id`. Eine Seite hat höchstens 500 Gruppen. ## Zugriff Organisations-`admin`, `editor` und `readonly`. Ein kundengebundener Nutzer oder API-Token erreicht nur Seiten eines Kunden in seinem Bereich; eine Seite ohne Kunde (`customerId: null`) beantwortet ihm `403` (`forbidden`). Eine Seite einer anderen Organisation antwortet `404` (`statusPageNotFound`). `:id` nimmt die numerische ID oder die `publicId` der Statusseite. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/status-pages/1/groups" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort `200 OK` ```json { "items": [ { "id": 3, "publicId": "9e8d7c6b-5a4f-4e3d-8c2b-1a0f9e8d7c6b", "statusPageId": 1, "name": "Core services", "sort": 0, "collapsed": false, "createdAt": "2026-10-27T08:55:00.000Z", "updatedAt": "2026-10-27T08:55:00.000Z" } ], "total": 1, "page": 1, "perPage": 1 } ``` `collapsed` legt fest, ob die Gruppe auf der öffentlichen Seite zugeklappt startet. ## Häufige Fehler - `400 Bad Request` (`invalidIdentifier`), wenn eine ID im Pfad weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageNotFound`), wenn die Statusseite nicht existiert oder zu einer anderen Organisation gehört
### Komponenten auflisten
URL: https://docs.uptimeify.io/de/api/status-pages/list-status-page-components
Description: Gibt alle Komponenten einer Statusseite zurück, sortiert nach sort.
Summary: `GET /api/status-pages/{id}/components` Eine Komponente ist eine Zeile auf der Statusseite: ein Monitor (`sourceKind: monitor`), ein Drittanbieter aus unserer Abhängigkeits-Überwachung (`sourceKind: dependency`) oder ein Eintrag, den du von Hand pflegst (`sourceKind: manual`). Komponenten können in einer [Gruppe](/de/api/status-pages/list-status-page-component-groups) stehen. Die Liste enthält alle Komponenten der Seite auf einer einzigen Ergebnisseite, sortiert nach `sort`, dann `id`. Eine Seite hat höchstens 500 Komponenten. Die Monitore, die die Seite über `includeCustomerMonitors` automatisch einschließt, sind keine Komponenten und stehen nicht in dieser Liste. ## Zugriff Organisations-`admin`, `editor` und `readonly`. Ein kundengebundener Nutzer oder API-Token erreicht nur Seiten eines Kunden in seinem Bereich; eine Seite ohne Kunde (`customerId: null`) beantwortet ihm `403` (`forbidden`). Eine Seite einer anderen Organisation antwortet `404` (`statusPageNotFound`). `:id` nimmt die numerische ID oder die `publicId` der Statusseite. ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/status-pages/1/components" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort `200 OK` ```json { "items": [ { "id": 7, "publicId": "0b6f3c1e-8d2a-4f5b-9c7e-1a2b3c4d5e6f", "statusPageId": 1, "groupId": 3, "sort": 0, "name": "Main Site", "description": null, "showUptime": true, "sourceKind": "monitor", "monitorType": "http", "monitorId": 101, "manualStatus": null, "dependencySlug": null, "createdAt": "2026-10-27T09:00:00.000Z", "updatedAt": "2026-10-27T09:00:00.000Z" }, { "id": 8, "publicId": "5d4c3b2a-1f0e-4d9c-8b7a-6f5e4d3c2b1a", "statusPageId": 1, "groupId": null, "sort": 1, "name": "Payment provider", "description": "Card payments at checkout", "showUptime": true, "sourceKind": "manual", "monitorType": null, "monitorId": null, "manualStatus": "operational", "dependencySlug": null, "createdAt": "2026-10-27T09:05:00.000Z", "updatedAt": "2026-10-27T09:05:00.000Z" } ], "total": 2, "page": 1, "perPage": 2 } ``` | Feld | Beschreibung | |---|---| | `groupId` | Numerische ID der Gruppe, oder `null`, wenn die Komponente in keiner Gruppe steht. | | `sourceKind` | `monitor`, `dependency` oder `manual`. | | `monitorType`, `monitorId` | Der Monitor einer Monitor-Komponente; `null` bei einer manuellen. `monitorType` ist eins von `http`, `dns`, `icmp`, `smtp`, `ssh`, `tcp`, `ftp`, `imap_pop`. | | `manualStatus` | Zustand einer manuellen Komponente: `operational`, `degraded`, `partial_outage`, `major_outage` oder `maintenance`; `null` bei den anderen Arten. | | `dependencySlug` | Anbieter-Slug einer dependency-Komponente (`GET /api/public/dependencies`); `null` bei den anderen Arten. | | `showUptime` | Ob die Komponente auf der Seite ihren Verfügbarkeitsbalken zeigt. | ## Häufige Fehler - `400 Bad Request` (`invalidIdentifier`), wenn eine ID im Pfad weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageNotFound`), wenn die Statusseite nicht existiert oder zu einer anderen Organisation gehört
### Wartungen auflisten
URL: https://docs.uptimeify.io/de/api/status-pages/list-status-page-maintenance
Description: Listet die geplanten Wartungen deiner Statusseiten.
Summary: `GET /api/status-pages/maintenances` ## Zugriff Organisations-`admin`, `editor` und `readonly`. Ein kundengebundener Nutzer oder API-Token sieht nur Wartungen, deren Statusseiten alle zu einem Kunden in seinem Bereich gehören. Eine Wartung einer anderen Organisation antwortet `404` (`statusPageMaintenanceNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. ## Query-Parameter | Parameter | Typ | Standard | Beschreibung | |-----------|-----|----------|--------------| | `statusPageId` | number\|string | - | Nur Wartungen, die auf dieser Statusseite stehen (ID oder `publicId`). | | `state` | string | - | Kommagetrennt: `scheduled`, `in_progress`, `completed`, `cancelled`. | | `page` | number | `1` | | | `perPage` | number | `50` | Höchstens 200. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/status-pages/maintenances?state=scheduled,in_progress" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `200 OK`, neuester Beginn zuerst. Jeder Eintrag hat dieselbe Form wie [Wartung abfragen](/de/api/status-pages/get-status-page-maintenance): ```json { "items": [ { "id": 12, "title": "Database upgrade", "state": "scheduled", "...": "..." } ], "total": 1, "page": 1, "perPage": 50 } ``` ## Häufige Fehler - `400 Bad Request` (`invalidIdentifier`), wenn eine ID weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageNotFound`), wenn eine Statusseite nicht existiert oder zu einer anderen Organisation gehört - `400 Bad Request` (`invalidRequestBody`), wenn `state`, `page` oder `perPage` ungültig ist
### Statusseiten-Vorlagen auflisten
URL: https://docs.uptimeify.io/de/api/status-pages/list-status-page-templates
Description: Listet die Vorfall- und Update-Vorlagen deiner Organisation.
Summary: `GET /api/status-pages/templates` Eine Vorlage füllt das Formular für einen neuen öffentlichen Vorfall (`kind: incident`) oder für ein Update zu einem laufenden (`kind: update`) vor. Sie veröffentlicht selbst nichts; Vorfälle entstehen weiter mit [Vorfall anlegen](/de/api/monitoring/create-manual-incident). ## Zugriff Organisations-`admin`, `editor` und `readonly`, auch kundengebunden. Vorlagen gehören der ganzen Organisation. Eine Vorlage einer anderen Organisation antwortet `404` (`statusPageTemplateNotFound`). Pfad-IDs nehmen die numerische ID oder die `publicId`. ## Query-Parameter - `kind` (optional): `incident` oder `update`. Jeder andere Wert antwortet `400` (`invalidRequestBody`). ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X GET "$BASE_URL/api/status-pages/templates?kind=incident" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `200 OK`, jede Vorlage (höchstens 200), nach Name: ```json { "items": [{ "id": 4, "publicId": "3f6c2a1b-8d4e-4b7a-9c1d-2e3f4a5b6c7d", "kind": "incident", "name": "Payment provider down", "title": "Card payments failing", "body": "We are looking into failed card payments.", "updateStatus": "investigating", "severity": "major", "impact": "partial_outage", "statusPageIds": [2], "componentIds": [8], "createdAt": "2026-10-27T09:00:00.000Z", "updatedAt": "2026-10-27T09:00:00.000Z" }], "total": 1, "page": 1, "perPage": 1 } ``` ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`), wenn `kind` weder `incident` noch `update` ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist
### Statusseiten auflisten
URL: https://docs.uptimeify.io/de/api/status-pages/list-status-pages
Description: Gibt alle Statusseiten der Organisation zurück. Jede Seite enthält ihre Custom-Domain-Infos, sofern konfiguriert.
Summary: `GET /api/status-pages` ## Query-Parameter | Parameter | Typ | Standard | Beschreibung | |---|---|---|---| | `envelope` | string | keiner | `items`: Antwort als `{ items, total, page, perPage }`. Ab 18.01.2027 Standard. | ## Beispiel (cURL) ```bash curl -X GET "$BASE_URL/api/status-pages?envelope=items" \ -H "Authorization: Bearer $TOKEN" \ -H "Accept: application/json" ``` ## Antwort ```json { "items": [ { "id": 1, "publicId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890", "organizationId": 1, "customerId": 5, "includeCustomerMonitors": true, "managementType": "managed", "canEdit": true, "customerPublicId": "f7e6d5c4-b3a2-1098-7654-321fedcba098", "name": "Production Status", "slug": "production-status", "description": "Real-time status of our production services", "visibility": "public", "isPublished": true, "showRecentIncidents": true, "showRecentMaintenance": true, "customDomainId": null, "ipAllowlist": [], "audienceGroups": [], "createdAt": "2026-01-15T10:00:00.000Z", "updatedAt": "2026-01-15T10:00:00.000Z" } ], "total": 1, "page": 1, "perPage": 1 } ``` **Listenform:** Mit `envelope=items` kommt die Liste als `{ items, total, page, perPage }`. Ohne den Parameter antwortet der Endpunkt noch in der bisherigen Form (`{ "statusPages": [...] }`); sie ist veraltet, ab dem 18.01.2027 ist `{ items, ... }` der Standard. `customerId`, `customerPublicId` und `customerName` sind bei einer Seite ohne Kunde `null`. Eine solche Seite sehen nur organisationsweite Rollen und API-Token; ein kundengebundener Aufrufer sieht sie nicht. `includeCustomerMonitors` sagt, ob die Monitore des Kunden automatisch erscheinen. Die Komponenten einer Seite liest du mit [Komponenten auflisten](/de/api/status-pages/list-status-page-components) und [Komponentengruppen auflisten](/de/api/status-pages/list-status-page-component-groups). `canEdit` (seit 30. Oktober 2026) sagt, ob du diese Seite und was an ihr hängt ändern darfst (Einstellungen, Komponenten, eigene Domain, Abonnenten, Vorfälle, Wartungen). Organisationsweite Aufrufer: `true` mit der Rolle `admin` oder `editor`. Kundengebundene Nutzer und Tokens (auch mit der Rolle `readonly`): `true` für `self_service`-Seiten, für `managed`-Seiten nur, wenn der Kunde `canEditManaged` hat. Es ist dieselbe Regel, die die schreibenden Endpunkte anwenden, siehe [Wer eine Statusseite ändern darf](/de/api/status-pages). `ipAllowlist` und `audienceGroups` (seit 28. Oktober 2026) enthalten die IP-Freigabeliste der Seite (als `addr/prefix`) und ihre Zielgruppen (`name`, `emailDomains`, `componentIds` als numerische IDs); ohne Einstellung sind beide `[]`. **Kompatibilität:** Seit dem 27.10.2026 kann `customerId` in Antworten `null` sein (eine Seite der ganzen Organisation, ohne Kunde), ebenso `customerPublicId` und `customerName`, wo vorhanden. Ein Client, der annimmt, dass `customerId` immer eine Zahl ist, muss `null` behandeln. ## Häufige Fehler - `401 Unauthorized`, wenn nicht authentifiziert
### Abonnenten einer Statusseite auflisten
URL: https://docs.uptimeify.io/de/api/status-pages/list-subscribers
Description: Gibt die E-Mail- und RSS-Abonnenten einer Statusseite zurück, dazu exakte Zählwerte je Status. Org-weit Admin oder Editor, kundengebunden nach der Eigentumsklasse der Seite.
Summary: `GET /api/status-pages/:id/subscribers` **Zugriff:** Organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor` (organisationsweites `readonly` bleibt lesend). Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens folgen stattdessen der Eigentumsklasse der Seite: erlaubt auf `self_service`-Seiten, auf `managed`-Seiten nur mit der Ausnahme `canEditManaged` des Kunden, sonst `403` mit `data.code: managed_by_organization`. Abonnenten-Adressen sind personenbezogene Daten, deshalb braucht das Lesen dasselbe Recht wie das Ändern der Seite. ## Pfad-Parameter | Parameter | Beschreibung | |-----------|-------------| | `id` | Statusseiten-ID oder `publicId` (UUID) | ## Beispiel (cURL) ```bash curl "$BASE_URL/api/status-pages/db58058e-4b58-4d97-a314-3bb8e279a182/subscribers" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort ```json { "total": 12, "confirmed": 9, "pending": 2, "unsubscribed": 1, "disabled": 0, "subscribers": [ { "id": 42, "email": "reader@example.com", "channel": "email", "target": null, "componentIds": null, "status": "confirmed", "locale": "en", "createdAt": "2026-08-01T12:00:00.000Z", "confirmedAt": "2026-08-01T12:05:00.000Z" }, { "id": 43, "email": null, "channel": "slack", "target": "https://hooks.slack.com/…", "componentIds": [12], "status": "confirmed", "locale": "de", "createdAt": "2026-10-27T09:00:00.000Z", "confirmedAt": "2026-10-27T09:01:00.000Z" } ] } ``` `status` ist `pending`, `confirmed`, `unsubscribed` oder `disabled` (ein Webhook-, Slack-, Teams-, SMS- oder Push-Abo, das nach 5 fehlgeschlagenen Zustellungen in Folge abgeschaltet wurde). `channel` ist `email`, `sms`, `push`, `webhook`, `slack` oder `teams`; außer bei `email` ist `email` `null`, und `target` trägt nur den Ursprung der Ziel-URL oder des Push-Endpunkts, nie die ganze URL (die URL eines Incoming Webhooks ist das Zugangsgeheimnis), bei `sms` die Nummer als Ländervorwahl und letzte zwei Ziffern (`+49…67`). `componentIds` nennt die Komponenten dieser Seite, denen der Abonnent folgt, `null` für die ganze Seite. `confirmedAt` ist `null`, bis der Abonnent bestätigt hat. `total`, `confirmed`, `pending`, `unsubscribed` und `disabled` sind exakte Zählwerte, unabhängig vom `subscribers`-Array berechnet; `subscribers` selbst ist auf 5000 Zeilen begrenzt, neueste zuerst, nutze [Abonnenten exportieren](/de/api/status-pages/export-subscribers) für die vollständige Liste bei größeren Seiten. ## Häufige Fehler - `401 Unauthorized`, wenn du nicht authentifiziert bist - `400 User must belong to an organization` (`data.code: userMustBelongToOrg`), wenn sich aus Session oder Token keine Organisation ableiten lässt - `403 Forbidden`, wenn du organisationsweit ohne die Rolle Admin oder Editor aufrufst, oder dein Kunden-Scope diese Statusseite nicht einschließt - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und die Seite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `400 Invalid Status page identifier`, wenn `id` keine gültige numerische ID oder UUID ist (kein `data.code`) - `404 Status page not found`, wenn `id` wohlgeformt ist, aber keine Statusseite dazu existiert (kein `data.code`) - `404 Status page not found` (`data.code: statusPageNotFound`), wenn `id` sich zu einer echten Statusseite auflöst, diese aber zu einer anderen Organisation gehört oder außerhalb deines Kunden-Scopes liegt Die letzten beiden Zeilen teilen sich dieselbe Meldung, unterscheiden sich aber im `data.code`: eine fehlerhafte oder gänzlich unbekannte `id` trägt nie einen `data.code`; nur eine `id`, die sich zu einer Zeile auflöst, die du nicht sehen darfst, tut das.
### Wartungs-Update veröffentlichen
URL: https://docs.uptimeify.io/de/api/status-pages/post-status-page-maintenance-update
Description: Veröffentlicht ein Update zu einer Wartung auf der Seite und an die Abonnenten.
Summary: `POST /api/status-pages/maintenances/{id}/updates` Hängt ein öffentliches Update an eine Wartung, vorher, währenddessen oder danach. ## Zugriff Organisationsweite Aufrufer: `admin` und `editor` (organisationsweites `readonly` bleibt lesend). Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens folgen der Eigentumsklasse jeder beteiligten Seite (bei einer neuen Wartung jede Seite in `statusPageIds`, sonst jede Seite, mit der die Wartung verknüpft ist): erlaubt auf `self_service`-Seiten, auf `managed`-Seiten nur mit der Ausnahme `canEditManaged` des Kunden, sonst `403` mit `data.code: managed_by_organization`. Eine Wartung ohne Statusseite folgt weiter der Rolle (`admin` oder `editor`). Ein kundengebundener Nutzer oder API-Token erreicht nur Wartungen, deren Statusseiten alle zu einem Kunden in seinem Bereich gehören; eine Seite ohne Kunde (`customerId: null`) ist Org-weiten Rollen vorbehalten. Eine Wartung einer anderen Organisation antwortet `404` (`statusPageMaintenanceNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Protokoll der Organisation. ## Request-Body | Feld | Typ | Pflicht | Standard | Beschreibung | |------|-----|---------|----------|--------------| | `body` | string | Ja | - | Der Text des Updates (1-5000 Zeichen), steht auf der öffentlichen Seite. | | `notifySubscribers` | boolean | Nein | `true` | An Abonnenten als `maintenance_update` senden. Derselbe Text zweimal an derselben Wartung geht einmal raus. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X POST "$BASE_URL/api/status-pages/maintenances/12/updates" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"body": "The upgrade takes 20 minutes longer than planned."}' ``` ## Antwort `201 Created`: ```json { "id": 31, "publicId": "7c2d4e6f-8a9b-4c0d-9e1f-2a3b4c5d6e7f", "body": "The upgrade takes 20 minutes longer than planned.", "createdAt": "2026-11-03T22:40:00.000Z" } ``` ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`), wenn ein Feld fehlt, den falschen Typ hat oder unbekannt ist; `data.issues` nennt das Feld - `400 Bad Request` (`invalidIdentifier`), wenn eine ID weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und eine beteiligte Statusseite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageMaintenanceNotFound`), wenn die Wartung nicht existiert oder zu einer anderen Organisation gehört - `409 Conflict` (`statusPageMaintenanceClosed`), wenn die Wartung abgesagt wurde
### Eigene Domain entfernen
URL: https://docs.uptimeify.io/de/api/status-pages/remove-status-page-domain
Description: Entfernt eine eigene Domain von einer Statusseite. Löscht den Domain-Datensatz; die customDomainId der Statusseite wird automatisch auf null gesetzt. Org-weit Admin oder Editor, kundengebunden nach der Eigentumsklasse der Seite.
Summary: `DELETE /api/status-pages/domains/:id` **Zugriff:** Organisationsweite Aufrufer brauchen die Rolle `admin` oder `editor` (organisationsweites `readonly` bleibt lesend). Kundengebundene Nutzer (auch mit der Rolle `readonly`) und kundengebundene API-Tokens folgen stattdessen der Eigentumsklasse der Seite: erlaubt auf `self_service`-Seiten, auf `managed`-Seiten nur mit der Ausnahme `canEditManaged` des Kunden, sonst `403` mit `data.code: managed_by_organization`. ## Pfad-Parameter | Parameter | Typ | Beschreibung | |-----------|-----|--------------| | `id` | number | Die zu entfernende Domain-ID | ## Beispiel (cURL) ```bash curl -X DELETE "$BASE_URL/api/status-pages/domains/42" \ -H "Authorization: Bearer $TOKEN" ``` ## Antwort `204 No Content` ## Häufige Fehler - `401 Unauthorized`, wenn nicht authentifiziert - `403 Forbidden`, wenn du organisationsweit ohne die Rolle Admin oder Editor aufrufst - `403 Forbidden` (`managed_by_organization`), wenn du kundengebunden aufrufst (Nutzer, auch mit der Rolle `readonly`, oder Token) und die Seite `managed` ist, ohne die Ausnahme `canEditManaged` des Kunden - `404 Not found`, wenn die Domain nicht existiert - `422 Unprocessable Entity`, wenn die Domain-ID ungültig ist
### Komponenten sortieren
URL: https://docs.uptimeify.io/de/api/status-pages/reorder-status-page-components
Description: Setzt Position und Gruppe vieler Komponenten in einem Aufruf.
Summary: `PUT /api/status-pages/{id}/components/order` Setzt `sort` und `groupId` mehrerer Komponenten in einer Transaktion, zum Beispiel nach Drag and drop. Jede genannte Komponente und Gruppe muss zu dieser Seite gehören; sonst antwortet der Aufruf `404` und nichts wird geschrieben. Komponenten, die du nicht nennst, bleiben, wie sie sind. ## Zugriff Organisations-`admin` und `editor`; kundengebundene Nutzer (auch `readonly`) und Tokens nur auf `self_service`-Seiten ihrer Kunden, oder auf `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein kundengebundener Nutzer oder API-Token erreicht nur Seiten eines Kunden in seinem Bereich; eine Seite ohne Kunde (`customerId: null`) beantwortet ihm `403` (`forbidden`). Eine Seite einer anderen Organisation antwortet `404` (`statusPageNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Protokoll der Organisation. ## Request-Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `items` | array | Ja | 1 bis 500 Einträge. | | `items[].id` | number\|string | Ja | ID oder `publicId` der Komponente. | | `items[].groupId` | number\|string\|null | Ja | ID oder `publicId` der Zielgruppe, `null` für keine Gruppe. | | `items[].sort` | number | Ja | Neue Position, 0-100000. | ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="" curl -X PUT "$BASE_URL/api/status-pages/1/components/order" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "items": [ { "id": 8, "groupId": 3, "sort": 0 }, { "id": 7, "groupId": 3, "sort": 1 } ] }' ``` ## Antwort `200 OK` mit allen Komponenten der Seite nach der Änderung, sortiert nach `sort`, in derselben Form wie bei [Komponenten auflisten](/de/api/status-pages/list-status-page-components) (`{ items, total, page, perPage }`). ## Häufige Fehler - `400 Bad Request` (`invalidRequestBody`), wenn `items` leer ist, mehr als 500 Einträge hat oder ein Eintrag ungültig ist - `400 Bad Request` (`invalidIdentifier`), wenn eine ID im Pfad weder Zahl noch UUID ist - `401 Unauthorized`, wenn du nicht angemeldet bist - `403 Forbidden` (`forbidden`), wenn deine Rolle das nicht darf, oder für einen kundengebundenen Aufrufer auf einer Seite ohne Kunde oder eines anderen Kunden - `403 Forbidden` (`statusPagesModuleDisabled`), wenn das Statusseiten-Modul nicht aktiviert ist - `404 Not Found` (`statusPageNotFound`), wenn die Statusseite nicht existiert oder zu einer anderen Organisation gehört - `404 Not Found` (`statusPageComponentNotFound`), wenn eine genannte Komponente auf dieser Seite nicht existiert - `404 Not Found` (`statusPageComponentGroupNotFound`), wenn eine genannte `groupId` keine Gruppe dieser Seite ist
### Statusseite abonnieren
URL: https://docs.uptimeify.io/de/api/status-pages/subscribe-to-status-page
Description: Öffentlicher Endpunkt hinter dem Abo-Formular: E-Mail, SMS, Browser-Push, Webhook, Slack oder Microsoft Teams, für die ganze Seite oder einzelne Komponenten. Double-Opt-in für jeden Kanal.
Summary: `POST /api/status-pages/public/:slug/subscribe` Ohne Anmeldung. An diesen Endpunkt schickt das Abo-Formular einer öffentlichen Statusseite. Jedes Abo beginnt als `pending` und wird erst aktiv, wenn der Bestätigungslink geöffnet und bestätigt wurde: per Mail bei `email`, als erste Nachricht an das Ziel bei `webhook`, `slack` und `teams`, mit einem sechsstelligen Code per SMS bei `sms` (eingegeben auf der Statusseite) und über einen ersten Push, den der Service Worker der Seite selbst bestätigt, bei `push`. Jede Nachricht enthält einen Abmeldelink. Die Seite muss veröffentlicht und öffentlich sein (ohne IP-Freigabeliste und ohne Zielgruppen), Abos müssen eingeschaltet sein, und ihre Organisation braucht das Statusseiten-Modul und darf nicht gesperrt sein. Sonst antwortet der Endpunkt genauso mit `{ "ok": true }` und speichert nichts. Bestehende Abonnenten einer Seite, die später geschützt wird (eine andere Sichtbarkeit als `public`, eine IP-Freigabeliste oder Zielgruppen), bekommen keine Benachrichtigungen mehr. `sms` und `push` muss die Seite zusätzlich anbieten (`smsSubscriptionsEnabled`, `pushSubscriptionsEnabled` an der Statusseite, beide standardmäßig aus); `GET /api/status-pages/public/:slug` sagt dem Formular, ob es sie zeigt. `sms` wird außerdem nur angeboten und angenommen, solange die Organisation SMS-Kontingent hat. ## Request-Body | Feld | Typ | Pflicht | Beschreibung | |------|-----|---------|--------------| | `channel` | string | nein | `email` (Standard), `sms`, `push`, `webhook`, `slack` oder `teams` | | `email` | string | bei `email` | Empfängeradresse | | `targetUrl` | string | bei URL-Kanälen | `https`-URL ohne Zugangsdaten, öffentlich erreichbar. Slack: eine Incoming-Webhook-URL. Teams: eine Incoming-Webhook- oder Workflows-URL, die Adaptive Cards annimmt | | `phone` | string | bei `sms` | Mobilnummer international, etwa `+49 170 1234567` oder `0049...`; Leerzeichen, Bindestriche und Klammern zählen nicht | | `pushSubscription` | object | bei `push` | `PushSubscription.toJSON()` des Browsers: `endpoint` (`https`, öffentlich erreichbar) sowie `keys.p256dh` und `keys.auth`, erzeugt mit dem `pushPublicKey` der Seite | | `componentIds` | array | nein | Komponenten dieser Seite (numerische ID oder `publicId`), höchstens 500. Fehlt oder leer: die ganze Seite | | `locale` | string | nein | `de...` für deutsche, `da...` für dänische Nachrichten, sonst Englisch | Ein URL-, SMS- oder Push-Abo wird verschlüsselt gespeichert. Sein Ziel wird nie vollständig ausgegeben: Die Abonnentenliste zeigt bei URL und Push-Endpunkt den Ursprung, bei einer Telefonnummer die Ländervorwahl und die letzten zwei Ziffern. ## Beispiel (cURL) ```bash curl -X POST "https://uptimeify.io/api/status-pages/public/acme/subscribe" \ -H "Content-Type: application/json" \ -d '{"channel":"webhook","targetUrl":"https://example.com/hooks/status","componentIds":[12]}' ``` ## Antwort `200 OK` ```json { "ok": true } ``` Bei `email` und `sms` kommt immer diese Antwort (außer `403 statusPageSmsUnavailable` unten), auch für eine unbekannte Seite, eine schon bestätigte oder eine gedrosselte Adresse oder Nummer. So verrät der Endpunkt nicht, ob es eine Adresse, Nummer oder Seite gibt. ## SMS Die Code-SMS und jede spätere SMS gehen vom SMS-Kontingent der Organisation ab: im Inklusivvolumen, darüber nur mit eingeschalteter Mehrnutzung der Organisation und nie über ihren SMS-Deckel hinaus. Ist kein SMS-Budget mehr da, geht nichts raus, und der Abonnent zählt nicht als fehlgeschlagen. Der Code gilt 15 Minuten; das Formular der Statusseite bestätigt ihn mit `POST /api/status-pages/public/:publicId/confirm` und `{ "phone": "...", "code": "123456" }` (5 Versuche je Nummer und Stunde). Eine Nummer bekommt höchstens 3 Codes pro Stunde. Eine Ereignis-SMS ist genau eine SMS: Seitenname, Ereignis und ein kurzer Abmeldelink; lange Titel werden gekürzt. ## Browser-Push W3C Web Push mit VAPID. Die Nachrichten sind Ende-zu-Ende für den Browser verschlüsselt (RFC 8291) und lauf…
### Statusseite aktualisieren
URL: https://docs.uptimeify.io/de/api/status-pages/update-status-page
Description: Aktualisiert eine Statusseite. Mindestens ein Feld muss angegeben werden. Erfordert die Rolle `admin` oder `editor`; kundengebundene Nutzer und Tokens (auch `readonly`) ändern selbstverwaltete Seiten ihrer Kunden.
Summary: `PATCH /api/status-pages/:id` ## Request-Body (alle optional) | Feld | Typ | Beschreibung | |------|-----|--------------| | `customerId` | number\|null | Seite zu einem anderen Kunden deiner Organisation verschieben. `null` löst sie von ihrem Kunden (Seite der ganzen Organisation); das dürfen nur organisationsweite Rollen und API-Token. | | `includeCustomerMonitors` | boolean | Jeden Monitor des Kunden, außer denen in `hiddenMonitors`, automatisch hinter den ausdrücklichen Komponenten anzeigen. Ein Wechsel von `customerId` lässt den Wert unverändert. | | `managementType` | string | `managed` oder `self_service`. Ändern dürfen nur Organisations-Admins ohne Kundenbindung (sonst `403 managementTypeOrgOnly`). | | `name` | string | Anzeigename (1-120 Zeichen) | | `slug` | string | URL-Slug (1-120 Zeichen, 409 bei Konflikt) | | `description` | string\|null | Beschreibung (max. 1000 Zeichen). `null` löscht sie. | | `visibility` | string | `public`, `customer_members_only`, `password_protected` (jeder mit dem Seitenpasswort, siehe unten) oder `sso_members_only` (wie `customer_members_only`, zusätzlich muss die Sitzung über das Single Sign-on deiner Organisation entstanden sein) | | `accessPassword` | string | Setzt ein neues Seitenpasswort (8-200 Zeichen). Pflicht, wenn die Seite `password_protected` wird und noch kein Passwort hat; sonst lässt du das Feld weg und das bisherige bleibt. Ein neues Passwort meldet jeden Besucher ab, der die Seite freigeschaltet hat. Entfernen lässt sich das Passwort nicht: Wechselst du auf eine andere Sichtbarkeit, bleibt es gespeichert (`hasPassword` bleibt `true`), und beim Zurückwechseln gilt es wieder. Wird nie zurückgegeben; die Antwort zeigt `hasPassword` und `accessPasswordSetAt`. | | `ipAllowlist` | array | Ersetzt die IP-Freigabeliste: IPv4-/IPv6-Adressen oder CIDR-Bereiche, höchstens 50, gespeichert als `addr/prefix`. `[]` hebt die Beschränkung auf. | | `audienceGroups` | array | Ersetzt alle Zielgruppen, höchstens 20: `[{ "name", "emailDomains", "componentIds" }]`. `[]` entfernt sie. Siehe unten. | | `isPublished` | boolean | Seite veröffentlichen oder verbergen | | `showRecentIncidents` | boolean | Abschnitt „Letzte Vorfälle" anzeigen | | `showRecentMaintenance` | boolean | Abschnitt „Letzte Wartungen" anzeigen | | `smsSubscriptionsEnabled` | boolean | SMS-Abos auf der öffentlichen Seite anbieten (Standard `false`). Ausschalten stoppt auch die SMS an bestehende SMS-Abonnenten. Einschalten braucht SMS-Kontingent (sonst `403 smsQuotaRequired`); eine Seite, die es schon an hat, behält es. | | `pushSubscriptionsEnabled` | boolean | Browser-Push-Abos auf der öffentlichen Seite anbieten (Standard `false`). Ausschalten stoppt auch den Push an bestehende Push-Abonnenten. | | `monitorUpdatesEnabled` | boolean | Monitore schreiben auf diese Seite (Standard `true`): ihr Zustand setzt Komponenten und Seitenstatus, Monitoring-Vorfälle stehen in der Historie und gehen an die Abonnenten. `false`: die Seite zeigt nur, was ihr meldet oder ausdrücklich verknüpft (verknüpfte Vorfälle, Wartungen, Regeln aus Incident Management). | | `designConfig` | object | Visuelle Design-Einstellungen (Layout, Farben, Typografie, …). Alle Felder siehe [Design aktualisieren](/de/api/status-pages/update-status-page-design). | | `hiddenMonitors` | array | Monitore, die auf dieser Statusseite ausgeblendet werden. Jeder Eintrag ist `{ "type": "http"\|"dns"\|"icmp"\|"smtp"\|"ssh"\|"ftp"\|"imap_pop", "id": }`. Leer lassen oder `[]` senden, um alle Monitore anzuzeigen (Standard). Später hinzugefügte Monitore erscheinen automatisch. Maximal 500 Einträge. | Wenn angegeben, ersetzt `hiddenMonitors` die gespeicherte Liste vollständig; ohne das Feld bleibt sie unverändert; `[]` zeigt wieder alle Monitore an. **Private Seiten (seit 28. Oktober 2026).** - `password_protected`: Wer das Seitenpasswort kennt, sieht die Seite. Besucher schalten sie über den [verify-password-Endpunkt](/de/api/status-pages/get-public-status-page) fre…
### Komponente aktualisieren
URL: https://docs.uptimeify.io/de/api/status-pages/update-status-page-component
Description: Ändert Name, Beschreibung, Gruppe, Position, Verfügbarkeitsbalken, manuellen Zustand oder Monitor einer Komponente.
Summary: `PATCH /api/status-pages/{id}/components/{componentId}` ## Zugriff Organisations-`admin` und `editor`; kundengebundene Nutzer (auch `readonly`) und Tokens nur auf `self_service`-Seiten ihrer Kunden, oder auf `managed`-Seiten mit der Ausnahme `canEditManaged` des Kunden (sonst `403 managed_by_organization`). Ein kundengebundener Nutzer oder API-Token erreicht nur Seiten eines Kunden in seinem Bereich; eine Seite ohne Kunde (`customerId: null`) beantwortet ihm `403` (`forbidden`). Eine Seite einer anderen Organisation antwortet `404` (`statusPageNotFound`). IDs im Pfad nehmen die numerische ID oder die `publicId`. Die Änderung steht im Audit-Protokoll der Organisation. ## Request-Body (alle optional, mindestens ein Feld) | Feld | Typ | Beschreibung | |------|-----|--------------| | `name` | string | Anzeigename (1-120 Zeichen). | | `description` | string\|null | Max. 1000 Zeichen. `null` löscht sie. | | `groupId` | number\|string\|null | ID oder `publicId` einer Gruppe dieser Seite. `null` nimmt die Komponente aus ihrer Gruppe. | | `sort` | number | Position, 0-100000. | | `showUptime` | boolean | Verfügbarkeitsbalken anzeigen. | | `manualStatus` | string | Nur manuelle Komponenten (oder zusammen mit `sourceKind: "manual"`): `operational`, `degraded`, `partial_outage`, `major_outage` oder `maintenance`. | | `sourceKind` | string | `monitor` oder `manual`. Schaltet die Komponente um zwischen „folgt einem Monitor“ und „Zustand setzt du selbst“. `manual` löst die Verknüpfung zum Monitor; `manualStatus` ist dann standardmäßig `operational`. `monitor` braucht `monitorType` und `monitorId`. Nicht für `dependency`-Komponenten. | | `monitorType` | string | Zusammen mit `monitorId`: der Monitor, dem die Komponente folgt (`http`, `dns`, `icmp`, `smtp`, `ssh`, `tcp`, `ftp`, `imap_pop`). Verknüpft eine Monitor-Komponente mit einem anderen Monitor oder macht mit `sourceKind: "monitor"` aus einer manuellen eine Monitor-Komponente. Dieselben Regeln wie beim Anlegen: ein Monitor dieser Organisation, bei einer Seite mit Kunde einer dieses Kunden, und im Kundenbereich des Aufrufers. | | `monitorId` | number | Zusammen mit `monitorType`. | Beim Wechsel der Quelle behält die Komponente ihre ID, Gruppe, Abos und Vorfall-Verknüpfungen. Eine `dependency`-Komponente behält ihren Anbieter; lösche sie stattdessen und lege eine neue an. Um viele Komponenten auf einmal zu verschieben, nimm [Komponenten sortieren](/de/api/status-pages/reorder-status-page-components). ## Beispiel (cURL) ```bash BASE_URL="https://uptimeify.io" TOKEN="