# Notificações push com n8n: alertas no celular a partir de qualquer workflow

> Envie notificações push para o seu iPhone ou celular Android a partir do n8n. Um nó HTTP Request, um sub-workflow compartilhado "Send push", um workflow de erro que avisa quando algo falha e botões Aprovar e Recusar que retomam um workflow em espera.

*30.10.2026*

<!-- source: https://pocketalert.app/pt/blog/n8n-push-notifications -->

O n8n é bom em fazer coisas enquanto você está fora, e ruim em avisar você sobre elas. Chega um formulário, um feed ganha uma publicação nova, uma sincronização falha às 3 da manhã, e o único registro é uma linha na lista de execuções que você só vai abrir na semana que vem.

Este guia conecta o n8n ao seu celular. Você vai chamar a API do Pocket Alert a partir de um nó HTTP Request, encapsular essa chamada em um sub-workflow reutilizável, adicionar um workflow de erro que avisa quando qualquer workflow falha e, no fim, criar botões Aprovar e Recusar que retomam um workflow direto da tela de bloqueio.

Tudo abaixo foi testado no n8n 2.45.7 (a imagem Docker `n8nio/n8n`), com o nó HTTP Request apontando para um capturador de requisições local, para que cada requisição pudesse ser conferida com a referência da API.

## O que você precisa

- Uma instância do n8n: auto-hospedada ou n8n Cloud.
- Uma conta no Pocket Alert e o app no seu celular [iPhone ou Android](/get-app). [Criar conta](/signup) é gratuito.
- Uma chave de API em [Chaves de API](/account/apikeys).

## Passo 1: uma credencial Header Auth

O Pocket Alert lê a chave de API de um cabeçalho chamado `Token`. No n8n, crie uma credencial do tipo **Header Auth**:

- **Name:** `Token`
- **Value:** sua chave de API

Dê à credencial o nome `Pocket Alert`. Guardar a chave como credencial a mantém fora do JSON do workflow, então você pode exportar e compartilhar workflows sem vazar a chave.

## Passo 2: o nó HTTP Request

Adicione um nó **HTTP Request** e configure assim:

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Campo</th><th>Valor</th></tr></thead>
<tbody>
<tr><th>Method</th><td><code>POST</code></td></tr>
<tr><th>URL</th><td><code>https://api.pocketalert.app/v1/messages</code></td></tr>
<tr><th>Authentication</th><td><strong>Generic Credential Type</strong>, depois <strong>Header Auth</strong>, depois a credencial <code>Pocket Alert</code></td></tr>
<tr><th>Send Body</th><td>On</td></tr>
<tr><th>Body Content Type</th><td><code>JSON</code></td></tr>
<tr><th>Specify Body</th><td><strong>Using JSON</strong></td></tr>
</tbody>
</table>
</div>

O corpo precisa de `title` e `message`. `level` e `actions` são opcionais. A forma mais óbvia de escrever é JSON simples com expressões dentro das strings:

```json
{
  "title": "New signup",
  "message": "{{ $json.name }} on {{ $json.plan }}",
  "level": "high"
}
```

Isso funciona até um valor conter aspas duplas ou quebra de linha. Com `name` igual a `Ana "AJ" Silva`, o n8n interrompe o nó com "The value in the JSON Body field is not valid JSON", porque a aspas encerra a string antes da hora. Mensagens de formulário e títulos de RSS esbarram nisso mais cedo do que você imagina.

A solução é deixar o JavaScript montar o JSON. Coloque o corpo inteiro em uma expressão:

```js
{{ JSON.stringify({
  title: 'New signup',
  message: $json.name + ' on ' + $json.plan,
  level: 'high'
}) }}
```

Ou, se preferir manter o layout do JSON, envolva cada valor dinâmico em `JSON.stringify()` e remova as aspas ao redor dele: `"message": {{ JSON.stringify($json.name + ' on ' + $json.plan) }}`. As duas formas geraram JSON válido, com as aspas escapadas, nos testes. Veja o que o n8n enviou:

```http
POST /v1/messages
Content-Type: application/json
Token: <your API key>
User-Agent: n8n

{"title":"New signup","message":"Ana \"AJ\" Silva on Pro","level":"high"}
```

`level` aceita `silent`, `low`, `default`, `high` ou `critical`. `high` fura o Foco no iPhone. `critical` toca mesmo com a chave de silencioso e com o Não perturbe ativado. É um recurso pago; no plano gratuito ele chega como `high`. Mais detalhes em [níveis de prioridade](https://info.pocketalert.app/features/priority-levels.html).

## Passo 3: um sub-workflow "Send push" para tudo

Copiar esse nó para cada workflow significa mexer em dez workflows quando você trocar a chave, a lógica de níveis ou o botão. Coloque tudo em um único sub-workflow e chame-o de todos os outros lugares.

Copie este JSON e cole em um canvas vazio do n8n (ou salve como arquivo e use **Import from File**):

```json
{
  "name": "Send push",
  "nodes": [
    {
      "parameters": {
        "workflowInputs": {
          "values": [
            { "name": "title" },
            { "name": "message" },
            { "name": "level" },
            { "name": "url" }
          ]
        }
      },
      "name": "When called",
      "type": "n8n-nodes-base.executeWorkflowTrigger",
      "typeVersion": 1.1,
      "position": [0, 0]
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://api.pocketalert.app/v1/messages",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpHeaderAuth",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={{ JSON.stringify({\n  title: $json.title,\n  message: $json.message,\n  level: $json.level || 'default',\n  actions: $json.url ? [{ type: 'view', label: 'Open', value: $json.url }] : []\n}) }}",
        "options": {}
      },
      "name": "Pocket Alert",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [220, 0]
    }
  ],
  "connections": {
    "When called": { "main": [[{ "node": "Pocket Alert", "type": "main", "index": 0 }]] }
  },
  "settings": { "executionOrder": "v1" }
}
```

Depois de importar, abra o nó **Pocket Alert** e escolha a sua credencial. O sub-workflow recebe quatro entradas: `title`, `message`, um `level` opcional que cai para `default`, e um `url` opcional. Quando `url` está preenchido, a notificação ganha um botão **Open** que o abre. Um array `actions` vazio é aceito e significa simplesmente que não há botões.

**Publique-o.** No n8n 2.x, as execuções de produção chamam a versão publicada de um sub-workflow. Enquanto você não publicar o Send push, toda chamada agendada ou disparada por webhook falha com "Workflow is not active and cannot be executed", mesmo que um teste manual pelo editor funcione, porque execuções manuais usam o rascunho. O mesmo vale depois de edições: alterações no Send push só chegam à produção quando você publica de novo.

Para chamá-lo de outro workflow, adicione um nó **Execute Sub-workflow**, escolha **Send push** na lista e preencha os quatro campos com expressões, por exemplo `New order #{{ $json.id }}` como título.

## Receba uma notificação push quando qualquer workflow falhar

O n8n executa um workflow de erro separado quando uma execução de produção falha. Crie um workflow chamado **Error alert** com um nó **Error Trigger** seguido de um nó **Execute Sub-workflow** que chama o Send push com estes campos:

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Entrada</th><th>Expressão</th></tr></thead>
<tbody>
<tr><th>title</th><td><code>Failed: {{ $json.workflow.name }}</code></td></tr>
<tr><th>message</th><td><code>{{ ($json.execution?.lastNodeExecuted ?? 'Trigger') + ': ' + ($json.execution ?? $json.trigger).error.message }}</code></td></tr>
<tr><th>level</th><td><code>high</code></td></tr>
<tr><th>url</th><td><code>{{ $json.execution?.url ?? '' }}</code></td></tr>
</tbody>
</table>
</div>

Publique também o Error alert; no 2.x, um workflow de erro não publicado é ignorado e aparece no log com a mesma mensagem "not active". Depois, abra cada workflow que você quer monitorar, vá em **Workflow settings** e defina **Error workflow** como Error alert.

Para testar os caminhos, um workflow chamado "Sync orders" foi feito para falhar de propósito: o nó HTTP Request dele recebeu um `503`. O Error Trigger recebeu isto (resumido):

```json
{
  "execution": {
    "id": "5",
    "url": "http://localhost:5678/workflow/WPErAWNJyV6MWO11/executions/5",
    "error": {
      "message": "Service unavailable - try again later or consider setting this node to retry automatically (in the node settings)",
      "description": "down",
      "httpCode": "503"
    },
    "lastNodeExecuted": "Fetch orders",
    "mode": "webhook"
  },
  "workflow": { "id": "WPErAWNJyV6MWO11", "name": "Sync orders" }
}
```

O celular recebeu "Failed: Sync orders" com "Fetch orders: Service unavailable..." e um botão **Open** apontando para aquela execução. Dois detalhes importam:

- **O link da execução usa a sua URL pública.** O n8n monta `execution.url` a partir de `N8N_EDITOR_BASE_URL`, caindo para a URL do webhook se ela não existir. No teste, o endereço era `localhost`, o que não serve de nada no celular. Em uma instância auto-hospedada, defina `N8N_EDITOR_BASE_URL` com o endereço em que você abre o n8n.
- **Um trigger que falha tem outro formato.** Quando o próprio trigger falha, por exemplo um feed RSS que devolve HTML, não existe execução. O payload tem `trigger.error` no lugar de `execution` e não tem URL. O `?.` e o `??` nas expressões acima cobrem esse caso; no teste, a notificação chegou como "Failed: Changelog to phone" com "Trigger: Non-whitespace before first tag..." e sem botão.

## Três workflows que as pessoas realmente criam

Cada um deles termina no mesmo nó Execute Sub-workflow chamando o Send push. Os três rodaram contra o capturador e geraram requisições válidas.

### Um novo envio de formulário

Um **n8n Form Trigger** com três campos rotulados Name, Email e Message. A saída do formulário usa os rótulos como chaves, então as entradas são:

- title: `Contact form: {{ $json.Name }}`
- message: `{{ $json.Email }}` e `{{ $json.Message }}` na linha seguinte
- level: `default`

Deixe `url` vazio aqui. Um botão `view` precisa de uma URL `http(s)`, então um link `mailto:` faria a requisição ser rejeitada com `400`. O mesmo funciona com um nó **Webhook** atrás do formulário do seu próprio site; nesse caso, os campos ficam em `$json.body`. Mais ideias em [alertas de envio de formulário](/use-cases/form-submission-alerts).

### Uma nova publicação em um feed RSS

Um **RSS Feed Trigger** consultando um changelog ou blog a cada 10 minutos:

- title: `New post: {{ $json.title }}`
- message: `{{ $json.contentSnippet }}`
- level: `low`
- url: `{{ $json.link }}`

`contentSnippet` é a descrição sem HTML, então `<p>You can now work <b>offline</b>.</p>` chegou como texto simples. O trigger só emite itens mais novos que o último que viu, então ligá-lo não inunda você com o arquivo antigo. O botão **Open** leva até a publicação.

### Uma verificação agendada

Um **Schedule Trigger** a cada 5 minutos, seguido de um nó **HTTP Request** que faz GET no seu site, com duas opções ativadas em **Response**: **Include Response Headers and Status** e **Never Error**. Sem o Never Error, um `503` interrompe o nó em vez de chegar à etapa seguinte. Depois, um nó **If** com `{{ $json.statusCode }}` diferente de `200`, e no ramo verdadeiro:

- title: `Site check failed: {{ $json.statusCode }}`
- level: `high`
- url: a página que você está verificando

O Never Error cobre códigos de status ruins, não um site que simplesmente não responde. Uma falha de DNS ou um timeout ainda fazem o nó falhar, e aí o workflow de erro envia a notificação. Tenha em mente que uma verificação assim avisa você a cada execução enquanto o site estiver fora do ar: doze notificações por hora num intervalo de 5 minutos. Mais padrões em [alertas de automação](/use-cases/automation-alerts).

## Aprove ou recuse pela tela de bloqueio

Alguns workflows não deveriam terminar sem uma pessoa: um reembolso acima de um limite, uma publicação prestes a sair, um agente de IA prestes a mexer em produção. Os [botões de ação](/features/action-buttons) `http` do Pocket Alert enviam uma requisição direto do celular, e o nó **Wait** do n8n pode pausar até que uma requisição chegue. Juntando tudo:

1. Um trigger com a requisição, aqui um nó **Webhook** recebendo `{"order":"A-1042","amount":129}`.
2. Um nó **HTTP Request** que envia a notificação com dois botões.
3. Um nó **Wait**: **Resume** definido como **On Webhook Call**, **HTTP Method** `POST`, **Limit Wait Time** ativado, 2 horas.
4. Um nó **If**: `{{ $json.body.decision }}` igual a `approve`.

O corpo do nó HTTP Request:

```js
{{ JSON.stringify({
  title: 'Refund $' + $json.body.amount + '?',
  message: 'Order ' + $json.body.order + ' is asking for a refund.',
  level: 'high',
  actions: ['approve', 'decline'].map(decision => ({
    type: 'http',
    label: decision === 'approve' ? 'Approve' : 'Decline',
    value: JSON.stringify({
      url: $execution.resumeUrl,
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ decision })
    })
  }))
}) }}
```

O `http` de um botão `value` é ele mesmo uma string JSON, por isso há um `JSON.stringify` dentro de outro `JSON.stringify`. `$execution.resumeUrl` é o endereço em que o nó Wait escuta para esta execução específica.

No teste, um POST para a URL do botão Aprovar, com o corpo indicado, retornou `200`, o workflow foi retomado e `$json.body.decision` era `approve`, então o nó If seguiu pelo ramo verdadeiro. Recusar foi pelo ramo falso. Os detalhes que exigiram algumas tentativas:

- **Envie a decisão no corpo, não na URL.** No n8n 2.45.7, a URL de retomada já termina em `?signature=...`. Acrescentar `?decision=approve` quebra a assinatura e o n8n responde `401`. Um corpo JSON evita manipulação de string.
- **O segundo toque é recusado.** Depois que a execução é retomada, outro toque retorna `409` "has finished already", e o app mostra a notificação de requisição falhou com um botão Retry. Vale o primeiro toque.
- **Sem resposta significa não.** Quando o limite de 2 horas se esgota, o nó Wait continua sem `decision`, então o nó If vai para o ramo falso. Faça desse ramo o caminho seguro.
- **O celular precisa alcançar o n8n.** A requisição sai do celular, não do Pocket Alert. `$execution.resumeUrl` é montada a partir da URL do seu webhook (`WEBHOOK_URL`, que o n8n 2.45 pede que você renomeie para `N8N_WEBHOOK_URL`). No n8n Cloud ou atrás de um domínio público, isso funciona sem mais nada. Em um servidor doméstico, funciona enquanto o celular estiver na mesma rede, ou por uma VPN como o Tailscale.
- **Botões são um recurso pago.** No plano gratuito, a notificação ainda chega, mas sem botões. Os botões de notificação do sistema exigem o app do Pocket Alert 2.0.1 ou posterior.

O mesmo padrão para agentes de IA está em [notificações com humano no circuito](/blog/human-in-the-loop-notifications).

## Ou faça POST para um webhook do Pocket Alert

Se você preferir não manter uma chave de API no n8n, crie um webhook em [Webhooks](/webhooks) no console e faça o nó HTTP Request enviar um POST com JSON para a URL `https://p4a.me/wh/...` dele, sem autenticação. Um template no webhook transforma o payload na mensagem. A troca: o título é sempre `Webhook <name>`, e o texto vem do template em vez do workflow. O histórico do webhook registra cada requisição recebida, o que ajuda na hora de depurar.

## Limites e solução de problemas

- **Cota diária.** O plano gratuito permite 50 mensagens por dia, com reinício às 00:00 UTC. Um loop sobre 200 itens envia 200 notificações. Depois do limite, a API responde `429`; não deixe o n8n tentar de novo, pois a resposta não muda até o reinício. Veja [limites diários](https://info.pocketalert.app/features/daily-limits.html).
- **`401`** significa que a chave está errada, ou que o nome do cabeçalho na credencial é diferente de `Token`.
- **`400`** significa que o corpo não tem `title` ou `message` (uma expressão que resultou vazia conta), tem um nível desconhecido, ou tem um botão inválido: mais de 3, uma URL `view` que não é `http(s)`, ou um valor `http` que não é uma string JSON com `url`.
- **"not valid JSON" no n8n** significa que um valor quebrou o corpo JSON. Use `JSON.stringify` como no Passo 2.
- **Nada chega quando algo falha.** Confira se o Error alert e o Send push estão publicados e se o workflow que falha tem o Error alert definido nas configurações dele. Execuções de teste manuais pelo editor não disparam o workflow de erro.

## FAQ

### Existe um nó do Pocket Alert para o n8n?

Não por enquanto. O nó HTTP Request cobre a API inteira, e o sub-workflow Send push oferece um bloco parecido com um nó, que você configura uma vez só. Há também um [app oficial para o Make](/blog/make-com-integration), se você usa o Make.

### Isso funciona no n8n Cloud?

Sim. Tudo aqui usa nós nativos. No Cloud, as URLs de execução e de retomada já são públicas, o que poupa a configuração de URL que uma instância auto-hospedada precisa.

### Posso enviar para apenas um celular?

Adicione `device_id` com o ID do dispositivo ao corpo. Sem ele, a notificação vai para todos os seus dispositivos. `application_id` organiza a mensagem dentro de um aplicativo, então os alertas do n8n ganham um canal próprio no app.

[Crie uma conta gratuita](/signup), importe o workflow Send push e aponte o seu workflow de erro para ele. A próxima falha vai aparecer no seu celular em vez de ficar escondida na lista de execuções.
