# Notifiche push per le routine di Claude: sapere quando un run richiede la tua attenzione

> Le routine di Claude girano nel cloud di Anthropic su una pianificazione, una chiamata API o un evento GitHub, e non avvisano nessuno quando finiscono. Ecco come ricevere una notifica push sul telefono quando un run è completato, fallisce o trova qualcosa.

*18.10.2026*

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

Le routine di Claude sono la parte di Claude Code che funziona senza che tu debba fare nulla. Salvi una volta un prompt e un repository, e il cloud di Anthropic avvia una nuova sessione di Claude Code ogni notte, a ogni nuova pull request, oppure ogni volta che il tuo sistema di monitoraggio chiama un endpoint. Il tuo portatile può restare chiuso.

Il problema è che una routine non riferisce a nessuno. Il risultato resta in una sessione su claude.ai finché non vai a guardarlo, e anche l'elenco dei run non aiuta molto: uno stato verde significa solo che la sessione è partita e si è chiusa senza errori di infrastruttura, non che il lavoro sia riuscito. Un controllo notturno delle dipendenze che ha trovato una build rotta appare identico a uno che non ha trovato nulla.

Questa guida fa in modo che la routine invii una notifica push al tuo telefono tramite Pocket Alert: una silenziosa quando tutto va bene, una rumorosa quando qualcosa richiede il tuo intervento.

## Cosa sono le routine di Claude, in breve

Anthropic ora le chiama **attività pianificate**. "Routine" è il nome precedente e compare ancora nell'indirizzo web (`claude.ai/code/routines`), nell'alias CLI `/routines` e nell'API. È la stessa funzionalità, attualmente in anteprima di ricerca.

Una routine è una configurazione salvata di Claude Code: un prompt, uno o più repository GitHub, un ambiente cloud e un insieme di connettori. Ogni run è una sessione cloud completa che può eseguire comandi shell, modificare codice, fare push su un branch `claude/` e chiamare connettori. I run partono da trigger, e una routine può averne più di uno:

- **Pianificazione**: preset orari, giornalieri o settimanali, un'espressione cron personalizzata (non più di una volta all'ora), oppure un run unico a un orario prestabilito.
- **API**: una POST all'endpoint `/fire` dedicato della routine con un bearer token. Puoi passare un campo `text`, come il corpo di un alert, che il run riceve come contesto.
- **GitHub**: eventi di pull request, release o issue su un repository con la GitHub App di Claude installata, con filtri sulle pull request per autore, branch, etichette, stato di bozza e altro.

Crei le routine su [claude.ai/code/routines](https://claude.ai/code/routines) con **New task**, nell'app Desktop, oppure con `/schedule` nella CLI di Claude Code, per esempio `/schedule daily PR review at 9am`. Richiedono un piano Pro, Max, Team o Enterprise, e i run consumano il tuo utilizzo dell'abbonamento come le sessioni interattive.

## Di cosa hai bisogno

- Un account Pocket Alert, una chiave API da [Chiavi API](/account/apikeys) e l'app sul tuo telefono [iPhone o Android](/get-app). Il piano gratuito funziona.
- Una routine, o un piano per crearne una.

Ci sono due modi per far arrivare un run al tuo telefono: `curl` dalla sessione verso l'API di Pocket Alert, oppure il [server MCP di Pocket Alert](/tools/mcp) aggiunto come connettore. Inizia con curl. Funziona su tutti i piani che includono le routine, e la chiave non entra mai nella sessione.

## Configurazione: curl con un segreto di rete

L'ambiente cloud di una routine ha per default l'accesso di rete **Trusted**: registry di pacchetti, GitHub e API dei provider cloud, nient'altro. `api.pocketalert.app` non è in questa lista, quindi un `curl` semplice fallirebbe con `403` e `x-deny-reason: host_not_allowed`.

Un **segreto di rete** risolve sia il problema della rete sia quello della chiave. Salvi la chiave sull'ambiente, e il proxy di Anthropic la aggiunge alle richieste verso gli host che elenchi, dopo che escono dalla VM della sessione. Gli host con un segreto di rete sono raggiungibili qualunque sia il livello di accesso, e Claude non vede mai la chiave.

1. Apri la routine su [claude.ai/code/routines](https://claude.ai/code/routines), scegli **Edit**, poi **Advanced settings > General > Cloud environment**. Passa sopra l'ambiente e clicca sulla sua icona delle impostazioni.
2. In **Network secrets**, clicca **Add secret** e lascia il tipo **Bearer**.
3. **Name**: `Pocket Alert`. **Allowed websites**: `api.pocketalert.app`.
4. In **Custom headers**, cambia il nome dell'header da `Authorization` a `Token`, elimina il prefisso `Bearer` e incolla la tua chiave API come valore.
5. Clicca **Add**. Il segreto viene salvato subito e non può più essere visualizzato.

Ora la richiesta non ha bisogno di alcuna chiave. Aggiungi questo in fondo al prompt della 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_}"
```

L'ultima riga viene dalla documentazione di Anthropic: ogni sessione cloud può leggere il proprio ID da `CLAUDE_CODE_REMOTE_SESSION_ID`, e quel comando lo trasforma nell'URL della trascrizione. Con questo nel messaggio, passi dalla notifica al run con un solo tocco.

Clicca **Run now** nella pagina della routine per testarla prima della prima esecuzione pianificata.

Se la finestra dell'ambiente non ha la riga **Custom headers** (con un piano Team senza il ruolo di amministratore, il modulo chiede solo un host e un valore), imposta **Network access** su **Custom**, aggiungi `api.pocketalert.app` in **Allowed domains** lasciando invariata la lista predefinita, e metti la chiave in una variabile d'ambiente come `POCKETALERT_KEY`, inviata come `-H "Token: $POCKETALERT_KEY"`. Tieni presente che le variabili d'ambiente sono leggibili da chiunque usi l'ambiente, ed è per questo che il segreto è l'opzione migliore.

## Oppure collega il server MCP come connettore

Le routine possono usare i tuoi connettori di claude.ai, e il traffico dei connettori passa dai server di Anthropic, quindi non richiede alcuna modifica alla allowlist. In questo caso il prompt dice semplicemente "chiama lo strumento `create_message` di pocketalert" con titolo, messaggio e livello.

Il limite è l'autenticazione. Il server MCP di Pocket Alert accetta la chiave API come `Authorization: Bearer KEY`, e su claude.ai un connettore personalizzato può inviare una chiave fissa solo tramite la sezione **Request headers** della finestra **Add custom connector**. Anthropic indica questa sezione come beta disponibile a un numero limitato di organizzazioni. Se la vedi (nei piani Team ed Enterprise un Owner aggiunge il connettore da **Organization settings > Connectors**):

1. Vai su [claude.ai/customize/connectors](https://claude.ai/customize/connectors) e clicca **Add custom connector**.
2. URL: `https://mcp.pocketalert.app/mcp`. Authentication: **No sign-in**.
3. In **Request headers**, scegli `authorization` e inserisci `Bearer YOUR_API_KEY`.

Le nuove routine includono per default tutti i tuoi connettori, quindi controlla la scheda **Connectors** della routine e tieni solo quelli che servono. Il comando `claude mcp add` della CLI di Claude Code non aiuta qui: i server aggiunti in quel modo vivono sulla tua macchina e non compaiono nelle routine. Se usi Claude Code anche in locale, quella configurazione è descritta in [notifiche push per Claude Code](/blog/claude-code-push-notifications); per altre opzioni MCP vedi [i migliori server MCP per le notifiche](/blog/best-mcp-notification-servers).

## Secondo livello: una push che non dipende dal modello

Entrambe le soluzioni sopra si basano sul fatto che Claude segua l'ultimo paragrafo del prompt. Di solito lo fa. Ma un run che incontra un rate limit o un errore API non arriva mai a quel paragrafo, ed è proprio il run di cui vorresti sapere.

Gli hook funzionano anche nelle routine: una sessione cloud con un repository legge il file `.claude/settings.json` del repository. Un hook `Stop` si attiva quando Claude termina, mentre `StopFailure` si attiva al posto suo quando il turno finisce con un errore API come `rate_limit` o `server_error`. Committa questo come `.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" }] }
    ]
  }
}
```

E lo script, `.claude/hooks/notify.sh`, reso eseguibile:

```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
```

Il controllo su `CLAUDE_CODE_REMOTE` mantiene l'hook silenzioso sul tuo portatile, dove quella variabile non è mai `true`. `jq` è preinstallato nelle sessioni cloud, e il segreto di rete della prima sezione fornisce la chiave. Mantieni la push basata sul prompt per il contenuto ("3 pacchetti obsoleti, PR aperta") e l'hook come segnale garantito di "è finito", oppure usane solo uno.

L'hook si attiva per ogni sessione cloud su quel repository, non solo per i run delle routine, quindi aspettati una notifica anche quando usi Claude Code sul web con quel repository.

## Livelli e pulsanti

Il prompt qui sopra usa già la parte più importante: i livelli. `low` arriva in silenzio e resta nello storico, `high` arriva come urgente su iPhone e supera Full immersion. La regola "high solo per i problemi" ti evita di silenziare tutto dopo una settimana. Esiste anche `critical`, che su piani a pagamento supera Non disturbare, ma una routine notturna raramente lo merita. Vedi [livelli di priorità](https://info.pocketalert.app/features/priority-levels.html) per il comportamento di ciascun livello su iOS e Android.

Sui piani a pagamento un messaggio può contenere fino a tre [pulsanti di azione](https://info.pocketalert.app/features/action-buttons.html). Quello utile qui è un pulsante `view` con l'URL della sessione, da aggiungere al JSON così:

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

Ogni notifica finisce anche nello storico dell'app e nella dashboard web, accanto agli avvisi dei tuoi server e della CI, così una settimana di run notturni si riduce a un solo scorrimento.

## Limiti onesti

- **Il prompt è una richiesta, non una garanzia.** Claude di solito invia la notifica, ma può saltarla, inviarne due o scrivere il JSON in modo errato. Usa l'hook se ti serve certezza.
- **Un run può fermarsi e aspettare.** Le routine partono in modalità automatica, ma un'azione che corrisponde a una regola di richiesta, o blocchi ripetuti, fa sì che il run attenda una risposta nella sua sessione. Né il prompt né `Stop` ti avviseranno di questa attesa. Se una routine di solito ti scrive alle 7:10 e oggi non lo fa, vai a controllare.
- **Si applicano i limiti di utilizzo.** I run contano sull'abbonamento. Senza crediti di utilizzo extra, i run aggiuntivi vengono rifiutati una volta raggiunto il limite, e un run che non parte non invia nulla. Ci sono anche limiti orari: 100 run pianificati per account, 30 Run now o chiamate API per routine.
- **Anteprima di ricerca.** Anthropic dice che comportamento, limiti e API potrebbero ancora cambiare.
- **Piano gratuito.** 50 messaggi al giorno su un dispositivo. Una routine oraria che invia una notifica per run rientra nel limite; una notifica per ogni file modificato no.

## Se non arriva nulla

1. **Apri il run.** Ogni run nella **History** della routine si apre come sessione completa. Cerca `api.pocketalert.app` nella trascrizione e leggi l'output di curl.
2. **`403` con `host_not_allowed`.** Il segreto non è collegato all'ambiente usato da questa routine, oppure l'host è scritto male. Controlla **Allowed websites**.
3. **`401`.** "No token provided" significa che nessuna chiave ha raggiunto l'API: il segreto non è collegato oppure il nome dell'header è sbagliato. "token contains an invalid number of segments" significa che l'header è ancora `Authorization`; cambialo in `Token`. "Invalid token" significa che il prefisso `Bearer` è ancora presente oppure che la chiave è stata revocata.
4. **`400`.** Il corpo non è JSON valido, di solito per una virgoletta non escapata nel riepilogo. La versione con hook costruisce il JSON con `jq`, che evita il problema.
5. **L'hook non si è mai attivato.** Verifica che `.claude/settings.json` sia committato sul branch predefinito, che lo script sia eseguibile e che la routine abbia un solo repository.

## FAQ

### Le routine di Claude e le attività pianificate sono la stessa cosa?

Sì. Anthropic ha rinominato le routine in attività pianificate; l'indirizzo web, l'alias `/routines` e l'API mantengono il vecchio nome.

### La routine vede la mia chiave API di Pocket Alert?

Non con un segreto di rete. Il proxy aggiunge l'header dopo che la richiesta esce dalla sessione, quindi la chiave non si trova in nessuna variabile d'ambiente o file che Claude possa leggere. Con una variabile d'ambiente, invece, è leggibile dentro la sessione.

### Una routine può svegliarmi di notte?

Con `"level": "critical"` su un piano a pagamento, sì. Riservalo alle routine che controllano la produzione, come una routine attivata via API dal tuo sistema di monitoraggio quando si registra un picco di errori.

### E la pianificazione locale con /loop o le attività pianificate di Desktop?

Quelle girano sulla tua macchina, quindi gli hook e i server MCP di Claude Code in locale funzionano normalmente. La configurazione è descritta in [notifiche push per Claude Code](/blog/claude-code-push-notifications). Per altri pattern di agenti, vedi [avvisi per agenti AI](/use-cases/ai-agent-alerts).

[Crea un account gratuito](/signup), aggiungi il segreto e lascia che la routine di domani mattina ti dica com'è andata.
