# Notifications push Home Assistant avec rest_command : fuite, lave-linge, porte

> Envoyez des alertes Home Assistant sur n’importe quel téléphone avec un seul rest_command, des niveaux de priorité du critique au faible, et un bouton qui ferme la vanne d’eau depuis la notification.

*23.10.2026*

<!-- source: https://pocketalert.app/fr/blog/home-assistant-push-notifications -->

L’application Home Assistant Companion gère bien les notifications pour les personnes qui utilisent Home Assistant. Cela se complique quand la personne qui doit être prévenue d’une fuite au sous-sol est votre conjoint, qui n’a jamais installé l’application, un parent, ou le voisin qui a votre double de clé. Leur donner un compte Home Assistant juste pour qu’ils reçoivent une notification push, c’est leur accorder plus d’accès qu’il n’en faut.

Il y a aussi le problème du bruit. « Lave-linge terminé » et « eau sur le sol de la salle de bain » ne devraient pas sonner de la même façon, et si vos alertes serveur passent déjà par une autre application, vous finissez par surveiller deux flux.

Ce guide utilise `rest_command` de Home Assistant pour envoyer des notifications push via Pocket Alert. Il ne nécessite ni module complémentaire ni intégration personnalisée, et il couvre trois automatisations : une fuite d’eau au niveau critique, un lave-linge terminé au niveau faible, et une porte ouverte alors que personne n’est à la maison.

## Ce dont vous avez besoin

- Home Assistant avec accès à `configuration.yaml` (éditeur de fichiers ou module complémentaire Studio Code Server, ou SSH).
- Un compte Pocket Alert, une clé API depuis [Clés API](/account/apikeys), et l’application sur le téléphone qui doit recevoir les alertes, [iPhone ou Android](/get-app). L’offre gratuite couvre 50 messages par jour sur un appareil.

## Le rest_command

Placez la clé dans `secrets.yaml`, dans le même dossier que `configuration.yaml` :

```yaml
pocketalert_token: "YOUR_API_KEY"
```

Ajoutez ensuite une commande dans `configuration.yaml` :

```yaml
rest_command:
  pocketalert:
    url: https://api.pocketalert.app/v1/messages
    method: post
    content_type: application/json
    timeout: 10
    headers:
      Token: !secret pocketalert_token
    payload: >-
      {% set body = {"title": title, "message": message,
                     "level": level | default("default")} %}
      {% if button_url is defined %}
        {% set req = {"url": button_url, "method": "POST"} | to_json %}
        {% set body = dict(body, actions=[{"type": "http",
              "label": button_label | default("Run"), "value": req}]) %}
      {% endif %}
      {{ body | to_json }}
```

Redémarrez Home Assistant. Vous disposez maintenant d’une action appelée `rest_command.pocketalert`, et tout ce que vous passez dans son `data` devient une variable de modèle : `title`, `message`, un `level` facultatif et un bouton facultatif.

Pourquoi construire le JSON avec `to_json` plutôt que de l’écrire à la main ? Un nom de capteur contenant un guillemet casserait une chaîne écrite à la main, alors que `to_json` l’échappe pour vous. L’API Pocket Alert n’accepte que du JSON, ce qui explique aussi la présence de `content_type` : sans lui, la requête part sans en-tête de type JSON.

Testez depuis **Outils de développement → Actions** : choisissez `rest_command.pocketalert`, passez en mode YAML et exécutez :

```yaml
action: rest_command.pocketalert
data:
  title: "Hello from Home Assistant"
  message: "rest_command works"
```

La notification push devrait arriver en une seconde ou deux.

## Trois automatisations

Ajoutez-les dans l’éditeur d’automatisations (**Modifier en YAML**) ou dans `automations.yaml`. Remplacez les identifiants d’entités par les vôtres.

### Fuite d’eau : critique

```yaml
alias: "Leak under the sink"
triggers:
  - trigger: state
    entity_id: binary_sensor.kitchen_leak
    to: "on"
actions:
  - action: rest_command.pocketalert
    data:
      title: "Water leak: kitchen"
      message: "The sensor under the sink is wet. Check it now."
      level: critical
```

`critical` est le niveau réservé aux situations qui ne peuvent pas attendre le matin. Sur iPhone, il joue à son propre volume malgré l’interrupteur silencieux et « Ne pas déranger » ; sur Android, il utilise un canal distinct qui contourne « Ne pas déranger » et occupe l’écran. Le niveau critique fait partie des offres payantes ; sur l’offre gratuite, le même message arrive en `high`, qui passe la « Concentration » mais pas l’interrupteur silencieux.

### Lave-linge terminé : faible

Il n’existe pas de capteur « lave-linge terminé », mais une prise connectée avec mesure de la consommation peut le déduire : lorsque la consommation reste sous quelques watts pendant quelques minutes, le cycle est terminé.

```yaml
alias: "Washer finished"
triggers:
  - trigger: numeric_state
    entity_id: sensor.washer_plug_power
    below: 5
    for: "00:03:00"
actions:
  - action: rest_command.pocketalert
    data:
      title: "Washer finished"
      message: "Laundry is ready to hang."
      level: low
```

`low` arrive discrètement, sans son ni interruption. Il figure dans la liste lorsque vous consultez votre téléphone, ce qui convient parfaitement à du linge qui attend. Ajustez `below` et `for` à votre machine : certains lave-linge s’arrêtent une minute ou deux en plein cycle.

### Porte ouverte alors que personne n’est là : élevé

L’état de `zone.home` correspond au nombre de personnes présentes dans la zone, donc `"0"` signifie que tout le monde est sorti.

```yaml
alias: "Front door opened while away"
triggers:
  - trigger: state
    entity_id: binary_sensor.front_door
    to: "on"
conditions:
  - condition: state
    entity_id: zone.home
    state: "0"
actions:
  - action: rest_command.pocketalert
    data:
      title: "Front door opened"
      message: "Opened at {{ now().strftime('%H:%M') }} and nobody is home."
      level: high
```

`high` est marqué comme sensible au temps sur iPhone, il passe donc la « Concentration » et le résumé programmé. La ligne de message est un modèle : les valeurs de `data` sont évaluées avant d’atteindre la commande.

## Un bouton qui ferme la vanne d’eau

Une alerte de fuite est plus utile quand on peut agir dessus. Les notifications Pocket Alert peuvent contenir jusqu’à trois [boutons d’action](/features/action-buttons), et un bouton `http` envoie une requête **depuis le téléphone lui-même**. Pocket Alert ne sert pas de relais. Le bouton peut donc appeler un webhook Home Assistant qui n’est pas exposé sur internet, tant que le téléphone peut l’atteindre.

D’abord, une automatisation qui ferme la vanne lorsque son webhook est appelé :

```yaml
alias: "Close main water valve (from push)"
triggers:
  - trigger: webhook
    webhook_id: "close-valve-9f2c41d7a3b8e605"
    allowed_methods:
      - POST
    local_only: true
actions:
  - action: valve.close_valve
    target:
      entity_id: valve.main_water
```

Si votre vanne apparaît comme un interrupteur, utilisez `switch.turn_off` à la place. Rendez l’identifiant du webhook long et aléatoire : les webhooks Home Assistant n’ont pas d’autre authentification que la connaissance de cet identifiant.

Ajoutez ensuite le bouton à l’automatisation de fuite :

```yaml
actions:
  - action: rest_command.pocketalert
    data:
      title: "Water leak: kitchen"
      message: "The sensor under the sink is wet."
      level: critical
      button_label: "Close water valve"
      button_url: "https://ha.example.com/api/webhook/close-valve-9f2c41d7a3b8e605"
```

Le `rest_command` ci-dessus transforme `button_url` en action `http` avec la méthode POST. Lorsque vous appuyez sur le bouton, le téléphone envoie la requête en arrière-plan sans ouvrir l’application.

Quelle URL utiliser :

- **Uniquement à la maison :** l’adresse à laquelle votre téléphone atteint Home Assistant sur votre Wi-Fi. `local_only: true` garde le webhook fermé à internet. Préférez une adresse `https://` si vous en avez une sur votre réseau.
- **Depuis n’importe où :** une fuite survient souvent quand vous êtes absent. La documentation de Home Assistant indique que les webhooks avec `local_only` fonctionnent aussi via les webhooks de Home Assistant Cloud (Nabu Casa), donc cette URL cloud est l’option la plus simple. Un VPN sur le téléphone, comme Tailscale ou WireGuard, fonctionne aussi avec l’adresse du réseau local.

Home Assistant recommande de ne pas placer derrière un webhook des actions destructrices ou dangereuses, comme déverrouiller une porte. Fermer une vanne d’eau va dans le bon sens ; l’ouvrir non, donc ne mettez pas cela sur les boutons de votre téléphone. Un second appui envoie une seconde requête, ce qui est sans conséquence ici, car fermer une vanne déjà fermée ne fait rien.

Deux points à connaître sur les boutons. Ils sont réservés aux offres payantes et sont retirés des messages sur l’offre gratuite ; l’alerte elle-même arrive toujours. Par ailleurs, iOS comme Android affichent votre propre libellé directement sur la notification, même lorsque l’application Pocket Alert est fermée (version 2.0.1 ou ultérieure). Les boutons sont aussi enregistrés avec le message dans l’application, donc vous pouvez encore les utiliser une fois la bannière disparue.

## Alertes pour les personnes sans Home Assistant

La personne qui reçoit la notification push n’a besoin que de l’application Pocket Alert. Deux façons de procéder :

- **Leur propre compte.** Ils créent un compte gratuit, génèrent une clé API et vous la transmettent. Ajoutez une seconde commande, `pocketalert_family`, avec leur clé dans `secrets.yaml`, et appelez les deux commandes dans l’automatisation de fuite. Vos alertes serveur restent sur votre compte ; ils ne voient que ce que vous leur envoyez.
- **Un second appareil sur votre compte.** Les offres payantes incluent plusieurs appareils. Ajoutez leur téléphone, puis copiez la commande en ajoutant `"device_id": "THEIR_DEVICE_ID"` au dictionnaire `body`, pour que seules les alertes du foyer leur soient envoyées.

Dans les deux cas, ils reçoivent l’alerte de fuite avec le même niveau et le même bouton, sans compte sur votre Home Assistant.

## Une seule application pour la maison et le reste

La même clé API fonctionne pour les tâches cron, les sauvegardes, les contrôles de disponibilité et l’intégration continue. Si vous gérez un homelab, les [alertes Proxmox, NAS et sauvegardes](/use-cases/homelab-alerts) arrivent dans le même flux que le capteur de fuite, chacune avec son propre niveau, et l’application permet de filtrer le flux par niveau, ce qui facilite la recherche des deux alertes importantes parmi quarante. Pour d’autres capteurs (cartes ESP32, Raspberry Pi, Node-RED), consultez [alertes IoT et capteurs](/use-cases/iot-sensor-alerts).

Pour les appareils qui ne peuvent envoyer qu’un webhook JSON, il existe une option sans code : créez un webhook dans [la console](/webhooks) et construisez le message à partir de la charge utile. Voir [Webhook vers notification push](/tools/webhook).

## RESTful Notifications comme action notify

Si vous préférez les actions `notify.*`, la plateforme RESTful Notifications de Home Assistant peut aussi envoyer vers Pocket Alert :

```yaml
notify:
  - name: pocketalert
    platform: rest
    resource: https://api.pocketalert.app/v1/messages
    method: POST_JSON
    title_param_name: title
    headers:
      Token: !secret pocketalert_token
    data:
      level: high
```

`POST_JSON` envoie un corps JSON, `title_param_name` associe le titre de la notification à notre champ `title`, et `data` ajoute des champs fixes. Appelez-la avec `action: notify.pocketalert` en fournissant `title` et `message`. Le niveau est fixé par notifieur : créez-en un par niveau si vous en avez besoin, ou restez sur `rest_command`, qui gère aussi les boutons.

## Si rien n’arrive

- **Consultez le journal.** `rest_command` enregistre un avertissement avec le code de statut lorsque la requête échoue. `401` signifie que la clé dans `secrets.yaml` est incorrecte ; `400` indique généralement que la charge utile n’est pas du JSON valide.
- **Redémarrez la première fois.** Le premier bloc `rest_command` nécessite un redémarrage de Home Assistant avant que l’action n’apparaisse ; les modifications suivantes se chargent avec l’action `rest_command.reload`.
- **Lancez l’action manuellement** depuis les outils de développement. Si cela fonctionne, le problème vient du déclencheur ou de la condition de l’automatisation ; consultez sa trace.
- **Le bouton ne fait rien :** ouvrez l’URL du webhook dans le navigateur du téléphone. Si le téléphone ne peut pas joindre Home Assistant à cette adresse, le bouton ne le pourra pas non plus.
- **Vérifiez le quota du jour.** L’offre gratuite s’arrête à 50 messages par jour, et un capteur bavard peut tout consommer. Un `for:` sur le déclencheur aide.

## FAQ

### Ai-je besoin de l’application Home Assistant Companion ?

Non. La notification push provient de Pocket Alert, donc le téléphone n’a besoin que de l’application Pocket Alert. Vous pouvez tout de même garder l’application Companion pour ses capteurs et le suivi de position.

### Cela fonctionne-t-il avec Home Assistant Cloud ?

Oui. `rest_command` appelle directement l’API Pocket Alert depuis votre Home Assistant, il ne dépend donc pas de Nabu Casa. Home Assistant Cloud n’intervient que pour le bouton de la vanne lorsque vous êtes absent.

### L’alerte de fuite peut-elle me réveiller la nuit ?

Au niveau `critical`, oui : elle sonne malgré l’interrupteur silencieux sur iPhone et malgré « Ne pas déranger » sur Android. Ce niveau nécessite une offre payante ; sur l’offre gratuite, elle arrive en `high`.

### Ma clé API est-elle exposée ?

Elle est stockée dans `secrets.yaml` et transmise dans l’en-tête `Token` via HTTPS. Utilisez une clé distincte pour Home Assistant afin de pouvoir la révoquer sans toucher à vos autres scripts.

[Créez un compte gratuit](/signup), ajoutez un `rest_command`, et laissez la maison vous prévenir quand elle a besoin de vous.
