# Claude Routines Push-Benachrichtigungen: wissen, wann ein Cloud-Lauf dich braucht

> Claude Routines laufen per Zeitplan, API-Aufruf oder GitHub-Event in Anthropics Cloud und sagen niemandem Bescheid, wenn sie fertig sind. So bekommst du eine Push-Benachrichtigung aufs Handy, wenn ein Lauf fertig ist, fehlschlägt oder etwas findet.

*18.10.2026*

<!-- source: https://pocketalert.app/de/blog/claude-routines-notifications -->

Claude Routines sind der Teil von Claude Code, der ohne dich läuft. Du speicherst einmal einen Prompt und ein Repository, und Anthropics Cloud startet jede Nacht, bei jedem neuen Pull Request oder wenn dein Monitoring einen Endpoint aufruft, eine frische Claude-Code-Session. Dein Laptop darf dabei zugeklappt sein.

Der Haken: Eine Routine meldet sich bei niemandem. Das Ergebnis liegt in einer Session auf claude.ai, bis du nachschaust, und die Laufliste hilft auch nicht viel. Ein grüner Status heißt nur, dass die Session gestartet und ohne Infrastrukturfehler beendet wurde, nicht dass die Arbeit erfolgreich war. Ein nächtlicher Abhängigkeits-Check, der einen kaputten Build gefunden hat, sieht genauso aus wie einer, der nichts gefunden hat.

Diese Anleitung lässt die Routine über Pocket Alert eine Push-Benachrichtigung aufs Handy schicken: eine leise, wenn alles in Ordnung ist, eine laute, wenn etwas deine Aufmerksamkeit braucht.

## Was Claude Routines kurz gesagt sind

Anthropic nennt sie inzwischen **Scheduled Tasks**. „Routines“ ist der frühere Name und taucht noch in der Web-Adresse (`claude.ai/code/routines`), im CLI-Alias `/routines` und in der API auf. Es ist dasselbe Feature, derzeit in der Research Preview.

Eine Routine ist eine gespeicherte Claude-Code-Konfiguration: ein Prompt, ein oder mehrere GitHub-Repositories, eine Cloud-Umgebung und eine Reihe von Connectors. Jeder Lauf ist eine vollwertige Cloud-Session, die Shell-Befehle ausführen, Code bearbeiten, in einen `claude/`-Branch pushen und Connectors aufrufen kann. Läufe starten über Trigger, und eine Routine kann mehrere davon haben:

- **Zeitplan**: stündlich, täglich, wöchentlich als Vorlagen, ein eigener Cron-Ausdruck (höchstens einmal pro Stunde) oder ein einmaliger Lauf zu einer festen Zeit.
- **API**: ein POST an den eigenen `/fire`-Endpoint der Routine mit einem Bearer-Token. Du kannst ein Feld `text` übergeben, etwa den Inhalt eines Alerts, den der Lauf als Kontext erhält.
- **GitHub**: Pull-Request-, Release- oder Issue-Events auf einem Repository, auf dem die Claude-GitHub-App installiert ist, mit Pull-Request-Filtern nach Autor, Branch, Labels, Draft-Status und mehr.

Routinen erstellst du unter [claude.ai/code/routines](https://claude.ai/code/routines) mit **New task**, in der Desktop-App oder mit `/schedule` in der Claude-Code-CLI, zum Beispiel `/schedule daily PR review at 9am`. Dafür brauchst du einen Pro-, Max-, Team- oder Enterprise-Tarif, und Läufe verbrauchen dein Abo-Kontingent so wie interaktive Sessions.

## Was du brauchst

- Ein Pocket-Alert-Konto, einen API-Schlüssel aus [API-Schlüssel](/account/apikeys) und die App auf deinem [iPhone oder Android](/get-app)-Handy. Der kostenlose Tarif reicht.
- Eine Routine oder einen Plan dafür.

Es gibt zwei Wege, wie ein Lauf auf dein Handy kommt: `curl` aus der Session an die Pocket-Alert-API oder der [Pocket-Alert-MCP-Server](/tools/mcp), eingebunden als Connector. Fang mit curl an. Es funktioniert in jedem Tarif mit Routines, und der Schlüssel gelangt nie in die Session.

## Einrichtung: curl mit einem Netzwerk-Secret

Die Cloud-Umgebung einer Routine hat standardmäßig den Netzwerkzugriff **Trusted**: Paket-Registries, GitHub und die APIs der Cloud-Anbieter, sonst nichts. `api.pocketalert.app` steht nicht auf dieser Liste, ein einfaches `curl` würde also mit `403` und `x-deny-reason: host_not_allowed` scheitern.

Ein **Netzwerk-Secret** löst beide Probleme, das Netzwerk und das Schlüsselproblem. Du hinterlegst den Schlüssel an der Umgebung, und Anthropics Proxy fügt ihn Anfragen an die Hosts hinzu, die du auflistest, nachdem sie die VM der Session verlassen haben. Hosts in einem Netzwerk-Secret sind unabhängig von der Zugriffsstufe erreichbar, und Claude sieht den Schlüssel nie.

1. Öffne die Routine unter [claude.ai/code/routines](https://claude.ai/code/routines), wähle **Edit** und dann **Advanced settings > General > Cloud environment**. Fahre über die Umgebung und klicke auf ihr Einstellungssymbol.
2. Klicke unter **Network secrets** auf **Add secret** und lasse den Typ **Bearer**.
3. **Name**: `Pocket Alert`. **Allowed websites**: `api.pocketalert.app`.
4. Unter **Custom headers** änderst du den Header-Namen von `Authorization` zu `Token`, entfernst das Präfix `Bearer` und fügst deinen API-Schlüssel als Wert ein.
5. Klicke auf **Add**. Das Secret wird sofort gespeichert und lässt sich danach nicht mehr einsehen.

Jetzt braucht die Anfrage überhaupt keinen Schlüssel mehr. Füge das ans Ende des Prompts der Routine:

```text
When you are done, send exactly one push notification with curl:

curl -sS https://api.pocketalert.app/v1/messages \
  -H 'Content-Type: application/json' \
  --data-binary @- <<'EOF'
{"title": "<routine name>: <one-line result>", "message": "<2-3 sentence summary>", "level": "<level>"}
EOF

Do not add any auth header; the environment adds it. Build valid JSON.
Pick the level:
- "low" if the run finished and nothing needs my attention.
- "default" if you opened a pull request or found something worth reading today.
- "high" only if the work failed, tests are broken, or you found a real problem.
Include the session link from:
echo "https://claude.ai/code/${CLAUDE_CODE_REMOTE_SESSION_ID/#cse_/session_}"
```

Die letzte Zeile stammt aus Anthropics Dokumentation: Jede Cloud-Session kann ihre ID aus `CLAUDE_CODE_REMOTE_SESSION_ID` lesen, und dieser Befehl macht daraus die URL des Transkripts. Mit ihr in der Nachricht kommst du mit einem Tipp von der Push-Benachrichtigung direkt zum Lauf.

Klicke auf der Seite der Routine auf **Run now**, um sie vor dem ersten geplanten Lauf zu testen.

Falls dein Umgebungsdialog keine Zeile **Custom headers** hat (im Team-Tarif ohne Admin-Rolle fragt das Formular nur nach Host und Wert), setze **Network access** auf **Custom**, füge `api.pocketalert.app` unter **Allowed domains** hinzu und lass die Standardliste stehen. Den Schlüssel legst du dann in einer Umgebungsvariable wie `POCKETALERT_KEY` ab und sendest ihn mit `-H "Token: $POCKETALERT_KEY"`. Beachte, dass Umgebungsvariablen für jeden lesbar sind, der die Umgebung nutzt. Deshalb ist das Secret die bessere Wahl.

## Oder den MCP-Server als Connector einbinden

Routinen können deine claude.ai-Connectors nutzen, und der Connector-Verkehr läuft über Anthropics Server. Dafür musst du gar nichts an der Allowlist ändern. Der Prompt sagt dann nur: „call the pocketalert `create_message` tool“ mit Titel, Nachricht und Level.

Die Grenze ist die Authentifizierung. Der Pocket-Alert-MCP-Server nimmt den API-Schlüssel als `Authorization: Bearer KEY` entgegen, und auf claude.ai kann ein eigener Connector einen festen Schlüssel nur über den Bereich **Request headers** im Dialog **Add custom connector** senden. Anthropic markiert diesen Bereich als Beta, die einer begrenzten Zahl von Organisationen zur Verfügung steht. Falls du ihn siehst (in Team- und Enterprise-Tarifen fügt ein Owner den Connector stattdessen unter **Organization settings > Connectors** hinzu):

1. Gehe zu [claude.ai/customize/connectors](https://claude.ai/customize/connectors) und klicke auf **Add custom connector**.
2. URL: `https://mcp.pocketalert.app/mcp`. Authentication: **No sign-in**.
3. Wähle unter **Request headers** `authorization` und trage `Bearer YOUR_API_KEY` ein.

Neue Routinen enthalten standardmäßig alle deine Connectors, also prüfe den Tab **Connectors** der Routine und behalte nur die, die sie braucht. Der Befehl `claude mcp add` der Claude-Code-CLI hilft hier nicht: So hinzugefügte Server liegen auf deinem Rechner und tauchen in Routinen nicht auf. Wenn du Claude Code auch lokal nutzt, steht die Einrichtung dafür in [Claude-Code-Push-Benachrichtigungen](/blog/claude-code-push-notifications). Weitere MCP-Optionen findest du unter [Beste MCP-Benachrichtigungsserver](/blog/best-mcp-notification-servers).

## Zweite Ebene: eine Push-Benachrichtigung, die nicht vom Modell abhängt

Beide Wege oben setzen voraus, dass Claude dem letzten Absatz deines Prompts folgt. Meistens tut es das. Ein Lauf, der an ein Rate-Limit oder einen API-Fehler stößt, erreicht diesen Absatz aber nie, und genau über diesen Lauf willst du am ehesten Bescheid wissen.

Hooks laufen auch in Routinen: Eine Cloud-Session mit einem Repository liest die Datei `.claude/settings.json` des Repositorys. Ein `Stop`-Hook feuert, wenn Claude fertig ist, und `StopFailure` feuert stattdessen, wenn der Durchlauf mit einem API-Fehler wie `rate_limit` oder `server_error` endet. Committe das als `.claude/settings.json`:

```json
{
  "hooks": {
    "Stop": [
      { "hooks": [{ "type": "command", "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/notify.sh done" }] }
    ],
    "StopFailure": [
      { "hooks": [{ "type": "command", "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/notify.sh failed" }] }
    ]
  }
}
```

Und das Skript `.claude/hooks/notify.sh`, ausführbar gemacht:

```bash
#!/usr/bin/env bash
[ "$CLAUDE_CODE_REMOTE" = "true" ] || exit 0

payload=$(cat)
last=$(jq -r '.last_assistant_message // ""' <<<"$payload")
link="https://claude.ai/code/${CLAUDE_CODE_REMOTE_SESSION_ID/#cse_/session_}"

if [ "$1" = "failed" ]; then
  title="Claude run failed: $(jq -r '.error // "unknown"' <<<"$payload")"
  level=high
else
  title="Claude run finished · $(basename "$CLAUDE_PROJECT_DIR")"
  level=low
fi

jq -n --arg t "$title" --arg m "${last:0:300}
$link" --arg l "$level" '{title: $t, message: $m, level: $l}' |
  curl -sS --max-time 10 https://api.pocketalert.app/v1/messages \
    -H 'Content-Type: application/json' --data-binary @- >/dev/null 2>&1 || true
```

Die Prüfung auf `CLAUDE_CODE_REMOTE` hält den Hook auf deinem Laptop still, dort ist die Variable nie `true`. `jq` ist in Cloud-Sessions vorinstalliert, und das Netzwerk-Secret aus dem ersten Abschnitt liefert den Schlüssel. Behalte die Push-Benachrichtigung über den Prompt für den Inhalt („3 veraltete Pakete, PR geöffnet“) und den Hook als garantiertes Signal „es ist fertig“, oder nutze nur eins von beiden.

Der Hook feuert für jede Cloud-Session auf diesem Repository, nicht nur für Routinen-Läufe. Rechne also auch dort mit einer Push-Benachrichtigung, wenn du Claude Code im Web nutzt.

## Level und Buttons

Der Prompt oben nutzt bereits das Wichtigste: die Level. `low` kommt leise an und bleibt im Verlauf, `high` wird auf dem iPhone als zeitkritisch zugestellt und umgeht den Fokus. Die Regel „high nur bei Problemen“ verhindert, dass du das Ganze nach einer Woche stummschaltest. `critical` gibt es auch, es durchbricht „Nicht stören“ in den kostenpflichtigen Tarifen, aber eine nächtliche Routine verdient es selten. Wie sich jedes Level auf iOS und Android verhält, steht unter [Prioritätsstufen](https://info.pocketalert.app/features/priority-levels.html).

In den kostenpflichtigen Tarifen kann eine Nachricht bis zu drei [Aktionsbuttons](https://info.pocketalert.app/features/action-buttons.html) enthalten. Nützlich ist hier ein `view`-Button mit der Session-URL, im JSON so ergänzt:

```json
"actions": [{"type": "view", "label": "Open run", "value": "https://claude.ai/code/session_..."}]
```

Jede Push-Benachrichtigung landet außerdem im Verlauf der App und im Web-Dashboard, neben den Alerts deiner Server und CI. Eine Woche nächtlicher Läufe ist also ein einziges Scrollen.

## Ehrliche Grenzen

- **Der Prompt ist eine Bitte, keine Garantie.** Claude schickt die Push-Benachrichtigung meist, kann sie aber auslassen, zwei senden oder das JSON falsch schreiben. Nutze den Hook, wenn du Sicherheit brauchst.
- **Ein Lauf kann anhalten und warten.** Routinen starten im Auto-Modus, aber eine Aktion, die einer Ask-Regel entspricht, oder wiederholte Blockaden lassen den Lauf auf eine Antwort in seiner Session warten. Weder der Prompt noch `Stop` melden dieses Warten. Wenn eine Routine dich sonst um 7:10 Uhr anpingt und es diesmal nicht tut, schau nach.
- **Nutzungslimits gelten.** Läufe zählen gegen dein Abo. Ohne Nutzungsguthaben werden zusätzliche Läufe abgelehnt, sobald du das Limit erreichst, und ein Lauf, der nie startet, sendet nichts. Außerdem gibt es stündliche Obergrenzen: 100 geplante Läufe pro Konto, 30 Run-now- oder API-Aufrufe pro Routine.
- **Research Preview.** Anthropic sagt, dass sich Verhalten, Limits und API noch ändern können.
- **Kostenloser Tarif.** 50 Nachrichten pro Tag auf einem Gerät. Eine stündliche Routine mit einer Push-Benachrichtigung pro Lauf passt; eine Push-Benachrichtigung pro geänderter Datei nicht.

## Wenn nichts ankommt

1. **Öffne den Lauf.** Jeder Lauf im **History** der Routine öffnet sich als vollständige Session. Suche im Transkript nach `api.pocketalert.app` und lies die Ausgabe von curl.
2. **`403` mit `host_not_allowed`.** Das Secret ist nicht an der Umgebung hinterlegt, die diese Routine nutzt, oder der Host ist falsch geschrieben. Prüfe **Allowed websites**.
3. **`401`.** „No token provided“ heißt, dass kein Schlüssel die API erreicht hat: Das Secret ist nicht angehängt oder der Header-Name ist falsch geschrieben. „token contains an invalid number of segments“ heißt, dass der Header noch `Authorization` ist; ändere ihn zu `Token`. „Invalid token“ heißt, dass noch das Präfix `Bearer` drinsteht oder der Schlüssel widerrufen wurde.
4. **`400`.** Der Body ist kein gültiges JSON, meist wegen eines nicht maskierten Anführungszeichens in der Zusammenfassung. Die Hook-Variante baut das JSON mit `jq`, das verhindert das.
5. **Hook läuft nie.** Prüfe, ob `.claude/settings.json` im Default-Branch committet ist, das Skript ausführbar ist und die Routine nur ein Repository hat.

## FAQ

### Sind Claude Routines und Scheduled Tasks dasselbe?

Ja. Anthropic hat Routines in Scheduled Tasks umbenannt. Die Web-Adresse, der Alias `/routines` und die API behalten den alten Namen.

### Sieht die Routine meinen Pocket-Alert-API-Schlüssel?

Mit einem Netzwerk-Secret nicht. Der Proxy fügt den Header hinzu, nachdem die Anfrage die Session verlassen hat, der Schlüssel steht also in keiner Umgebungsvariable und keiner Datei, die Claude lesen kann. Bei einer Umgebungsvariable ist er innerhalb der Session lesbar.

### Kann mich eine Routine nachts wecken?

Mit `"level": "critical"` im kostenpflichtigen Tarif ja. Reserviere das für Routinen, die Produktivsysteme überwachen, etwa eine API-gesteuerte Routine, die dein Monitoring bei einem Fehler-Peak auslöst.

### Was ist mit lokaler Planung über /loop oder Desktop-Scheduled-Tasks?

Die laufen auf deinem Rechner, deshalb funktionieren lokale Claude-Code-Hooks und MCP-Server wie gewohnt. Die Einrichtung steht unter [Claude-Code-Push-Benachrichtigungen](/blog/claude-code-push-notifications). Weitere Muster für Agenten findest du unter [KI-Agenten-Alerts](/use-cases/ai-agent-alerts).

[Kostenloses Konto erstellen](/signup), das Secret hinterlegen und den Routine-Lauf von morgen früh erzählen lassen, wie er gelaufen ist.
