# Notifiche push con n8n: avvisi sul telefono da ogni workflow

> Invia notifiche push al tuo iPhone o telefono Android da n8n. Un solo nodo HTTP Request, un sub-workflow condiviso "Invia push", un error workflow che ti avvisa quando qualcosa fallisce e pulsanti Approva e Rifiuta che riprendono un workflow in attesa.

*30.10.2026*

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

n8n è bravo a fare cose mentre sei fuori, e poco bravo a dirti cosa ha fatto. Arriva un modulo, un feed riceve un nuovo post, una sincronizzazione fallisce alle 3 di notte, e l'unica traccia è una riga nell'elenco delle esecuzioni che apri la settimana dopo.

Questa guida collega n8n al tuo telefono. Chiamerai l'API di Pocket Alert da un nodo HTTP Request, racchiuderai quella chiamata in un unico sub-workflow riutilizzabile, aggiungerai un error workflow che ti avvisa quando un workflow fallisce e concluderai con i pulsanti Approva e Rifiuta che riprendono un workflow direttamente dalla schermata di blocco.

Tutto ciò che segue è stato testato su n8n 2.45.7 (l'immagine Docker `n8nio/n8n`), con il nodo HTTP Request puntato a un request catcher locale, così ogni richiesta poteva essere verificata con il riferimento dell'API.

## Cosa ti serve

- Un'istanza di n8n: self-hosted o n8n Cloud.
- Un account Pocket Alert e l'app sul tuo telefono [iPhone o Android](/get-app). [Registrati](/signup) gratis.
- Una chiave API da [Chiavi API](/account/apikeys).

## Passo 1: una credenziale Header Auth

Pocket Alert legge la chiave API da un header chiamato `Token`. In n8n crea una credenziale di tipo **Header Auth**:

- **Name:** `Token`
- **Value:** la tua chiave API

Chiama la credenziale `Pocket Alert`. Salvare la chiave come credenziale la tiene fuori dal JSON del workflow, così puoi esportare e condividere i workflow senza esporla.

## Passo 2: il nodo HTTP Request

Aggiungi un nodo **HTTP Request** e configuralo così:

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Campo</th><th>Valore</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>, poi <strong>Header Auth</strong>, poi la credenziale <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>

Il body richiede `title` e `message`. `level` e `actions` sono opzionali. Il modo più ovvio di scriverlo è JSON semplice con espressioni dentro le stringhe:

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

Funziona finché un valore non contiene un doppio apice o un a capo. Con `name` impostato su `Ana "AJ" Silva`, n8n blocca il nodo con "The value in the JSON Body field is not valid JSON", perché l'apice chiude la stringa troppo presto. I messaggi dei moduli e i titoli RSS incappano in questo errore prima di quanto ti aspetteresti.

La soluzione è far costruire il JSON a JavaScript. Metti l'intero body in un'unica espressione:

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

Oppure, se preferisci mantenere la struttura JSON, racchiudi ogni valore dinamico in `JSON.stringify()` e togli le virgolette intorno: `"message": {{ JSON.stringify($json.name + ' on ' + $json.plan) }}`. In test entrambe le versioni hanno prodotto JSON valido, con gli apici escapati. Ecco cosa ha inviato n8n:

```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` accetta `silent`, `low`, `default`, `high` o `critical`. `high` supera la Full immersion su iPhone. `critical` suona anche con l'interruttore silenzioso e con Non disturbare. È una funzione a pagamento; sul piano gratuito arriva come `high`. Maggiori dettagli in [livelli di priorità](https://info.pocketalert.app/features/priority-levels.html).

## Passo 3: un sub-workflow "Invia push" per tutto

Copiare quel nodo in ogni workflow significa modificare dieci workflow quando cambi la chiave, la logica dei livelli o il pulsante. Mettilo invece in un unico sub-workflow e richiamalo da tutti gli altri.

Copia questo JSON e incollalo su un canvas vuoto di n8n (oppure salvalo come file e usa **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" }
}
```

Dopo l'importazione, apri il nodo **Pocket Alert** e scegli la tua credenziale. Il sub-workflow accetta quattro input: `title`, `message`, un `level` opzionale che ricade su `default`, e un `url` opzionale. Quando `url` è impostato, la push riceve un pulsante **Open** che lo apre. Un array `actions` vuoto è accettato e significa semplicemente nessun pulsante.

**Pubblicalo.** Su n8n 2.x, le esecuzioni in produzione chiamano la versione pubblicata di un sub-workflow. Finché non pubblichi Send push, ogni chiamata programmata o attivata da webhook fallisce con "Workflow is not active and cannot be executed", anche se un test manuale dall'editor funziona, perché i test manuali usano la bozza. Lo stesso vale dopo le modifiche: le modifiche a Send push arrivano in produzione solo quando le pubblichi di nuovo.

Per richiamarlo da un altro workflow, aggiungi un nodo **Execute Sub-workflow**, scegli **Send push** dalla lista e compila i quattro campi con delle espressioni, ad esempio `New order #{{ $json.id }}` per il titolo.

## Ricevi una push quando un workflow fallisce

n8n esegue un error workflow separato quando un'esecuzione in produzione fallisce. Crea un workflow chiamato **Error alert** con un nodo **Error Trigger** seguito da un nodo **Execute Sub-workflow** che richiama Send push con questi campi:

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Input</th><th>Espressione</th></tr></thead>
<tbody>
<tr><th>title</th><td><code>Fallito: {{ $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>

Pubblica anche Error alert; su 2.x un error workflow non pubblicato viene saltato, con lo stesso messaggio "not active" nel log. Poi apri ogni workflow che ti interessa, vai su **Workflow settings** e imposta **Error workflow** su Error alert.

Per verificare i percorsi, un workflow chiamato "Sync orders" è stato fatto fallire di proposito: il suo nodo HTTP Request ha ricevuto un `503`. L'Error Trigger ha ricevuto questo (abbreviato):

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

Il telefono ha ricevuto "Fallito: Sync orders" con "Fetch orders: Service unavailable..." e un pulsante **Open** che punta a quell'esecuzione. Due dettagli sono importanti:

- **Il link all'esecuzione usa il tuo URL pubblico.** n8n costruisce `execution.url` a partire da `N8N_EDITOR_BASE_URL`, con ripiego sull'URL del webhook. Nel test era `localhost`, che sul telefono non serve a nulla. Su un'istanza self-hosted, imposta `N8N_EDITOR_BASE_URL` sull'indirizzo con cui apri n8n.
- **Un trigger che fallisce appare diverso.** Quando fallisce il trigger stesso, ad esempio un feed RSS che restituisce HTML, non c'è un'esecuzione. Il payload contiene `trigger.error` al posto di `execution`, e nessun URL. Gli operatori `?.` e `??` nelle espressioni sopra gestiscono questo caso; nel test è arrivato come "Fallito: Changelog to phone" con "Trigger: Non-whitespace before first tag..." e nessun pulsante.

## Tre workflow che la gente costruisce davvero

Ognuno di questi termina con lo stesso nodo Execute Sub-workflow che richiama Send push. Tutti e tre sono stati eseguiti contro il catcher e hanno prodotto richieste valide.

### Un nuovo invio di modulo

Un **n8n Form Trigger** con tre campi etichettati Name, Email e Message. L'output del modulo usa le etichette come chiavi, quindi gli input sono:

- title: `Contact form: {{ $json.Name }}`
- message: `{{ $json.Email }}` e `{{ $json.Message }}` sulla riga successiva
- level: `default`

Qui lascia `url` vuoto. Un pulsante `view` richiede un URL `http(s)`, quindi un link `mailto:` farebbe rifiutare la richiesta con `400`. Lo stesso vale con un nodo **Webhook** collegato al modulo del tuo sito: in quel caso i campi si trovano sotto `$json.body`. Altre idee in [avvisi per invii di moduli](/use-cases/form-submission-alerts).

### Un nuovo post in un feed RSS

Un **RSS Feed Trigger** che controlla un changelog o un blog ogni 10 minuti:

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

`contentSnippet` è la descrizione senza HTML, quindi `<p>You can now work <b>offline</b>.</p>` è arrivato come testo semplice. Il trigger emette solo gli elementi più recenti dell'ultimo che ha visto, quindi attivarlo non ti sommerà l'archivio. Il pulsante **Open** porta al post.

### Un controllo programmato

**Schedule Trigger** ogni 5 minuti, poi un nodo **HTTP Request** che fa una GET al tuo sito con due opzioni attive in **Response**: **Include Response Headers and Status** e **Never Error**. Senza Never Error, un `503` blocca il nodo invece di passare allo step successivo. Poi un nodo **If** con `{{ $json.statusCode }}` diverso da `200`, e sul ramo true:

- title: `Site check failed: {{ $json.statusCode }}`
- level: `high`
- url: la pagina che stai controllando

Never Error copre i codici di stato errati, non un sito che non risponde affatto. Un errore DNS o un timeout fa comunque fallire il nodo, e a quel punto l'error workflow invia la push. Tieni presente che un controllo del genere ti avvisa a ogni esecuzione finché il sito è giù: dodici push all'ora con un intervallo di 5 minuti. Altri schemi in [avvisi per automazioni](/use-cases/automation-alerts).

## Approva o rifiuta dalla schermata di blocco

Alcuni workflow non dovrebbero concludersi senza una persona: un rimborso sopra un limite, la pubblicazione di un post, un agente AI che sta per toccare la produzione. I [pulsanti di azione](/features/action-buttons) `http` di Pocket Alert inviano una richiesta direttamente dal telefono, e il nodo **Wait** di n8n può mettere in pausa finché non arriva una richiesta. Mettili insieme:

1. Un trigger con la richiesta, qui un nodo **Webhook** che riceve `{"order":"A-1042","amount":129}`.
2. Un nodo **HTTP Request** che invia la push con due pulsanti.
3. Un nodo **Wait**: **Resume** impostato su **On Webhook Call**, **HTTP Method** `POST`, **Limit Wait Time** attivo, 2 ore.
4. Un nodo **If**: `{{ $json.body.decision }}` uguale a `approve`.

Il body del nodo 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 })
    })
  }))
}) }}
```

Il `http` di un pulsante `value` è a sua volta una stringa JSON, ed è per questo che c'è un `JSON.stringify` dentro un altro `JSON.stringify`. `$execution.resumeUrl` è l'indirizzo su cui il nodo Wait resta in ascolto per questa singola esecuzione.

In test, una POST all'URL del pulsante Approva con il suo body ha restituito `200`, il workflow è ripartito e `$json.body.decision` era `approve`, quindi il nodo If ha preso il ramo true. Rifiuta è finito sul ramo false. I dettagli che hanno richiesto qualche tentativo:

- **Invia la decisione nel body, non nell'URL.** Su n8n 2.45.7 l'URL di resume termina già con `?signature=...`. Aggiungere `?decision=approve` rompe la firma e n8n risponde `401`. Un body JSON evita manipolazioni di stringhe.
- **Il secondo tocco viene rifiutato.** Una volta che l'esecuzione è ripartita, un altro tocco riceve `409` "has finished already", e l'app mostra la sua notifica di richiesta fallita con un pulsante Riprova. Conta il primo tocco.
- **Nessuna risposta equivale a un no.** Quando scade il limite di 2 ore, il nodo Wait continua senza `decision`, quindi il nodo If va sul ramo false. Rendi sicuro quel ramo.
- **Il telefono deve poter raggiungere n8n.** La richiesta parte dal telefono, non da Pocket Alert. `$execution.resumeUrl` è costruito a partire dal tuo URL del webhook (`WEBHOOK_URL`, che n8n 2.45 ti chiede di rinominare in `N8N_WEBHOOK_URL`). Su n8n Cloud o dietro un dominio pubblico funziona senza problemi. Su un home server funziona finché il telefono è sulla stessa rete, oppure tramite una VPN come Tailscale.
- **I pulsanti sono una funzione a pagamento.** Sul piano gratuito la push arriva comunque, ma senza pulsanti. I pulsanti delle notifiche di sistema richiedono l'app Pocket Alert 2.0.1 o successiva.

Lo stesso schema per gli agenti AI è in [notifiche human-in-the-loop](/blog/human-in-the-loop-notifications).

## Oppure invia una POST a un webhook di Pocket Alert

Se preferisci non tenere una chiave API in n8n, crea un webhook da [Webhook](/webhooks) nella console e fai in modo che il nodo HTTP Request invii un JSON in POST al suo URL `https://p4a.me/wh/...` senza autenticazione. Un template sul webhook trasforma il payload nel messaggio. Il compromesso: il titolo è sempre `Webhook <name>`, e il testo arriva dal template invece che dal workflow. Lo storico dei webhook registra ogni richiesta ricevuta, utile per il debug.

## Limiti e risoluzione dei problemi

- **Quota giornaliera.** Il piano gratuito consente 50 messaggi al giorno, con reset alle 00:00 UTC. Un ciclo su 200 elementi invia 200 push. Dopo il limite l'API risponde `429`; non lasciare che n8n riprovi, la risposta non cambierà fino al reset. Vedi [limiti giornalieri](https://info.pocketalert.app/features/daily-limits.html).
- **`401`** significa che la chiave è sbagliata, oppure che il nome dell'header nella credenziale è diverso da `Token`.
- **`400`** significa che al body manca `title` o `message` (conta anche un'espressione che restituisce un valore vuoto), che il livello non è valido, oppure che c'è un pulsante non valido: più di 3, un URL `view` che non è `http(s)`, o un valore `http` che non è una stringa JSON con un `url`.
- **"not valid JSON" in n8n** significa che un valore ha rotto il body JSON. Passa a `JSON.stringify` come nel Passo 2.
- **Nessuna notifica in caso di errore.** Controlla che Error alert e Send push siano entrambi pubblicati e che il workflow che fallisce abbia Error alert impostato nelle sue impostazioni. Le esecuzioni di test manuali dall'editor non attivano l'error workflow.

## FAQ

### Esiste un nodo Pocket Alert per n8n?

Al momento no. Il nodo HTTP Request copre tutta l'API, e il sub-workflow Send push ti offre un blocco simile a un nodo che configuri una sola volta. C'è un'[app ufficiale per Make](/blog/make-com-integration) se usi Make.

### Funziona su n8n Cloud?

Sì. Tutto ciò che è qui usa nodi integrati. Su Cloud gli URL di esecuzione e di resume sono già pubblici, il che ti risparmia la configurazione dell'URL che serve a un'istanza self-hosted.

### Posso inviare a un solo telefono?

Aggiungi `device_id` con l'ID del dispositivo nel body. Senza, la push va a tutti i tuoi dispositivi. `application_id` archivia il messaggio sotto un'applicazione, così gli avvisi di n8n hanno un canale dedicato nell'app.

[Crea un account gratuito](/signup), importa il workflow Send push e collega il tuo error workflow. La prossima esecuzione fallita comparirà sul telefono invece che nell'elenco delle esecuzioni.
