# Notifications push Claude Code : soyez prévenu quand une tâche se termine

> Recevez une notification push sur votre téléphone quand Claude Code termine une tâche, attend une autorisation ou s’arrête sur une erreur. Un seul script de hook, trois événements, aucun plugin.

*11.10.2026*

<!-- source: https://pocketalert.app/fr/blog/claude-code-push-notifications -->

Claude Code travaille volontiers vingt minutes en autonomie. Le problème, c’est ce qui se passe pendant ces vingt minutes : soit vous restez à regarder le terminal, soit vous vous éloignez et revenez découvrir qu’il attend une demande d’autorisation depuis la troisième minute.

Les hooks règlent les deux situations. Claude Code exécute une commande shell à des moments précis de son cycle de vie, et trois de ces moments sont exactement ceux que vous voulez voir sur votre téléphone :

- **Stop** : Claude a fini de répondre. La tâche est terminée, ou il vous pose une question.
- **Notification** : Claude a besoin de vous. Une demande d’autorisation, ou il est resté inactif en attendant une saisie.
- **StopFailure** : le tour s’est terminé sur une erreur d’API, par exemple une limite de débit ou un problème de facturation.

Ce guide relie ces trois événements à Pocket Alert avec un seul script. La mise en place prend environ cinq minutes.

## Ce dont vous avez besoin

- Claude Code, dans une version récente.
- `jq` et `curl`. Les deux sont présents sur la plupart des distributions Linux ; sur macOS, `brew install jq`.
- Un compte Pocket Alert et une clé API depuis [Clés API](/account/apikeys). L’offre gratuite suffit.
- L’application Pocket Alert sur votre [iPhone ou Android](/get-app), connectée à votre compte.

## Étape 1. Le script de hook

Claude Code transmet à chaque hook un objet JSON sur l’entrée standard. Les champs dont vous avez besoin sont `hook_event_name`, `cwd`, `last_assistant_message` pour Stop, `message` pour Notification et `error` pour StopFailure. Le script transforme cela en notification push :

```bash
#!/usr/bin/env bash
payload=$(cat)
project=$(basename "$(jq -r '.cwd' <<<"$payload")")

case "$(jq -r '.hook_event_name' <<<"$payload")" in
  Stop)
    title="Claude finished · $project"
    message=$(jq -r '.last_assistant_message // "Task complete"' <<<"$payload")
    level=default ;;
  Notification)
    title="Claude needs you · $project"
    message=$(jq -r '.message' <<<"$payload")
    level=high ;;
  StopFailure)
    title="Claude stopped · $project"
    message=$(jq -r '"API error: " + (.error // "unknown")' <<<"$payload")
    level=high ;;
  *) exit 0 ;;
esac

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

exit 0
```

Enregistrez-le sous `~/.claude/hooks/pocketalert.sh` et rendez-le exécutable :

```bash
mkdir -p ~/.claude/hooks
chmod +x ~/.claude/hooks/pocketalert.sh
```

Deux lignes de ce script sont plus importantes qu’elles n’en ont l’air :

- **`jq -n` construit le JSON.** Le dernier message de Claude est rempli de guillemets, d’accents graves et de retours à la ligne. Le coller à la main dans une chaîne JSON casse au premier guillemet ; `jq` l’échappe correctement.
- **`exit 0` à la fin, et `|| true` après curl.** Pour un hook Stop, le code de sortie 2 signifie « ne pas s’arrêter, continuer ». Un hook de notification ne doit jamais bloquer Claude, même si votre réseau est coupé.

### Ou avec la CLI Pocket Alert

Si la [CLI Pocket Alert](/tools/cli) en version 2.0 ou ultérieure est installée, le bloc curl se réduit à une seule commande. La CLI échappe elle-même le texte et récupère la clé depuis `POCKETALERT_API_KEY` (le bloc `env` ci-dessous la définit) ou depuis `pocketalert auth` :

```bash
pocketalert send -t "$title" -m "${message:0:300}" -l "$level" -q >/dev/null 2>&1 || true
```

Gardez `-t` et `-m` plutôt que des arguments positionnels : une réponse qui commence par un tiret, comme une liste Markdown, serait sinon lue comme une option.

## Étape 2. Enregistrer les hooks

Ajoutez les hooks dans `~/.claude/settings.json` pour qu’ils s’appliquent à tous vos projets. Si le fichier contient déjà une clé `hooks`, fusionnez ces entrées avec elle :

```json
{
  "env": {
    "POCKETALERT_API_KEY": "YOUR_API_KEY"
  },
  "hooks": {
    "Stop": [
      { "hooks": [{ "type": "command", "command": "~/.claude/hooks/pocketalert.sh" }] }
    ],
    "StopFailure": [
      { "hooks": [{ "type": "command", "command": "~/.claude/hooks/pocketalert.sh" }] }
    ],
    "Notification": [
      {
        "matcher": "permission_prompt|idle_prompt",
        "hooks": [{ "type": "command", "command": "~/.claude/hooks/pocketalert.sh" }]
      }
    ]
  }
}
```

Le bloc `env` transmet la clé API au hook sans la placer dans votre profil shell. Si vous exportez déjà `POCKETALERT_API_KEY` ailleurs, omettez ce bloc.

Le `matcher` de Notification filtre selon le type de notification. `permission_prompt` se déclenche lorsqu’une demande d’autorisation est restée une dizaine de secondes sans réponse, et `idle_prompt` environ une minute après la fin de la réponse de Claude si vous n’avez rien tapé depuis. Dans une session de terminal, les deux ne se déclenchent que lorsque vous semblez être absent : votre téléphone ne vibre donc pas pendant que vous regardez l’écran. Stop n’a pas de matcher : il se déclenche à chaque fin de réponse de Claude.

Pour limiter les hooks à un seul dépôt, placez le même bloc `hooks` dans `.claude/settings.json` à la racine de ce dépôt, ou dans `.claude/settings.local.json` pour le garder hors de git.

## Étape 3. Tester

Claude Code prend normalement en compte seul les modifications du fichier de paramètres (ouvrez une nouvelle session si `/hooks` ne les affiche pas encore). Donnez-lui une petite tâche :

```text
> List the files in this directory and stop.
```

Quand Claude a terminé, votre téléphone affiche **Claude a terminé · votre-projet** avec le début de sa réponse. Si rien n’arrive, lancez `/hooks` dans Claude Code pour voir les hooks enregistrés.

Pour tester le script seul, envoyez-lui un faux événement :

```bash
echo '{"hook_event_name":"Stop","cwd":"/tmp/demo","last_assistant_message":"Hook test"}' \
  | POCKETALERT_API_KEY=YOUR_API_KEY ~/.claude/hooks/pocketalert.sh
```

## Ce qui arrive sur votre téléphone

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Événement</th><th>Titre</th><th>Contenu</th><th>Niveau</th></tr></thead>
<tbody>
<tr><th>Tâche terminée</th><td>Claude a terminé · api</td><td>Les 300 premiers caractères de la dernière réponse de Claude</td><td>default</td></tr>
<tr><th>Demande d’autorisation</th><td>Claude a besoin de vous · api</td><td>Claude a besoin de votre autorisation</td><td>high</td></tr>
<tr><th>Attente de saisie</th><td>Claude a besoin de vous · api</td><td>Claude attend votre saisie</td><td>high</td></tr>
<tr><th>Erreur API</th><td>Claude s’est arrêté · api</td><td>Erreur API : rate_limit</td><td>high</td></tr>
</tbody>
</table>
</div>

Le niveau `high` est transmis comme urgent avec contrainte de temps sur iPhone : une demande d’autorisation passe donc le mode Concentration, tandis que les messages de fin de tâche de routine restent silencieux. Chaque notification reste aussi dans l’historique de l’application et dans le [tableau de bord web](/messages), pour que vous puissiez relire ce que Claude a fait pendant la nuit.

## Adaptez-le à vos besoins

**Seulement quand vous êtes absent.** Stop se déclenche après chaque réponse, y compris les courtes que vous suivez à l’écran. Ajoutez un interrupteur en haut du script :

```bash
[ -f ~/.claude/away ] || exit 0
```

Lancez ensuite `touch ~/.claude/away` en quittant votre bureau et `rm ~/.claude/away` à votre retour. Les demandes d’autorisation méritent d’être signalées dans tous les cas : vous pouvez donc placer la vérification uniquement dans la branche `Stop)`.

**Regroupez par projet.** Créez une application par projet dans Pocket Alert et ajoutez `application_id` au JSON. L’application filtre alors par projet, et vous pouvez définir un niveau par défaut pour chacun.

**Ne bloquez jamais Claude.** Ajoutez `"async": true` à côté de `"type": "command"` : le hook s’exécute alors en arrière-plan. Désactivez-le dans les exécutions sans interface (`claude -p`) : les hooks en arrière-plan sont interrompus à la fin de la session, et la notification risque de ne jamais partir.

**Reprenez depuis le téléphone.** Avec une offre payante, un [bouton d’action](https://info.pocketalert.app/features/action-buttons.html) `copy` contenant l’identifiant de session vous permet de copier `claude --resume <id>` depuis le téléphone et de le coller à votre retour.

## Ou laissez Claude l’envoyer via MCP

Les hooks sont déterministes : ils se déclenchent que Claude s’en souvienne ou non. L’autre voie consiste à donner à Claude un outil de notification et à le laisser décider quand l’utiliser. Ajoutez le [serveur MCP Pocket Alert](/tools/mcp) :

```bash
claude mcp add --transport http pocketalert https://mcp.pocketalert.app/mcp \
  --scope user --header "Authorization: Bearer YOUR_API_KEY"
```

Vous pouvez alors demander : « lance la migration et envoie-moi le nombre de lignes une fois terminé », et Claude appelle `create_message` avec un message qu’il rédige pour l’occasion. L’outil accepte aussi `level` et `actions`, et `list_messages` permet à Claude de relire ce qu’il a envoyé précédemment.

Utilisez les deux : les hooks pour le « terminé » et le « besoin de vous » garantis, MCP pour les messages au contenu réel. Pour les validations avant les étapes risquées, consultez [Notifications avec validation humaine](/blog/human-in-the-loop-notifications).

## Si rien n’arrive

- **Vérifiez la clé.** Lancez la commande de test ci-dessus. Un `401` de curl signifie que la clé API est incorrecte ; retirez `>/dev/null` pour voir la réponse.
- **Vérifiez que les hooks sont chargés.** Lancez `/hooks`. Les modifications du fichier de paramètres sont en général prises en compte en quelques secondes ; si les hooks n’apparaissent pas, redémarrez Claude Code.
- **Vérifiez que `jq` est dans le PATH** utilisé par Claude Code. Les hooks s’exécutent dans l’environnement de Claude, et un éditeur lancé depuis l’interface graphique peut ne pas voir `/opt/homebrew/bin` de Homebrew.
- **Vérifiez la limite quotidienne.** L’offre gratuite envoie 50 messages par jour. Une longue session avec de nombreux petits tours peut les épuiser ; l’interrupteur d’absence décrit plus haut aide à limiter cela.

## FAQ

### Cela fonctionne-t-il avec les extensions VS Code et JetBrains ?

Oui. Les extensions exécutent Claude Code en arrière-plan et lisent le même `~/.claude/settings.json`, donc les hooks s’y déclenchent aussi.

### Claude peut-il voir la clé API ?

Pas dans la conversation : les hooks s’exécutent en dehors de celle-ci, et leur sortie pour Stop et Notification n’est pas transmise au modèle. Mais le bloc `env` s’applique à toute la session, si bien qu’une commande Bash lancée par Claude pourrait lire la variable. Si cela vous importe, conservez la clé dans un fichier que vous seul pouvez lire, par exemple `~/.config/pocketalert/key` avec les droits `600`, et utilisez `-H "Token: $(cat ~/.config/pocketalert/key)"` dans le script.

### Quelle est la différence avec le signal sonore du terminal ?

Le signal sonore et les notifications de bureau exigent que vous soyez devant l’ordinateur. Une notification push atteint votre téléphone où que vous soyez, conserve un historique et peut être configurée pour passer le mode Concentration pour les demandes qui bloquent Claude.

### Puis-je recevoir la réponse complète, et non 300 caractères ?

Une notification push transporte jusqu’à environ 3 000 caractères de texte. Vous pouvez augmenter la limite `0:300`, mais une notification sert à décider s’il faut retourner à son bureau, pas à lire la réponse complète.

### Est-ce gratuit ?

Oui. Les hooks font partie de Claude Code, et l’offre gratuite de Pocket Alert couvre 50 messages par jour sur un appareil. Les offres payantes ajoutent davantage de messages, d’appareils et de boutons d’action.

[Obtenez une clé API](/signup), ajoutez le script et laissez Claude vous signaler quand c’est à vous de jouer.
