# Notificações push para rotinas do Claude: saiba quando uma execução na nuvem precisa de você

> As rotinas do Claude rodam na nuvem da Anthropic por agendamento, chamada de API ou evento do GitHub, e não avisam ninguém quando terminam. Veja como receber uma notificação push no celular quando uma execução termina, falha ou encontra algo.

*18.10.2026*

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

As rotinas do Claude são a parte do Claude Code que roda sem você. Você salva um prompt e um repositório uma vez, e a nuvem da Anthropic inicia uma nova sessão do Claude Code todas as noites, em cada novo pull request, ou sempre que seu monitoramento chama um endpoint. Seu notebook pode ficar fechado.

O problema é que uma rotina não avisa ninguém. O resultado fica numa sessão em claude.ai até você ir olhar, e a lista de execuções também ajuda pouco: um status verde só significa que a sessão iniciou e encerrou sem erro de infraestrutura, não que o trabalho deu certo. Uma verificação noturna de dependências que encontrou um build quebrado parece exatamente igual a uma que não encontrou nada.

Este guia faz a rotina enviar uma notificação push para o seu celular pelo Pocket Alert: uma silenciosa quando tudo está bem, e uma com alerta quando algo precisa de você.

## O que são as rotinas do Claude, em resumo

A Anthropic agora chama essas rotinas de **tarefas agendadas**. "Routines" é o nome anterior e ainda aparece no endereço web (`claude.ai/code/routines`), no alias de CLI `/routines` e na API. É o mesmo recurso, atualmente em versão de pré-lançamento para pesquisa.

Uma rotina é uma configuração salva do Claude Code: um prompt, um ou mais repositórios do GitHub, um ambiente de nuvem e um conjunto de conectores. Cada execução é uma sessão completa na nuvem que pode rodar comandos de shell, editar código, enviar código para uma branch `claude/` e chamar conectores. As execuções começam a partir de gatilhos, e uma rotina pode ter vários:

- **Agendamento**: predefinições de hora em hora, diárias ou semanais, uma expressão cron personalizada (no máximo uma vez por hora), ou uma execução única em um horário definido.
- **API**: um POST para o endpoint `/fire` da própria rotina, com um token bearer. Você pode passar um campo `text`, como o corpo de um alerta, que a execução recebe como contexto.
- **GitHub**: eventos de pull request, release ou issue em um repositório com o GitHub App do Claude instalado, com filtros de pull request por autor, branch, labels, estado de rascunho e outros.

Você cria rotinas em [claude.ai/code/routines](https://claude.ai/code/routines) com **New task**, no aplicativo Desktop, ou com `/schedule` na CLI do Claude Code, por exemplo `/schedule daily PR review at 9am`. Elas exigem um plano Pro, Max, Team ou Enterprise, e as execuções consomem o uso da sua assinatura da mesma forma que as sessões interativas.

## O que você precisa

- Uma conta no Pocket Alert, uma chave de API em [Chaves de API](/account/apikeys) e o aplicativo no seu celular [iPhone ou Android](/get-app). O plano gratuito funciona.
- Uma rotina, ou um plano para criar uma.

Existem duas formas de uma execução chegar ao seu celular: `curl` a partir da sessão para a API do Pocket Alert, ou o [servidor MCP do Pocket Alert](/tools/mcp) adicionado como conector. Comece com o curl. Ele funciona em todos os planos que têm rotinas, e a chave nunca entra na sessão.

## Configuração: curl com um segredo de rede

O ambiente de nuvem de uma rotina tem acesso de rede **Trusted** por padrão: registros de pacotes, GitHub e APIs de provedores de nuvem, e mais nada. `api.pocketalert.app` não está nessa lista, então um `curl` simples falharia com `403` e `x-deny-reason: host_not_allowed`.

Um **segredo de rede** resolve o problema de rede e o problema da chave ao mesmo tempo. Você armazena a chave no ambiente, e o proxy da Anthropic a adiciona às requisições para os hosts que você listar, depois que elas saem da VM da sessão. Hosts com segredo de rede ficam acessíveis independentemente do nível de acesso, e o Claude nunca vê a chave.

1. Abra a rotina em [claude.ai/code/routines](https://claude.ai/code/routines), escolha **Edit** e depois **Advanced settings > General > Cloud environment**. Passe o mouse sobre o ambiente e clique no ícone de configurações.
2. Em **Network secrets**, clique em **Add secret** e mantenha o tipo **Bearer**.
3. **Name**: `Pocket Alert`. **Allowed websites**: `api.pocketalert.app`.
4. Em **Custom headers**, troque o nome do cabeçalho de `Authorization` para `Token`, apague o prefixo `Bearer` e cole sua chave de API como valor.
5. Clique em **Add**. O segredo é salvo imediatamente e não pode ser visualizado novamente.

Agora a requisição não precisa de chave nenhuma. Adicione isto ao final do prompt da rotina:

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

A última linha vem da documentação da Anthropic: cada sessão na nuvem pode ler o próprio ID em `CLAUDE_CODE_REMOTE_SESSION_ID`, e esse comando transforma o ID na URL da transcrição. Com ele na mensagem, você vai da notificação até a execução com um toque.

Clique em **Run now** na página da rotina para testá-la antes da primeira execução agendada.

Se o diálogo do seu ambiente não tiver a linha **Custom headers** (em um plano Team sem papel de administrador, o formulário pede apenas um host e um valor), defina **Network access** como **Custom**, adicione `api.pocketalert.app` em **Allowed domains** mantendo a lista padrão, e coloque a chave em uma variável de ambiente como `POCKETALERT_KEY`, enviada como `-H "Token: $POCKETALERT_KEY"`. Atenção: variáveis de ambiente podem ser lidas por qualquer pessoa que use o ambiente, por isso o segredo é a opção melhor.

## Ou adicione o servidor MCP como conector

As rotinas podem usar seus conectores do claude.ai, e o tráfego dos conectores passa pelos servidores da Anthropic, então não é preciso alterar nenhuma lista de permissões. Aí o prompt só diz "chame a ferramenta `create_message` do pocketalert" com um título, uma mensagem e um nível.

O limite está na autenticação. O servidor MCP do Pocket Alert recebe a chave de API como `Authorization: Bearer KEY`, e no claude.ai um conector personalizado só consegue enviar uma chave fixa pela seção **Request headers** do diálogo **Add custom connector**. A Anthropic marca essa seção como beta disponível para um conjunto limitado de organizações. Se você a vir (em planos Team e Enterprise, um Owner adiciona o conector em **Organization settings > Connectors**):

1. Acesse [claude.ai/customize/connectors](https://claude.ai/customize/connectors) e clique em **Add custom connector**.
2. URL: `https://mcp.pocketalert.app/mcp`. Autenticação: **No sign-in**.
3. Em **Request headers**, escolha `authorization` e digite `Bearer YOUR_API_KEY`.

Rotinas novas incluem todos os seus conectores por padrão, então confira a aba **Connectors** da rotina e mantenha apenas os que ela precisa. O `claude mcp add` da CLI do Claude Code não ajuda aqui: servidores adicionados dessa forma ficam na sua máquina e não aparecem nas rotinas. Se você também usa o Claude Code localmente, essa configuração está em [notificações push para o Claude Code](/blog/claude-code-push-notifications); para outras opções de MCP, veja [Melhores servidores MCP de notificação](/blog/best-mcp-notification-servers).

## Segundo nível: um push que não depende do modelo

As duas rotas acima dependem de o Claude seguir o último parágrafo do seu prompt. Normalmente ele segue. Mas uma execução que atinge um limite de taxa ou um erro de API nunca chega a esse parágrafo, e é justamente essa execução que você mais quer saber.

Hooks também rodam nas rotinas: uma sessão na nuvem com um repositório lê o `.claude/settings.json` do repositório. Um hook `Stop` dispara quando o Claude termina, e `StopFailure` dispara no lugar dele quando o turno termina com um erro de API, como `rate_limit` ou `server_error`. Faça commit disto 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" }] }
    ]
  }
}
```

E o script, `.claude/hooks/notify.sh`, com permissão de execução:

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

A verificação de `CLAUDE_CODE_REMOTE` mantém o hook silencioso no seu notebook, onde essa variável nunca é `true`. O `jq` já vem instalado nas sessões na nuvem, e o segredo de rede da primeira seção fornece a chave. Use o push baseado no prompt para o conteúdo ("3 pacotes desatualizados, PR aberto") e o hook como o sinal garantido de "terminou", ou use apenas um deles.

O hook dispara para cada sessão na nuvem daquele repositório, não só para execuções de rotinas, então espere uma notificação quando você usar o Claude Code na web nesse repositório também.

## Níveis e botões

O prompt acima já usa a parte mais importante: os níveis. `low` chega silenciosamente e fica no histórico, `high` aparece como urgente no iPhone e passa pelo Foco. A regra "high só para problemas" é o que impede você de silenciar tudo depois de uma semana. Existe também `critical`, que fura o modo Não perturbe nos planos pagos, mas uma rotina noturna raramente merece isso. Veja [níveis de prioridade](https://info.pocketalert.app/features/priority-levels.html) para saber como cada nível se comporta no iOS e no Android.

Nos planos pagos, uma mensagem pode ter até três [botões de ação](https://info.pocketalert.app/features/action-buttons.html). O mais útil aqui é um botão `view` com a URL da sessão, adicionado ao JSON assim:

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

Cada push também cai no histórico do aplicativo e no painel web, junto com os alertas dos seus servidores e do seu CI, então uma semana de execuções noturnas cabe em uma rolagem.

## Limites honestos

- **O prompt é um pedido, não uma garantia.** O Claude normalmente envia a notificação, mas pode pular, enviar duas ou escrever o JSON errado. Use o hook se você precisa de certeza.
- **Uma execução pode parar e esperar.** As rotinas começam no modo automático, mas uma ação que corresponde a uma regra de confirmação, ou bloqueios repetidos, faz a execução aguardar uma resposta na própria sessão. Nem o prompt nem o `Stop` vão avisar sobre essa espera. Se uma rotina costuma avisar você às 7h10 e não avisou, vá verificar.
- **Os limites de uso se aplicam.** As execuções contam na sua assinatura. Sem créditos de uso, execuções extras são recusadas ao atingir o limite, e uma execução que nunca começa não envia nada. Também há limites por hora: 100 execuções agendadas por conta, 30 disparos de Run now ou da API por rotina.
- **Pré-lançamento de pesquisa.** A Anthropic diz que o comportamento, os limites e a API ainda podem mudar.
- **Plano gratuito.** 50 mensagens por dia em um dispositivo. Uma rotina de hora em hora enviando um push por execução cabe; um push por arquivo alterado não cabe.

## Se nada chegar

1. **Abra a execução.** Cada execução no **History** da rotina abre como uma sessão completa. Procure `api.pocketalert.app` na transcrição e leia a saída do curl.
2. **`403` com `host_not_allowed`.** O segredo não está no ambiente usado por esta rotina, ou o host está digitado errado. Confira **Allowed websites**.
3. **`401`.** "No token provided" significa que nenhuma chave chegou à API: o segredo não está anexado ou o nome do cabeçalho está errado. "token contains an invalid number of segments" significa que o cabeçalho ainda é `Authorization`; troque para `Token`. "Invalid token" significa que o prefixo `Bearer` ainda está presente ou que a chave foi revogada.
4. **`400`.** O corpo não é um JSON válido, geralmente por causa de uma aspas sem escape no resumo. A versão com hook monta o JSON com `jq`, o que evita esse problema.
5. **O hook nunca rodou.** Verifique se o `.claude/settings.json` está commitado na branch padrão, se o script tem permissão de execução e se a rotina tem apenas um repositório.

## FAQ

### Rotinas do Claude e tarefas agendadas são a mesma coisa?

Sim. A Anthropic renomeou as rotinas para tarefas agendadas; o endereço web, o alias `/routines` e a API mantêm o nome antigo.

### A rotina consegue ver minha chave de API do Pocket Alert?

Não, com um segredo de rede. O proxy adiciona o cabeçalho depois que a requisição sai da sessão, então a chave não está em nenhuma variável de ambiente ou arquivo que o Claude consiga ler. Com uma variável de ambiente, ela fica legível dentro da sessão.

### Uma rotina pode me acordar à noite?

Com `"level": "critical"` em um plano pago, sim. Reserve isso para rotinas que monitoram produção, como uma rotina disparada pela API que o seu monitoramento aciona em um pico de erros.

### E o agendamento local com /loop ou as tarefas agendadas do Desktop?

Elas rodam na sua máquina, então os hooks e servidores MCP locais do Claude Code funcionam normalmente. A configuração está em [notificações push para o Claude Code](/blog/claude-code-push-notifications). Para mais padrões com agentes, veja [alertas para agentes de IA](/use-cases/ai-agent-alerts).

[Crie uma conta gratuita](/signup), adicione o segredo e deixe a rotina de amanhã de manhã contar como foi.
