# Notifications push n8n : des alertes sur votre téléphone depuis n’importe quel workflow

> Envoyez des notifications push sur votre iPhone ou téléphone Android depuis n8n. Un nœud HTTP Request, un sous-workflow « Send push » partagé, un workflow d’erreur qui vous prévient en cas d’échec, et des boutons Approuver et Refuser qui reprennent un workflow en attente.

*30.10.2026*

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

n8n sait très bien exécuter des tâches pendant votre absence, mais il vous prévient mal. Un formulaire arrive, un flux reçoit une nouvelle publication, une synchronisation échoue à 3 h du matin, et la seule trace est une ligne dans la liste des exécutions que vous ouvrirez la semaine suivante.

Ce guide connecte n8n à votre téléphone. Vous appellerez l’API Pocket Alert depuis un nœud HTTP Request, encapsulerez cet appel dans un sous-workflow réutilisable, ajouterez un workflow d’erreur qui vous avertit dès qu’un workflow échoue, et terminerez par des boutons Approuver et Refuser qui reprennent un workflow depuis l’écran verrouillé.

Tout ce qui suit a été testé sur n8n 2.45.7 (l’image Docker `n8nio/n8n`), le nœud HTTP Request pointant vers un collecteur de requêtes local afin de pouvoir vérifier chaque requête par rapport à la référence de l’API.

## Ce dont vous avez besoin

- Une instance n8n : auto-hébergée ou n8n Cloud.
- Un compte Pocket Alert et l’application sur votre [iPhone ou téléphone Android](/get-app). [Créer un compte](/signup) gratuitement.
- Une clé API depuis [Clés API](/account/apikeys).

## Étape 1 : un identifiant Header Auth

Pocket Alert lit la clé API dans un en-tête nommé `Token`. Dans n8n, créez un identifiant de type **Header Auth** :

- **Name :** `Token`
- **Value :** votre clé API

Nommez l’identifiant `Pocket Alert`. Stocker la clé sous forme d’identifiant la garde hors du JSON du workflow : vous pouvez ainsi exporter et partager vos workflows sans fuite de la clé.

## Étape 2 : le nœud HTTP Request

Ajoutez un nœud **HTTP Request** et configurez-le comme suit :

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Champ</th><th>Valeur</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>, puis <strong>Header Auth</strong>, puis l’identifiant <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>

Le corps doit contenir `title` et `message`. `level` et `actions` sont facultatifs. La façon la plus évidente d’écrire le corps est un JSON simple avec des expressions dans les chaînes :

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

Cela fonctionne jusqu’à ce qu’une valeur contienne un guillemet double ou un saut de ligne. Avec `name` valant `Ana "AJ" Silva`, n8n arrête le nœud avec le message « The value in the JSON Body field is not valid JSON », car le guillemet termine la chaîne trop tôt. Les messages de formulaire et les titres RSS rencontrent ce problème plus souvent qu’on ne l’imagine.

La solution consiste à laisser JavaScript construire le JSON. Placez tout le corps dans une seule expression :

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

Ou, si vous préférez garder la mise en forme JSON, entourez chaque valeur dynamique de `JSON.stringify()` et supprimez les guillemets qui l’entourent : `"message": {{ JSON.stringify($json.name + ' on ' + $json.plan) }}`. Les deux méthodes ont produit un JSON valide, avec les guillemets échappés, lors des tests. Voici ce que n8n a envoyé :

```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` accepte `silent`, `low`, `default`, `high` ou `critical`. `high` passe la concentration sur iPhone. `critical` joue le son malgré le commutateur silencieux et le mode Ne pas déranger. C’est une fonctionnalité payante ; sur l’offre gratuite, elle est remplacée par `high`. Plus de détails dans [les niveaux de priorité](https://info.pocketalert.app/features/priority-levels.html).

## Étape 3 : un sous-workflow « Send push » pour tout

Copier ce nœud dans chaque workflow signifie devoir modifier dix workflows dès que vous changez la clé, la logique des niveaux ou le bouton. Placez-le plutôt dans un seul sous-workflow et appelez-le depuis les autres.

Copiez ce JSON et collez-le sur un canevas n8n vide (ou enregistrez-le dans un fichier et utilisez **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" }
}
```

Après l’import, ouvrez le nœud **Pocket Alert** et sélectionnez votre identifiant. Le sous-workflow reçoit quatre entrées : `title`, `message`, un `level` facultatif qui revient à `default` si absent, et un `url` facultatif. Lorsque `url` est renseigné, la notification push reçoit un bouton **Open** qui l’ouvre. Un tableau `actions` vide est accepté et signifie simplement qu’il n’y a aucun bouton.

**Publiez-le.** Sur n8n 2.x, les exécutions en production appellent la version publiée d’un sous-workflow. Tant que Send push n’est pas publié, chaque appel planifié ou déclenché par webhook échoue avec « Workflow is not active and cannot be executed », même si un test manuel depuis l’éditeur fonctionne, car les exécutions manuelles utilisent le brouillon. Il en va de même après chaque modification : les changements apportés à Send push ne parviennent en production qu’après une nouvelle publication.

Pour l’appeler depuis un autre workflow, ajoutez un nœud **Execute Sub-workflow**, choisissez **Send push** dans la liste, puis remplissez les quatre champs avec des expressions, par exemple `New order #{{ $json.id }}` pour le titre.

## Recevoir une notification push quand un workflow échoue

n8n exécute un workflow d’erreur distinct lorsqu’une exécution en production échoue. Créez un workflow nommé **Error alert** avec un nœud **Error Trigger** suivi d’un nœud **Execute Sub-workflow** qui appelle Send push avec ces champs :

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Entrée</th><th>Expression</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>

Publiez aussi Error alert : sur la 2.x, un workflow d’erreur non publié est ignoré, avec le même message « not active » dans le journal. Ensuite, ouvrez chaque workflow qui vous importe, allez dans **Workflow settings** et définissez **Error workflow** sur Error alert.

Pour vérifier les chemins, un workflow nommé « Sync orders » a été volontairement conçu pour échouer : son nœud HTTP Request a reçu un `503`. Le nœud Error Trigger a reçu ceci (tronqué) :

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

Le téléphone a reçu « Failed: Sync orders » avec « Fetch orders: Service unavailable... » et un bouton **Open** pointant vers cette exécution. Deux points comptent :

- **Le lien d’exécution utilise votre URL publique.** n8n construit `execution.url` à partir de `N8N_EDITOR_BASE_URL`, avec repli sur l’URL du webhook. Pendant le test, il s’agissait de `localhost`, inutilisable sur un téléphone. Sur une instance auto-hébergée, définissez `N8N_EDITOR_BASE_URL` sur l’adresse à laquelle vous ouvrez n8n.
- **Un déclencheur défaillant se présente autrement.** Lorsque le déclencheur lui-même échoue, par exemple un flux RSS qui renvoie du HTML, il n’y a pas d’exécution. La charge utile contient `trigger.error` au lieu de `execution`, et aucune URL. Les `?.` et `??` des expressions ci-dessus gèrent ce cas ; lors du test, la notification est arrivée sous la forme « Failed: Changelog to phone » avec « Trigger: Non-whitespace before first tag... » et sans bouton.

## Trois workflows que les gens construisent vraiment

Chacun se termine par le même nœud Execute Sub-workflow qui appelle Send push. Les trois ont été exécutés sur le collecteur et ont produit des requêtes valides.

### Un nouvel envoi de formulaire

Un **n8n Form Trigger** avec trois champs intitulés Name, Email et Message. La sortie du formulaire utilise les intitulés comme clés, donc les entrées sont :

- title : `Contact form: {{ $json.Name }}`
- message : `{{ $json.Email }}` puis `{{ $json.Message }}` sur la ligne suivante
- level : `default`

Laissez `url` vide ici. Un bouton `view` nécessite une URL `http(s)`, donc un lien `mailto:` ferait rejeter la requête avec une erreur `400`. La même chose fonctionne avec un nœud **Webhook** placé derrière le formulaire de votre propre site : les champs se trouvent alors sous `$json.body`. Plus d’idées dans [les alertes de formulaire](/use-cases/form-submission-alerts).

### Une nouvelle publication dans un flux RSS

Un **RSS Feed Trigger** qui interroge un journal des modifications ou un blog toutes les 10 minutes :

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

`contentSnippet` correspond à la description sans HTML : `<p>You can now work <b>offline</b>.</p>` est donc arrivé sous forme de texte brut. Le déclencheur n’émet que les éléments plus récents que le dernier vu, donc l’activer ne vous inonde pas d’archives. Le bouton **Open** mène à la publication.

### Une vérification planifiée

Un **Schedule Trigger** toutes les 5 minutes, suivi d’un nœud **HTTP Request** qui effectue un GET sur votre site, avec deux options activées sous **Response** : **Include Response Headers and Status** et **Never Error**. Sans Never Error, un `503` arrête le nœud au lieu d’atteindre l’étape suivante. Ensuite, un nœud **If** avec `{{ $json.statusCode }}` différent de `200`, et sur la branche vraie :

- title : `Site check failed: {{ $json.statusCode }}`
- level : `high`
- url : la page que vous vérifiez

Never Error couvre les mauvais codes de statut, mais pas un site qui ne répond pas du tout. Un échec DNS ou un délai d’attente fait toujours échouer le nœud, et c’est alors le workflow d’erreur qui envoie la notification. Gardez à l’esprit qu’une vérification de ce type vous sollicite à chaque exécution tant que le site est hors ligne : douze notifications par heure avec un intervalle de 5 minutes. Plus de modèles dans [les alertes d’automatisation](/use-cases/automation-alerts).

## Approuver ou refuser depuis l’écran verrouillé

Certains workflows ne devraient pas se terminer sans intervention humaine : un remboursement au-delà d’un seuil, une publication sur le point de partir, un agent IA sur le point de modifier la production. Les [boutons d’action](/features/action-buttons) `http` de Pocket Alert envoient une requête directement depuis le téléphone, et le nœud **Wait** de n8n peut suspendre le workflow jusqu’à l’arrivée d’une requête. Combinez les deux :

1. Un déclencheur qui reçoit la requête, ici un nœud **Webhook** recevant `{"order":"A-1042","amount":129}`.
2. Un nœud **HTTP Request** qui envoie la notification push avec deux boutons.
3. Un nœud **Wait** : **Resume** réglé sur **On Webhook Call**, **HTTP Method** `POST`, **Limit Wait Time** activé, 2 heures.
4. Un nœud **If** : `{{ $json.body.decision }}` est égal à `approve`.

Le corps du nœud 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 })
    })
  }))
}) }}
```

La valeur `http` d’un bouton `value` est elle-même une chaîne JSON, d’où le `JSON.stringify` imbriqué dans un autre `JSON.stringify`. `$execution.resumeUrl` est l’adresse sur laquelle le nœud Wait écoute pour cette exécution précise.

Lors du test, un POST sur l’URL du bouton Approuver avec son corps a renvoyé `200`, le workflow a repris et `$json.body.decision` valait `approve`, donc le nœud If a emprunté la branche vraie. Refuser a emprunté la branche fausse. Les points qui ont demandé quelques essais :

- **Envoyez la décision dans le corps, pas dans l’URL.** Sur n8n 2.45.7, l’URL de reprise se termine déjà par `?signature=...`. Ajouter `?decision=approve` casse la signature et n8n répond `401`. Un corps JSON évite toute manipulation de chaîne.
- **Le second appui est refusé.** Une fois l’exécution reprise, un nouvel appui renvoie `409` « has finished already », et l’application affiche sa notification d’échec de requête avec un bouton Réessayer. Le premier appui est celui qui compte.
- **Pas de réponse signifie non.** Lorsque la limite de 2 heures expire, le nœud Wait continue sans `decision`, donc le nœud If prend la branche fausse. Faites de cette branche la branche sûre.
- **Le téléphone doit pouvoir joindre n8n.** La requête part du téléphone, et non de Pocket Alert. `$execution.resumeUrl` est construit à partir de votre URL de webhook (`WEBHOOK_URL`, que n8n 2.45 vous demande de renommer en `N8N_WEBHOOK_URL`). Sur n8n Cloud ou derrière un domaine public, cela fonctionne tout seul. Sur un serveur domestique, cela fonctionne tant que le téléphone est sur le même réseau, ou via un VPN comme Tailscale.
- **Les boutons sont une fonctionnalité payante.** Sur l’offre gratuite, la notification push arrive toujours, mais sans boutons. Les boutons des notifications système nécessitent l’application Pocket Alert 2.0.1 ou ultérieure.

Le même schéma pour les agents IA est décrit dans [les notifications avec intervention humaine](/blog/human-in-the-loop-notifications).

## Ou envoyer un POST vers un webhook Pocket Alert

Si vous préférez ne pas conserver de clé API dans n8n, créez un webhook dans [Webhooks](/webhooks) depuis la console, puis faites envoyer au nœud HTTP Request un POST de JSON vers son URL `https://p4a.me/wh/...`, sans authentification. Un modèle associé au webhook transforme la charge utile en message. Le compromis : le titre est toujours `Webhook <name>`, et le texte provient du modèle plutôt que du workflow. L’historique du webhook journalise chaque requête reçue, ce qui est utile pour le débogage.

## Limites et dépannage

- **Quota quotidien.** L’offre gratuite autorise 50 messages par jour, réinitialisés à 00:00 UTC. Une boucle sur 200 éléments envoie 200 notifications push. Au-delà de la limite, l’API répond `429` ; ne laissez pas n8n réessayer, la réponse ne changera pas avant la réinitialisation. Voir [les limites quotidiennes](https://info.pocketalert.app/features/daily-limits.html).
- **`401`** signifie que la clé est incorrecte, ou que le nom de l’en-tête dans l’identifiant n’est pas `Token`.
- **`400`** signifie que le corps ne contient pas `title` ou `message` (une expression qui renvoie une valeur vide compte), qu’il contient un niveau inconnu, ou qu’un bouton n’est pas valide : plus de 3 boutons, une URL `view` qui n’est pas `http(s)`, ou une valeur `http` qui n’est pas une chaîne JSON avec une `url`.
- **« not valid JSON » dans n8n** signifie qu’une valeur a cassé le corps JSON. Passez à `JSON.stringify` comme à l’étape 2.
- **Rien en cas d’échec.** Vérifiez qu’Error alert et Send push sont tous deux publiés, et que le workflow en échec a Error alert défini dans ses paramètres. Les tests manuels depuis l’éditeur ne déclenchent pas le workflow d’erreur.

## FAQ

### Existe-t-il un nœud Pocket Alert pour n8n ?

Pas pour le moment. Le nœud HTTP Request couvre l’ensemble de l’API, et le sous-workflow Send push vous offre un bloc semblable à un nœud, que vous configurez une seule fois. Il existe une [application officielle pour Make](/blog/make-com-integration) si vous utilisez Make.

### Est-ce que cela fonctionne sur n8n Cloud ?

Oui. Tout ce qui est décrit ici repose sur des nœuds intégrés. Sur Cloud, les URL d’exécution et de reprise sont déjà publiques, ce qui évite la configuration des URL dont a besoin une instance auto-hébergée.

### Puis-je envoyer vers un seul téléphone ?

Ajoutez `device_id` avec l’identifiant de l’appareil dans le corps. Sans lui, la notification push part vers tous vos appareils. `application_id` classe le message dans une application, afin que les alertes n8n aient leur propre canal dans l’application.

[Créez un compte gratuit](/signup), importez le workflow Send push et faites pointer votre workflow d’erreur vers lui. La prochaine exécution en échec apparaîtra sur votre téléphone au lieu de la liste des exécutions.
