# Notificaciones push en Home Assistant con rest_command: fuga, lavadora, puerta

> Envía alertas de Home Assistant a cualquier teléfono con un solo rest_command, niveles de prioridad de crítico a bajo y un botón que cierra la válvula de agua desde la notificación.

*23.10.2026*

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

La app Home Assistant Companion gestiona bien las notificaciones para quienes usan Home Assistant. Se complica cuando la persona que debe enterarse de una fuga en el sótano es tu pareja, que nunca la instaló, un padre o la vecina que tiene tu copia de la llave. Darles una cuenta de Home Assistant solo para que reciban una notificación push es dar más acceso del que necesitan.

También está el problema del ruido. "La lavadora ha terminado" y "agua en el suelo del baño" no deberían sonar igual, y si tus alertas de servidor ya pasan por otra app, acabas revisando dos fuentes.

Esta guía usa `rest_command` de Home Assistant para enviar notificaciones push a través de Pocket Alert. No necesita complementos ni integraciones personalizadas, y cubre tres automatizaciones: una fuga de agua con nivel crítico, una lavadora terminada con nivel bajo y una puerta abierta sin nadie en casa.

## Lo que necesitas

- Home Assistant con acceso a `configuration.yaml` (editor de archivos o el complemento Studio Code Server, o SSH).
- Una cuenta de Pocket Alert, una clave de API desde [Claves de API](/account/apikeys) y la app en el teléfono que debe recibir las alertas, [iPhone o Android](/get-app). El plan gratuito incluye 50 mensajes al día en un dispositivo.

## El rest_command

Guarda la clave en `secrets.yaml`, en la misma carpeta que `configuration.yaml`:

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

Después, añade un comando en `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 }}
```

Reinicia Home Assistant. Ahora tienes una acción llamada `rest_command.pocketalert`, y lo que pases en su `data` se convierte en variable de plantilla: `title`, `message`, un `level` opcional y un botón opcional.

¿Por qué construir el JSON con `to_json` en lugar de escribirlo a mano? Un nombre de sensor con comillas rompería una cadena escrita a mano, y `to_json` lo escapa por ti. La API de Pocket Alert solo acepta JSON, y por eso se define `content_type`: sin él, la petición se envía sin tipo de contenido JSON.

Pruébalo desde **Herramientas para desarrolladores → Acciones**: elige `rest_command.pocketalert`, cambia al modo YAML y ejecuta:

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

La notificación debería llegar en uno o dos segundos.

## Tres automatizaciones

Añádelas en el editor de automatizaciones (**Editar en YAML**) o en `automations.yaml`. Sustituye los IDs de entidad por los tuyos.

### Fuga de agua: crítica

```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` es el nivel para lo que no puede esperar a la mañana. En iPhone suena con su propio volumen aunque el interruptor de silencio esté activado y con No molestar; en Android usa un canal aparte que ignora No molestar y ocupa la pantalla. La alerta crítica forma parte de los planes de pago; en el plan gratuito, el mismo mensaje llega como `high`, que sí atraviesa Concentración pero no el interruptor de silencio.

### Lavadora terminada: baja

No existe un sensor de "lavadora terminada", pero un enchufe inteligente con medición de potencia te lo dice: cuando el consumo se mantiene por debajo de unos pocos vatios durante unos minutos, el ciclo ha terminado.

```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` llega en silencio, sin sonido ni interrupciones. Aparece en la lista cuando miras el teléfono, que es exactamente lo urgente que es la ropa mojada. Ajusta `below` y `for` a tu máquina: algunas lavadoras se paran un minuto o dos a mitad de ciclo.

### Puerta abierta sin nadie en casa: alta

El estado de `zone.home` es el número de personas dentro de la zona, así que `"0"` significa que todos están fuera.

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

En iPhone, `high` se marca como sensible al tiempo, así que atraviesa Concentración y el resumen programado. La línea del mensaje es una plantilla: los valores de `data` se procesan antes de llegar al comando.

## Un botón que cierra la válvula de agua

Una alerta de fuga es más útil si puedes actuar desde ella. Las notificaciones de Pocket Alert pueden incluir hasta tres [botones de acción](/features/action-buttons), y un botón `http` envía una petición **desde el propio teléfono**. Pocket Alert no la reenvía. Eso significa que el botón puede llamar a un webhook de Home Assistant que no está abierto a internet, siempre que el teléfono pueda alcanzarlo.

Primero, una automatización que cierra la válvula cuando se llama a su webhook:

```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 tu válvula aparece como interruptor, usa `switch.turn_off` en su lugar. Haz que el ID del webhook sea largo y aleatorio: los webhooks de Home Assistant no tienen más autenticación que conocer el ID.

Después, añade el botón a la automatización de fuga:

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

El `rest_command` de arriba convierte `button_url` en una acción `http` con método POST. Al pulsar el botón, el teléfono envía la petición en segundo plano sin abrir la app.

Qué URL usar:

- **Solo en casa:** la dirección a la que tu teléfono accede a Home Assistant por Wi-Fi. `local_only: true` mantiene el webhook cerrado a internet. Prefiere una dirección `https://` si tienes una en tu red.
- **Desde cualquier lugar:** una fuga suele ocurrir cuando no estás en casa. La documentación de Home Assistant indica que los webhooks con `local_only` siguen funcionando a través de los webhooks de Home Assistant Cloud (Nabu Casa), así que esa URL en la nube es la opción más sencilla. Una VPN en el teléfono, como Tailscale o WireGuard, también funciona con la dirección de la LAN.

El propio Home Assistant recomienda no poner acciones destructivas o inseguras detrás de un webhook, como desbloquear una puerta. Cerrar una válvula de agua es la dirección segura; abrirla no lo es, así que no pongas eso en los botones del teléfono. Un segundo toque envía una segunda petición, lo cual no pasa nada aquí, porque cerrar una válvula ya cerrada no hace nada.

Dos cosas que conviene saber sobre los botones. Son una función de los planes de pago y se eliminan de los mensajes en el plan gratuito; la alerta en sí sigue llegando. Además, tanto iOS como Android muestran tu propia etiqueta directamente en la notificación, incluso con la app de Pocket Alert cerrada (versión 2.0.1 o posterior). Los botones también se guardan con el mensaje en la app, así que puedes seguir pulsándolos después de que desaparezca el aviso.

## Alertas para personas sin Home Assistant

La persona que recibe la notificación solo necesita la app de Pocket Alert. Hay dos formas de configurarlo:

- **Su propia cuenta.** Se registra gratis, crea una clave de API y te la envía. Añade un segundo comando, `pocketalert_family`, con su clave en `secrets.yaml`, y llama a ambos comandos en la automatización de fuga. Tus alertas de servidor siguen en tu cuenta; ellos solo ven lo que les envías.
- **Un segundo dispositivo en tu cuenta.** Los planes de pago incluyen varios dispositivos. Añade su teléfono y luego haz una copia del comando con `"device_id": "THEIR_DEVICE_ID"` añadido al diccionario `body`, de modo que solo las alertas del hogar vayan a ese teléfono.

En cualquiera de los dos casos, reciben la alerta de fuga con el mismo nivel y botón, sin necesitar una cuenta en tu Home Assistant.

## Una app para la casa y todo lo demás

La misma clave de API sirve para tareas cron, copias de seguridad, comprobaciones de disponibilidad y CI. Si tienes un homelab, las [alertas de Proxmox, NAS y copias de seguridad](/use-cases/homelab-alerts) llegan al mismo flujo que el sensor de fugas, cada una con su propio nivel, y la app puede filtrar el flujo por nivel, así que los dos avisos que importan son fáciles de encontrar entre cuarenta. Para otros sensores (placas ESP32, una Raspberry Pi, Node-RED), consulta [Alertas de IoT y sensores](/use-cases/iot-sensor-alerts).

Para dispositivos que solo pueden enviar un webhook JSON, hay una opción sin código: crea un webhook en [la consola](/webhooks) y genera el mensaje a partir del payload con una plantilla. Consulta [Webhook a push](/tools/webhook).

## RESTful Notifications como acción notify

Si prefieres las acciones `notify.*`, la plataforma RESTful Notifications de Home Assistant también puede enviar a 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` envía un cuerpo JSON, `title_param_name` asigna el título de la notificación a nuestro campo `title` y `data` añade campos fijos. Llámala con `action: notify.pocketalert` y `title` más `message`. El nivel es fijo por notificador, así que crea uno por nivel si necesitas varios, o usa `rest_command`, que además gestiona los botones.

## Si no llega nada

- **Revisa el registro.** `rest_command` registra un aviso con el código de estado cuando falla la petición. `401` significa que la clave de `secrets.yaml` es incorrecta; `400` suele indicar que el payload no es JSON válido.
- **Reinicia la primera vez.** El primer bloque de `rest_command` necesita reiniciar Home Assistant antes de que aparezca la acción; las ediciones posteriores se cargan con la acción `rest_command.reload`.
- **Ejecuta la acción a mano** desde Herramientas para desarrolladores. Si funciona, el problema está en el disparador o la condición de la automatización; revisa su traza.
- **El botón no hace nada:** abre el host de la URL del webhook desde el navegador del teléfono. Si el teléfono no puede acceder a Home Assistant en esa dirección, el botón tampoco podrá.
- **Revisa la cuota de hoy.** El plan gratuito se detiene en 50 mensajes al día, y un sensor muy activo puede agotarla. Un `for:` en el disparador ayuda.

## Preguntas frecuentes

### ¿Necesito la app Home Assistant Companion?

No. La notificación push llega desde Pocket Alert, así que el teléfono solo necesita la app de Pocket Alert. Puedes seguir usando la app Companion para sus sensores y el seguimiento de ubicación.

### ¿Funciona con Home Assistant Cloud?

Sí. `rest_command` llama directamente a la API de Pocket Alert desde tu Home Assistant, así que no depende de Nabu Casa. Home Assistant Cloud solo ayuda con el botón de la válvula cuando estás fuera de casa.

### ¿La alerta de fuga puede despertarme por la noche?

Con `critical`, sí: suena a través del interruptor de silencio en iPhone y a través de No molestar en Android. Ese nivel requiere un plan de pago; en el plan gratuito llega como `high`.

### ¿Mi clave de API queda expuesta?

Se guarda en `secrets.yaml` y viaja en la cabecera `Token` por HTTPS. Usa una clave separada para Home Assistant para poder revocarla sin tocar tus otros scripts.

[Crea una cuenta gratuita](/signup), añade un `rest_command` y deja que la casa te avise cuando te necesite.
