# Notificaciones push para rutinas de Claude: sabe cuándo una ejecución en la nube te necesita

> Las rutinas de Claude se ejecutan en la nube de Anthropic según un horario, una llamada a la API o un evento de GitHub, y no avisan a nadie cuando terminan. Así puedes recibir una notificación push en el teléfono cuando una ejecución termina, falla o encuentra algo.

*18.10.2026*

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

Las rutinas de Claude son la parte de Claude Code que funciona sin ti. Guardas un prompt y un repositorio una sola vez, y la nube de Anthropic inicia una sesión nueva de Claude Code cada noche, en cada nueva pull request o cuando tu monitorización llama a un endpoint. Tu portátil puede estar cerrado.

El problema es que una rutina no informa a nadie. El resultado queda en una sesión de claude.ai hasta que vas a mirarlo, y la lista de ejecuciones tampoco ayuda mucho: un estado verde solo significa que la sesión arrancó y terminó sin un error de infraestructura, no que el trabajo saliera bien. Una comprobación nocturna de dependencias que encontró una compilación rota se ve exactamente igual que una que no encontró nada.

Esta guía hace que la rutina te envíe una notificación push al teléfono a través de Pocket Alert: una silenciosa cuando todo va bien, y una más llamativa cuando algo requiere tu atención.

## Qué son las rutinas de Claude, en resumen

Anthropic ahora las llama **tareas programadas**. "Routines" es el nombre anterior y todavía aparece en la dirección web (`claude.ai/code/routines`), en el alias de CLI `/routines` y en la API. Es la misma función, que actualmente está en vista previa de investigación.

Una rutina es una configuración guardada de Claude Code: un prompt, uno o más repositorios de GitHub, un entorno en la nube y un conjunto de conectores. Cada ejecución es una sesión completa en la nube que puede ejecutar comandos de shell, editar código, enviar cambios a una rama `claude/` y llamar a conectores. Las ejecuciones se inician desde disparadores, y una rutina puede tener varios:

- **Programación**: por hora, a diario, semanal con preajustes, una expresión cron personalizada (no más de una vez por hora) o una ejecución única a una hora determinada.
- **API**: un POST al endpoint `/fire` propio de la rutina con un token de portador. Puedes pasar un campo `text`, como el cuerpo de una alerta, que la ejecución recibe como contexto.
- **GitHub**: eventos de pull request, release o issue en un repositorio con la GitHub App de Claude instalada, con filtros de pull request por autor, rama, etiquetas, estado de borrador y más.

Creas rutinas en [claude.ai/code/routines](https://claude.ai/code/routines) con **New task**, en la aplicación de escritorio, o con `/schedule` en la CLI de Claude Code, por ejemplo `/schedule daily PR review at 9am`. Necesitan un plan Pro, Max, Team o Enterprise, y las ejecuciones consumen tu uso de suscripción igual que las sesiones interactivas.

## Qué necesitas

- Una cuenta de Pocket Alert, una clave de API de [Claves de API](/account/apikeys) y la aplicación en tu teléfono [iPhone o Android](/get-app). El plan gratuito sirve.
- Una rutina, o un plan para crear una.

Hay dos formas de que una ejecución llegue a tu teléfono: `curl` desde la sesión hacia la API de Pocket Alert, o el [servidor MCP de Pocket Alert](/tools/mcp) añadido como conector. Empieza con curl. Funciona en todos los planes que tienen rutinas, y la clave nunca entra en la sesión.

## Configuración: curl con un secreto de red

El entorno en la nube de una rutina tiene acceso de red **Trusted** por defecto: registros de paquetes, GitHub y APIs de proveedores de nube, y nada más. `api.pocketalert.app` no está en esa lista, así que un `curl` normal fallaría con `403` y `x-deny-reason: host_not_allowed`.

Un **secreto de red** resuelve tanto el problema de red como el de la clave. Guardas la clave en el entorno, y el proxy de Anthropic la añade a las peticiones de los hosts que indiques cuando salen de la VM de la sesión. Los hosts con un secreto de red son accesibles sea cual sea el nivel de acceso, y Claude nunca ve la clave.

1. Abre la rutina en [claude.ai/code/routines](https://claude.ai/code/routines), elige **Edit** y luego **Advanced settings > General > Cloud environment**. Pasa el cursor sobre el entorno y haz clic en su icono de configuración.
2. En **Network secrets**, haz clic en **Add secret** y mantén el tipo **Bearer**.
3. **Name**: `Pocket Alert`. **Allowed websites**: `api.pocketalert.app`.
4. En **Custom headers**, cambia el nombre de la cabecera de `Authorization` a `Token`, borra el prefijo `Bearer` y pega tu clave de API como valor.
5. Haz clic en **Add**. El secreto se guarda de inmediato y ya no se puede volver a ver.

Ahora la petición no necesita ninguna clave. Añade esto al final del prompt de la rutina:

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

La última línea viene de la documentación de Anthropic: cada sesión en la nube puede leer su propio ID desde `CLAUDE_CODE_REMOTE_SESSION_ID`, y ese comando lo convierte en la URL de la transcripción. Con ella en el mensaje, pasas de la notificación a la ejecución con un solo toque.

Haz clic en **Run now** en la página de la rutina para probarla antes de la primera ejecución programada.

Si tu diálogo de entorno no tiene la fila **Custom headers** (en un plan Team sin rol de administrador, el formulario solo pide un host y un valor), pon **Network access** en **Custom**, añade `api.pocketalert.app` a **Allowed domains** manteniendo la lista predeterminada, y guarda la clave en una variable de entorno como `POCKETALERT_KEY`, enviada como `-H "Token: $POCKETALERT_KEY"`. Ten en cuenta que las variables de entorno pueden ser leídas por cualquiera que use el entorno, por eso el secreto es la mejor opción.

## O añade el servidor MCP como conector

Las rutinas pueden usar tus conectores de claude.ai, y el tráfico de los conectores pasa por los servidores de Anthropic, así que no necesita ningún cambio en la lista de permitidos. Entonces el prompt solo dice "llama a la herramienta `create_message` de pocketalert" con un título, un mensaje y un nivel.

El límite está en la autenticación. El servidor MCP de Pocket Alert recibe la clave de API como `Authorization: Bearer KEY`, y en claude.ai un conector personalizado solo puede enviar una clave fija mediante la sección **Request headers** del diálogo **Add custom connector**. Anthropic marca esa sección como una beta disponible para un conjunto limitado de organizaciones. Si la ves (en los planes Team y Enterprise, un Owner añade el conector en **Organization settings > Connectors**):

1. Ve a [claude.ai/customize/connectors](https://claude.ai/customize/connectors) y haz clic en **Add custom connector**.
2. URL: `https://mcp.pocketalert.app/mcp`. Autenticación: **No sign-in**.
3. En **Request headers**, elige `authorization` e introduce `Bearer YOUR_API_KEY`.

Las rutinas nuevas incluyen todos tus conectores por defecto, así que revisa la pestaña **Connectors** de la rutina y deja solo los que necesita. El comando `claude mcp add` de la CLI de Claude Code no sirve aquí: los servidores añadidos así viven en tu máquina y no aparecen en las rutinas. Si también usas Claude Code en local, esa configuración está en [notificaciones push de Claude Code](/blog/claude-code-push-notifications); para otras opciones MCP consulta [mejores servidores MCP de notificaciones](/blog/best-mcp-notification-servers).

## Segundo nivel: un push que no depende del modelo

Las dos rutas anteriores dependen de que Claude siga el último párrafo de tu prompt. Normalmente lo hace. Pero una ejecución que alcanza un límite de tasa o un error de API nunca llega a ese párrafo, y es justo la ejecución de la que más te interesa enterarte.

Los hooks también funcionan en las rutinas: una sesión en la nube con un repositorio lee el archivo `.claude/settings.json` del repositorio. Un hook `Stop` se dispara cuando Claude termina, y `StopFailure` se dispara en su lugar cuando el turno termina con un error de API como `rate_limit` o `server_error`. Confirma este archivo como `.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" }] }
    ]
  }
}
```

Y el script, `.claude/hooks/notify.sh`, con permisos de ejecución:

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

La comprobación de `CLAUDE_CODE_REMOTE` mantiene el hook en silencio en tu portátil, donde esa variable nunca vale `true`. `jq` viene preinstalado en las sesiones en la nube, y el secreto de red de la primera sección aporta la clave. Mantén el push basado en el prompt para el contenido ("3 paquetes desactualizados, PR abierta") y el hook como la señal garantizada de "ha terminado", o usa solo uno de los dos.

El hook se dispara para cada sesión en la nube de ese repositorio, no solo para las ejecuciones de rutinas, así que espera una notificación también cuando uses Claude Code en la web en ese repositorio.

## Niveles y botones

El prompt de arriba ya usa la parte más importante: los niveles. `low` llega en silencio y queda en el historial, `high` llega como urgente en el iPhone y salta el modo Concentración. La regla "high solo para problemas" es lo que evita que silencies todo después de una semana. `critical` también existe y atraviesa No molestar en los planes de pago, pero una rutina nocturna rara vez lo merece. Consulta [niveles de prioridad](https://info.pocketalert.app/features/priority-levels.html) para ver cómo se comporta cada nivel en iOS y Android.

En los planes de pago, un mensaje puede incluir hasta tres [botones de acción](https://info.pocketalert.app/features/action-buttons.html). El más útil aquí es un botón `view` con la URL de la sesión, añadido al JSON así:

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

Cada notificación también se guarda en el historial de la aplicación y en el panel web, junto con las alertas de tus servidores y de CI, así que una semana de ejecuciones nocturnas se revisa de un vistazo.

## Límites reales

- **El prompt es una petición, no una garantía.** Claude normalmente envía la notificación, pero puede saltársela, enviar dos o escribir mal el JSON. Usa el hook si necesitas certeza.
- **Una ejecución puede parar y esperar.** Las rutinas arrancan en modo automático, pero una acción que coincide con una regla de preguntar, o bloqueos repetidos, hace que la ejecución espere una respuesta en su sesión. Ni el prompt ni `Stop` te avisarán de esa espera. Si una rutina suele avisarte a las 7:10 y no lo hace, ve a mirar.
- **Se aplican los límites de uso.** Las ejecuciones cuentan contra tu suscripción. Sin créditos de uso, las ejecuciones adicionales se rechazan al llegar al límite, y una ejecución que nunca arranca no envía nada. También hay límites por hora: 100 ejecuciones programadas por cuenta, y 30 ejecuciones con Run now o disparos por API por rutina.
- **Vista previa de investigación.** Anthropic indica que el comportamiento, los límites y la API todavía pueden cambiar.
- **Plan gratuito.** 50 mensajes al día en un dispositivo. Una rutina horaria que envía una notificación por ejecución cabe; una notificación por cada archivo que tocó, no.

## Si no llega nada

1. **Abre la ejecución.** Cada ejecución en el **History** de la rutina se abre como una sesión completa. Busca `api.pocketalert.app` en la transcripción y lee la salida de curl.
2. **`403` con `host_not_allowed`.** El secreto no está en el entorno que usa esta rutina, o el host está mal escrito. Revisa **Allowed websites**.
3. **`401`.** "No token provided" significa que ninguna clave llegó a la API: el secreto no está asociado o el nombre de la cabecera está mal escrito. "token contains an invalid number of segments" significa que la cabecera sigue siendo `Authorization`; cámbiala a `Token`. "Invalid token" significa que el prefijo `Bearer` sigue ahí o que la clave fue revocada.
4. **`400`.** El cuerpo no es JSON válido, normalmente por una comilla sin escapar en el resumen. La versión con hook construye el JSON con `jq`, lo que evita ese problema.
5. **El hook nunca se ejecutó.** Comprueba que `.claude/settings.json` está confirmado en la rama por defecto, que el script tiene permisos de ejecución y que la rutina tiene un solo repositorio.

## Preguntas frecuentes

### ¿Las rutinas de Claude y las tareas programadas son lo mismo?

Sí. Anthropic renombró las rutinas como tareas programadas; la dirección web, el alias `/routines` y la API mantienen el nombre anterior.

### ¿La rutina ve mi clave de API de Pocket Alert?

No con un secreto de red. El proxy añade la cabecera después de que la petición sale de la sesión, así que la clave no está en ninguna variable de entorno ni archivo que Claude pueda leer. Con una variable de entorno, sí es legible dentro de la sesión.

### ¿Puede una rutina despertarme por la noche?

Con `"level": "critical"` en un plan de pago, sí. Reserva ese nivel para rutinas que vigilan producción, como una rutina disparada por API que tu monitorización activa ante un pico de errores.

### ¿Qué pasa con la programación local con /loop o con las tareas programadas de escritorio?

Se ejecutan en tu máquina, así que los hooks y servidores MCP de Claude Code en local funcionan como siempre. La configuración está en [notificaciones push de Claude Code](/blog/claude-code-push-notifications). Para más patrones con agentes, consulta [alertas para agentes de IA](/use-cases/ai-agent-alerts).

[Crea una cuenta gratuita](/signup), añade el secreto y deja que la rutina de mañana por la mañana te cuente cómo le fue.
