UptimeEye MCP-Server

Verbinde Claude, Cursor oder einen anderen MCP-Client und richte dein Monitoring ein, indem du es beschreibst: „prüfe unsere Checkout-API alle 30 Sekunden aus Europa und den USA und schick Alerts an den Bereitschaftskanal“, oder frag, was deine Services geloggt haben, als ein Monitor ausfiel. Gleiche API, gleiche Rechte wie in der App, und kein Server, den du betreiben musst: Claude verbindet sich per Anmeldung, jeder andere Client mit einem Management-Key.

In Claude verbinden

Claude (claude.ai, Claude Desktop und Claude Code) verbindet sich per Anmeldung, ohne Key zum Kopieren. UptimeEye steht im Claude-Verzeichnis: Du meldest dich mit deinem UptimeEye-Konto an, danach kann Claude in jeder Organisation arbeiten, in der du Mitglied bist.

claude.ai und Claude Desktop

  1. Öffne UptimeEye im Claude-Verzeichnis oder geh in Claude auf Customize → Connectors, Reiter Discover, und such nach UptimeEye.
  2. Klick auf Connect, melde dich bei UptimeEye an, falls gefragt, wähl deine Standard-Organisation und klick auf Allow.

Mit einem Claude-Team- oder -Enterprise-Plan muss ein Owner den Connector eventuell zuerst für eure Claude-Organisation freigeben; danach verbindet ihn jedes Mitglied mit seiner eigenen Anmeldung. Ohne Verzeichnis fügst du ihn als benutzerdefinierten Connector hinzu: Customize → Connectors → + Add → Add custom connector mit der URL https://api.uptimeeye.com/mcp.

Claude Code

Füg den Server ohne Header hinzu, führ dann in Claude Code /mcp aus, wähl uptimeeye und dann Authenticate. Dein Browser öffnet sich für die Anmeldung.

shell
claude mcp add --transport http uptimeeye https://api.uptimeeye.com/mcp
Hinweis: Ein Connector handelt als du, mit deiner Rolle in der jeweiligen Organisation. Er funktioniert in all deinen Organisationen: Die beim Verbinden gewählte ist der Standard, eine andere nennst du im Chat („liste die Monitore von Kunde B“). In einer Organisation, die du verlässt oder deren Plan deinen Platz nicht mehr enthält, funktioniert er nicht mehr. Für CI, Skripte und andere Clients nimm einen Management-Key; ein Key funktioniert nur in seiner eigenen Organisation.

Schnellstart mit API-Key

1. Management-Key erstellen

Öffne in der App API-Keys → Neuer API-Key, wähle den Typ „Management“ und kopiere den Key. Er beginnt mit ue_live_ und wird nur einmal angezeigt. Log-Ingest-Keys (ue_ingest_) funktionieren hier nicht.

2. Server im Client eintragen

Endpoint: https://api.uptimeeye.com/mcp (Streamable HTTP), authentifiziert mit Authorization: Bearer ue_live_…. In Claude Code ist das ein Befehl:

shell
claude mcp add --transport http uptimeeye https://api.uptimeeye.com/mcp \
  --header "Authorization: Bearer ue_live_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

3. Fragen

Probier „Liste meine UptimeEye-Monitore auf“ – und beschreib dann, was überwacht werden soll. Der Assistent schaut zuerst deine Benachrichtigungskanäle nach, weil jeder Monitor einen braucht.

Client verbinden

Claude Code

Der Befehl aus dem Schnellstart richtet den Server nur für dich ein. Mit --scope project teilst du ihn über .mcp.json mit deinem Team, und der Key landet nicht in dieser Datei: In einfachen Anführungszeichen steht ${UPTIMEEYE_API_KEY} unverändert in der Datei, und Claude Code liest den Key beim Start aus dieser Umgebungsvariable.

shell
claude mcp add --transport http --scope project uptimeeye https://api.uptimeeye.com/mcp \
  --header 'Authorization: Bearer ${UPTIMEEYE_API_KEY}'

Cursor

Global in ~/.cursor/mcp.json oder pro Projekt in .cursor/mcp.json:

.cursor/mcp.json
{
  "mcpServers": {
    "uptimeeye": {
      "url": "https://api.uptimeeye.com/mcp",
      "headers": { "Authorization": "Bearer ue_live_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" }
    }
  }
}

VS Code (GitHub Copilot im Agent-Modus)

VS Code fragt einmal nach dem Key und speichert ihn sicher:

.vscode/mcp.json
{
  "inputs": [
    { "type": "promptString", "id": "uptimeeye-key", "description": "UptimeEye API key (ue_live_…)", "password": true }
  ],
  "servers": {
    "uptimeeye": {
      "type": "http",
      "url": "https://api.uptimeeye.com/mcp",
      "headers": { "Authorization": "Bearer ${input:uptimeeye-key}" }
    }
  }
}

Claude Desktop

Claude Desktop verbindet sich per Anmeldung (siehe In Claude verbinden). Mit einem Key verbindet es sich stattdessen über die mcp-remote-Bridge (braucht Node.js): Trag das in claude_desktop_config.json ein und starte die App neu:

claude_desktop_config.json
{
  "mcpServers": {
    "uptimeeye": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.uptimeeye.com/mcp", "--header", "Authorization:${UPTIMEEYE_AUTH}"],
      "env": { "UPTIMEEYE_AUTH": "Bearer ue_live_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" }
    }
  }
}

Andere Clients: Alles, was Remote-MCP-Server über Streamable HTTP mit einem eigenen Header unterstützt, funktioniert mit dem Endpoint und Header oben.

Verfügbare Tools

Die Tools tragen MCP-Annotationen: Lesende Tools sind als read-only markiert, Lösch-Tools als destruktiv, sodass gut gebaute Clients vor dem Ausführen nachfragen.

ToolWas es tut
list_organizationsDie Organisationen, in denen eine angemeldete Verbindung arbeiten kann, mit deiner Rolle und der Standard-Organisation. Jedes andere Tool nimmt ein optionales organization (ID oder Slug), um in einer anderen davon zu arbeiten.
list_monitorsAlle Uptime-Monitore mit ID, Name, URL, Status und Prüfintervall.
get_monitorVollständige Konfiguration eines Monitors mit seinen Schritten und Assertions.
list_locationsRegionen, aus denen ein Monitor prüfen kann, z. B. eu-central-1, und ob sie gerade bedient werden.
create_monitorHTTP-, TCP-Port- (host:port), DNS- oder ICMP-Check mit Intervall, Timeout, Assertions (Statuscode, Antwortzeit, Keyword im Body, Header, JSON-Pfad, Zertifikatslaufzeit, DNS-Eintrag), Request-Headern und -Body, Regionen und Tags; oder ein Flow aus mehreren Schritten.
update_monitorÄndert beliebige der Felder oben oder pausiert und startet ihn wieder (paused); weggelassene Felder bleiben, wie sie sind.
update_monitor_stepÄndert einen Schritt an seiner Position, samt Assertions, oder fügt einen hinzu (add), dann ist der Monitor ein Flow; ein späterer Schritt kann einen Wert nutzen, den ein früherer ausliest.
remove_monitor_stepEntfernt einen Schritt eines Flows. Destruktiv.
delete_monitorDestruktiv – der Assistent fragt, bevor er es aufruft.
list_monitor_executionsDie letzten Checks eines Monitors, neueste zuerst, pro Region erfolgreich oder nicht und wie lange sie dauerten, optional nur die fehlgeschlagenen.
get_monitor_executionEin Check (standardmäßig der letzte) mit dem Ergebnis jeder Region und jedes Schritts: Statuscode, Fehler, Zeiten, Zertifikat oder DNS-Einträge und jede Assertion mit ihrem Ergebnis. Mit Link in die App.
get_monitor_statisticsUptime in Prozent, durchschnittliche Antwortzeit und Anzahl der Checks und Incidents über einen Zeitraum, wie die Übersicht des Monitors sie zeigt.
run_monitorStartet sofort einen Check, z. B. um einen Fix zu bestätigen.
list_scheduled_tasksAlle Scheduled Tasks: die Cron-Jobs und Worker, die UptimeEye per Heartbeat melden.
get_scheduled_taskDetails eines Tasks, inklusive der URL, die dein Job aufruft.
get_scheduled_task_runsStatus eines Tasks, letzter und nächster erwarteter Heartbeat und seine Heartbeats (Start, Erfolg, Fehler) in einem Zeitraum.
create_scheduled_taskTask mit einfachem Intervall (alle 5 Minuten) oder Cron-Ausdruck mit Zeitzone, plus Karenzzeit.
update_scheduled_taskÄndert Zeitplan, Karenzzeit, Kanal oder Tags oder pausiert und startet ihn wieder (paused, keine Alerts, solange pausiert).
delete_scheduled_taskDestruktiv – der Assistent fragt, bevor er es aufruft.
list_notification_channelsAlert-Ziele. Monitore und Tasks verweisen per ID auf einen Kanal.
get_notification_channel_detailsEin Kanal mit seinen Integrationen, den Monitoren und Tasks, die ihn nutzen, und seinen letzten Benachrichtigungen mit ihren Zustellungen, um herauszufinden, warum ein Alert nicht ankam.
create_notification_channelKanal mit E-Mail-, Webhook-, Teams-, Discord- oder PagerDuty-Integrationen. Slack und Telegram brauchen deine eigene Anmeldung in der App; das Tool antwortet mit der Seite dafür.
update_notification_channelBenennt einen Kanal um oder ändert seine Tags.
add_integration / update_integrationFügt einem Kanal eine Integration hinzu oder ändert ihr Ziel.
remove_integrationEntfernt eine Integration aus einem Kanal. Destruktiv.
send_test_notificationSchickt einen Test an jede Integration eines Kanals.
delete_notification_channelDestruktiv; schlägt fehl, solange Monitore den Kanal noch nutzen.
list_status_pagesDeine Statusseiten.
get_status_pageEine Statusseite mit ihren Einstellungen, Abschnitten, Komponenten, öffentlicher URL, eigenen Domains und Report-Zeitplan.
create_status_pageStatusseite mit Abschnitten aus Monitoren und Scheduled Tasks. Sie ist sofort öffentlich, deshalb zeigt der Assistent sie dir vorher.
update_status_pageÄndert Name, Slug, Sprache, Theme, Abschnitte, Abonnements oder White-Label-Branding.
delete_status_pageDestruktiv; die öffentliche URL funktioniert danach nicht mehr.
add_status_page_domainVerbindet eine eigene Domain (eine Subdomain wie status.acme.com); das Ergebnis nennt den CNAME-Eintrag, den du setzt, get_status_page ihren Stand.
delete_status_page_domainEntfernt eine eigene Domain. Destruktiv.
list_status_page_subscribers / delete_status_page_subscriberDie bestätigten Abonnenten einer Statusseite; einen zu entfernen ist destruktiv.
set_status_page_report_scheduleDer Uptime-Report einer Statusseite, wöchentlich oder monatlich per E-Mail an seine Empfänger.
list_incidentsIncidents, optional nach Status gefiltert.
get_incidentEin Incident mit seinen Updates, betroffenen Monitoren und Tasks und Statusseiten.
create_incident / create_incident_updateEröffnet einen Incident auf Statusseiten oder veröffentlicht ein Update in seinem Verlauf. Abonnenten bekommen eine E-Mail, deshalb zeigt der Assistent dir den Text vorher.
update_incident / update_incident_updateKorrigiert einen Incident oder eines seiner Updates; Besucher sehen die Änderung.
delete_incident / delete_incident_updateDestruktiv – der Assistent fragt, bevor er sie aufruft.
list_variablesDeine Variablen; den Wert einer sicheren Variable gibt kein Tool zurück.
create_variable / update_variableSetzt eine Variable, die Monitore als {{KEY}} nutzen; Secrets markierst du als sicher.
delete_variableDestruktiv; Monitore, die die Variable noch nutzen, können sie nicht mehr auflösen.
list_log_alerts / get_log_alertDeine Log-Alerts mit Bedingung, Kanal und Zustand.
create_log_alert / update_log_alertAlert, wenn mehr oder weniger Log-Zeilen als ein Schwellenwert in einem Zeitfenster auf eine LogsQL-Abfrage passen; update pausiert und startet ihn auch wieder (paused).
delete_log_alertDestruktiv – der Assistent fragt, bevor er es aufruft.
preview_log_alertMisst eine Log-Alert-Bedingung sofort: passende Zeilen und ob der Alert auslösen würde.
list_log_alert_eventsDie letzten Zustandswechsel eines Log-Alerts mit gezähltem Wert und Grund.

Dein Job schickt einem Scheduled Task seine Heartbeats: GET https://api.uptimeeye.com/v1/beat/{taskId} bei Erfolg. Optional: /start zu Beginn des Laufs und /fail, um einen fehlgeschlagenen Lauf zu melden und sofort einen Alert auszulösen. GET, POST und HEAD werden alle akzeptiert.

Logs-Tools

Fünf lesende Tools durchsuchen die Logs, die deine Services an UptimeEye Logs senden. Abfragen sind LogsQL, z. B. service:api level:error. Der Zeitraum wird mit start und end (RFC 3339) gesetzt und ist standardmäßig die letzte Stunde; jedes Ergebnis nennt den tatsächlich durchsuchten Zeitraum, den die Aufbewahrungsdauer deines Plans verkürzen kann.

ToolWas es tut
query_logsDurchsucht die Logs mit einer LogsQL-query, neueste zuerst. Optional start, end und limit (Standard 50, höchstens 200). Lange Werte werden gekürzt, und das Ergebnis sagt, ob Zeilen oder Werte gekürzt wurden.
logs_histogramLog-Volumen über die Zeit für eine query (etwa 48 Intervalle), um zu sehen, wann Fehler begannen oder sprunghaft anstiegen.
logs_fieldsWelche Felder es in den passenden Logs gibt und wie viele Einträge jedes davon tragen, damit Abfragen existierende Feldnamen nutzen.
logs_facetsDie häufigsten Werte eines field (z. B. service, level, host), optional eingeschränkt durch eine query. limit Standard 10, höchstens 50.
get_log_contextKontext zu einem entry aus einem query_logs-Ergebnis: seine Fehlersignatur, wie oft er in den letzten 24 Stunden auftrat, und zugehörige Einträge (gleicher Trace oder Request, sonst die vorangehenden Zeilen desselben Service).
Hinweis: Die Logs-Tools brauchen einen Plan mit Logs. Hat der Plan keine Logs oder sind noch keine Logs angekommen, sagt das Tool das und was zu tun ist. Ein Management-Key kann alle Logs der Organisation lesen: Wer den Key hat, kann die Logs jedes Service innerhalb der Aufbewahrungsdauer deines Plans durchsuchen. Ein mit deinem Konto angemeldeter Connector liest Logs nur bei eingeschaltetem Log-Zugriff (Assistenten-Einstellungen, nur Admins).

Beispiel-Prompts

  • „Überwache https://shop.example.com jede Minute aus eu-central-1 und us-east-1 und schick mir eine E-Mail an ops@example.com, wenn die Seite down oder langsamer als 2 Sekunden ist.“
  • „Leg einen Heartbeat für unser nächtliches Backup um 02:30 Europe/Berlin mit 30 Minuten Karenzzeit an und gib mir die curl-Zeile für die Crontab.“
  • „Schick mir einen Alert, wenn unser Postgres auf db.example.com:5432 keine Verbindungen mehr annimmt – prüfe jede Minute.“
  • „Welche Monitore sind gerade down, und gibt es offene Incidents?“
  • „Der Checkout-Monitor ist um 14:05 ausgefallen. Was hat der Checkout-Service um diese Zeit geloggt, und ist der Fehler neu?“
  • „Tagge jeden Monitor, dessen URL staging enthält, mit staging und pausiere sie.“
  • „Verschiebe alle Monitore vom Channel ‚Old alerts‘ nach ‚On-call‘ und lösche dann ‚Old alerts‘.“

Ein Projekt mit einem AI-Agent einrichten

Coding-Agents (Claude Code, Cursor, Copilot) können dein Repository und die UptimeEye-Doku gleichzeitig lesen. Füge einen dieser Prompts in den Agent in deinem Projekt ein; Endpoints, Jobs und Stack findet er selbst.

Jeden öffentlichen Endpoint überwachen

Read https://uptimeeye.com/llms.txt. Find the public URLs and health endpoints of this project (routes, deployment config, README). Using the UptimeEye MCP server, create one monitor per endpoint: 30 s interval if my plan allows it, expected status 200, attached to the notification channel I pick. Show me the list before you create anything.

Heartbeats für Cron-Jobs ergänzen

Find every cron job, scheduled worker and CI schedule in this repository. For each one, create an UptimeEye scheduled task via MCP with the matching schedule and a sensible grace period. Then change the job so it calls https://api.uptimeeye.com/v1/beat/<taskId> on success and https://api.uptimeeye.com/v1/beat/<taskId>/fail on error.

Logs senden

Add UptimeEye log shipping to this project. Follow https://uptimeeye.com/docs/logs/ingest and pick the integration guide that matches our stack (Kubernetes, Docker, OpenTelemetry, Node.js, Python, Go, Spring Boot, .NET, …). Read the ingest key from the environment variable UPTIMEEYE_INGEST_KEY and use service and env as stream fields.
Hinweis: Den Log-Ingest-Key (ue_ingest_…) erstellst du in der App unter API-Keys – der MCP-Server kann keine Keys anlegen.

Rechte & Sicherheit

  • Ein Management-Key handelt für eine Organisation mit denselben Rechten wie die REST-API. Erstelle einen Key pro Client, damit du sie einzeln widerrufen kannst.
  • Ein in Claude angemeldeter Connector handelt als du in der gewählten Organisation, mit deiner Rolle dort. Trenn ihn in Claude, um ihn zu widerrufen; wirst du aus der Organisation entfernt oder fehlt dir ein Platz, verliert er den Zugriff innerhalb einer Minute.
  • Ein Management-Key kann wie ein angemeldeter Connector alle Logs der Organisation lesen, innerhalb der Aufbewahrungsdauer deines Plans, über die Logs-Tools und die REST-API. Eine engere Log-Berechtigung gibt es nicht, behandle beide also wie die Logs selbst.
  • Lösch-Tools sind als destruktiv annotiert, und der Server weist den Assistenten an, vorher ausdrücklich nachzufragen.
  • Plan-Limits gelten genau wie in der App – der Assistent kann deine Monitor-Anzahl oder dein Mindestintervall nicht überschreiten.
  • Keys werden gehasht gespeichert; der Klartext-Key wird nur einmal beim Erstellen angezeigt. Anfragen werden in der EU (Deutschland) verarbeitet.

Lieber Infrastructure as Code? Dieselben Operationen gibt es über den Terraform-Provider.

FAQ

Was ist der UptimeEye MCP-Server?

Ein Model-Context-Protocol-Endpoint unter https://api.uptimeeye.com/mcp (Streamable HTTP). AI-Assistenten, die MCP sprechen, können Monitore und Flows, Scheduled Tasks, Benachrichtigungskanäle, Statusseiten, Incidents, Log-Alerts und Variablen deiner Organisation auflisten, anlegen und ändern – dieselben Operationen wie über die REST-API und den Terraform-Provider – und die Logs der Organisation durchsuchen.

Welchen Plan brauche ich?

Jeden Plan, auch Free. Der Assistent arbeitet innerhalb der Limits deines Plans: Fragst du nach mehr Monitoren oder einem kürzeren Intervall, als der Plan erlaubt, liefert das Tool das Limit zurück und der Assistent sagt es dir. Die Logs-Tools brauchen einen Plan mit Logs, ein angemeldeter Connector außerdem den eingeschalteten Log-Zugriff.

Welche Clients funktionieren?

Claude (claude.ai, Claude Desktop und Claude Code) verbindet sich per Anmeldung, ohne Key: siehe In Claude verbinden. Jeder andere MCP-Client, der über Streamable HTTP einen Authorization-Header senden kann, funktioniert mit einem Management-Key: Cursor, VS Code, Windsurf und weitere. Clients, die nur lokale stdio-Server unterstützen, verbinden sich über die mcp-remote-Bridge, die Node.js braucht.

Kann eine Verbindung in mehreren Organisationen arbeiten?

Ja, mit Anmeldung: Ein Connector funktioniert in jeder Organisation, in der du Mitglied bist. Die beim Verbinden gewählte Organisation ist der Standard; nenn im Chat eine andere, z. B. „liste die Monitore von Kunde B“, und Claude gibt sie den Tools als organization mit (list_organizations zeigt deine). Ein Management-Key funktioniert nur in seiner eigenen Organisation.

Mein UptimeEye-Connector in Claude zeigt „Couldn't connect“. Was tun?

Ein Connector, der als benutzerdefinierter Connector angelegt wurde, bevor es die Anmeldung gab, behält seine alten Einstellungen, und Reconnect behebt das nicht. Entfern ihn unter Customize → Connectors (⋯ → Remove) und verbinde UptimeEye aus dem Claude-Verzeichnis; klick dann auf Connect und Allow.

Kann der Assistent Slack-, Teams- oder PagerDuty-Alerts einrichten?

E-Mail-Integrationen ja, bei jeder Verbindung. Webhook, Teams, Discord und PagerDuty brauchen eine Webhook-URL oder einen Routing-Key, also Zugangsdaten: Mit API-Key richtet der Assistent sie über MCP ein; ein mit deinem UptimeEye-Konto angemeldeter Connector fragt nie danach und antwortet stattdessen mit der Seite des Kanals in der App. Slack und Telegram brauchen deine eigene Anmeldung in der App; dafür antwortet das Tool mit der Seite, auf der du sie verbindest. Steht der Kanal, verknüpft der Assistent jeden Monitor per ID damit.

Kann der Assistent meine Logs lesen?

Ja, wenn dein Plan Logs enthält. Die lesenden Tools query_logs, logs_histogram, logs_fields, logs_facets und get_log_context durchsuchen deine Logs mit LogsQL, zeigen ihr Volumen über die Zeit und ordnen einen einzelnen Fehlereintrag ein. Ein Management-Key kann alle Logs der Organisation lesen. Ein mit deinem Konto angemeldeter Connector liest sie nur, solange ein Admin den Log-Zugriff in den Assistenten-Einstellungen eingeschaltet hat (das Zahnrad im Assistenten in der App); sonst sagt das das Logs-Tool und verlinkt die Einstellung. Um zuerst Logs zu senden, folge der Logs-Doku – ein Coding-Agent kann das für dich einrichten (siehe die Prompts oben).

Wie widerrufe ich den Zugriff?

Lösch den Key in der App unter API-Keys: Jeder Client, der ihn nutzt, verliert sofort den Zugriff. Einen Connector trennst du in Claude; er funktioniert außerdem innerhalb einer Minute nicht mehr, sobald du aus der Organisation entfernt wirst.