# n8n Push-Benachrichtigungen: Alarme auf dein Handy aus jedem Workflow

> Sende Push-Benachrichtigungen von n8n auf dein iPhone oder Android-Handy. Ein HTTP-Request-Node, ein gemeinsamer Sub-Workflow „Send push“, ein Error-Workflow, der dich bei jedem Fehler anpingt, und Buttons für Genehmigen und Ablehnen, die einen wartenden Workflow fortsetzen.

*30.10.2026*

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

n8n ist gut darin, Dinge zu erledigen, während du weg bist, und schlecht darin, dir davon zu erzählen. Ein Formular kommt rein, ein Feed bekommt einen neuen Beitrag, ein Sync schlägt um 3 Uhr morgens fehl, und die einzige Spur ist eine Zeile in der Ausführungsliste, die du nächste Woche öffnest.

Diese Anleitung verbindet n8n mit deinem Handy. Du rufst die Pocket Alert API aus einem HTTP-Request-Node auf, packst diesen Aufruf in einen wiederverwendbaren Sub-Workflow, fügst einen Error-Workflow hinzu, der dich anpingt, sobald irgendein Workflow fehlschlägt, und schließt mit Buttons für Genehmigen und Ablehnen ab, mit denen ein Workflow direkt vom Sperrbildschirm aus fortgesetzt wird.

Alles unten wurde mit n8n 2.45.7 getestet (das Docker-Image `n8nio/n8n`). Der HTTP-Request-Node zeigte dabei auf einen lokalen Request-Catcher, damit jeder Request gegen die API-Referenz geprüft werden konnte.

## Was du brauchst

- Eine n8n-Instanz: selbst gehostet oder n8n Cloud.
- Ein Pocket Alert-Konto und die App auf deinem [iPhone oder Android](/get-app)-Handy. [Registriere dich](/signup) kostenlos.
- Einen API-Schlüssel aus [API Keys](/account/apikeys).

## Schritt 1: ein Header-Auth-Credential

Pocket Alert liest den API-Schlüssel aus einem Header namens `Token`. Erstelle in n8n ein Credential vom Typ **Header Auth**:

- **Name:** `Token`
- **Value:** dein API-Schlüssel

Nenne das Credential `Pocket Alert`. Wenn du den Schlüssel als Credential speicherst, landet er nicht im Workflow-JSON, sodass du Workflows exportieren und teilen kannst, ohne den Schlüssel preiszugeben.

## Schritt 2: der HTTP-Request-Node

Füge einen **HTTP Request**-Node hinzu und richte ihn so ein:

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Feld</th><th>Wert</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>, dann <strong>Header Auth</strong>, dann das Credential <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>

Der Body braucht `title` und `message`. `level` und `actions` sind optional. Der naheliegende Weg ist einfaches JSON mit Expressions in den Strings:

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

Das funktioniert, bis ein Wert ein doppeltes Anführungszeichen oder einen Zeilenumbruch enthält. Mit `name` gleich `Ana "AJ" Silva` bricht n8n den Node mit „The value in the JSON Body field is not valid JSON“ ab, weil das Anführungszeichen den String vorzeitig beendet. Formularnachrichten und RSS-Titel stoßen da früher an die Grenze, als man denkt.

Die Lösung ist, JavaScript das JSON bauen zu lassen. Packe den ganzen Body in einen einzigen Ausdruck:

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

Oder, wenn du das JSON-Layout beibehalten willst, umschließe jeden dynamischen Wert mit `JSON.stringify()` und lass die Anführungszeichen darum weg: `"message": {{ JSON.stringify($json.name + ' on ' + $json.plan) }}`. Beide Varianten erzeugten im Test gültiges JSON mit maskierten Anführungszeichen. So sah der Request aus, den n8n gesendet hat:

```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` akzeptiert `silent`, `low`, `default`, `high` oder `critical`. `high` durchbricht auf dem iPhone den Fokus. `critical` spielt auch bei stummgeschaltetem Schalter und bei Nicht stören einen Ton ab. Das ist eine kostenpflichtige Funktion; im kostenlosen Tarif kommt sie als `high` an. Mehr dazu unter [Prioritätsstufen](https://info.pocketalert.app/features/priority-levels.html).

## Schritt 3: ein Sub-Workflow „Send push“ für alles

Wenn du den Node in jeden Workflow kopierst, musst du bei einer Änderung am Schlüssel, an der Level-Logik oder am Button zehn Workflows anfassen. Lege ihn stattdessen in einem Sub-Workflow ab und rufe ihn überall sonst auf.

Kopiere dieses JSON und füge es auf einer leeren n8n-Arbeitsfläche ein (oder speichere es als Datei und nutze **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" }
}
```

Nach dem Import öffne den Node **Pocket Alert** und wähle dein Credential aus. Der Sub-Workflow nimmt vier Eingaben entgegen: `title`, `message`, ein optionales `level`, das auf `default` zurückfällt, und eine optionale `url`. Ist `url` gesetzt, bekommt die Push-Benachrichtigung einen Button **Open**, der sie öffnet. Ein leeres Array `actions` wird akzeptiert und bedeutet einfach keine Buttons.

**Veröffentliche ihn.** In n8n 2.x rufen Produktionsläufe die veröffentlichte Version eines Sub-Workflows auf. Solange du Send push nicht veröffentlichst, schlägt jeder geplante oder webhook-gestartete Aufruf mit „Workflow is not active and cannot be executed“ fehl, obwohl ein manueller Test aus dem Editor funktioniert, weil manuelle Läufe den Entwurf verwenden. Dasselbe gilt nach Änderungen: Anpassungen an Send push erreichen die Produktion erst, wenn du erneut veröffentlichst.

Um ihn aus einem anderen Workflow aufzurufen, füge einen **Execute Sub-workflow**-Node hinzu, wähle **Send push** aus der Liste und fülle die vier Felder mit Expressions, zum Beispiel `New order #{{ $json.id }}` als Titel.

## Eine Push-Benachrichtigung, wenn ein Workflow fehlschlägt

n8n führt einen eigenen Error-Workflow aus, wenn eine Produktionsausführung fehlschlägt. Erstelle einen Workflow namens **Error alert** mit einem **Error Trigger**-Node, gefolgt von einem **Execute Sub-workflow**-Node, der Send push mit diesen Feldern aufruft:

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Eingabe</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>

Veröffentliche auch Error alert; in 2.x wird ein nicht veröffentlichter Error-Workflow übersprungen, und das Log zeigt dieselbe Meldung „not active“. Öffne dann jeden Workflow, der dir wichtig ist, gehe zu **Workflow settings** und setze **Error workflow** auf Error alert.

Um die Pfade zu prüfen, wurde ein Workflow namens „Sync orders“ absichtlich fehlschlagen gelassen: Sein HTTP-Request-Node bekam ein `503`. Der Error Trigger erhielt Folgendes (gekürzt):

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

Auf dem Handy kam „Failed: Sync orders“ an, mit „Fetch orders: Service unavailable...“ und einem Button **Open**, der auf diese Ausführung zeigt. Zwei Details sind wichtig:

- **Der Ausführungslink nutzt deine öffentliche URL.** n8n baut `execution.url` aus `N8N_EDITOR_BASE_URL` auf und fällt auf die Webhook-URL zurück. Im Test war das `localhost`, was auf dem Handy nutzlos ist. Setze bei einer selbst gehosteten Instanz `N8N_EDITOR_BASE_URL` auf die Adresse, unter der du n8n öffnest.
- **Ein fehlschlagender Trigger sieht anders aus.** Wenn der Trigger selbst fehlschlägt, zum Beispiel ein RSS-Feed, der HTML zurückgibt, gibt es keine Ausführung. Die Payload enthält `trigger.error` statt `execution` und keine URL. Die `?.`- und `??`-Operatoren in den Expressions oben fangen diesen Fall ab; im Test kam „Failed: Changelog to phone“ mit „Trigger: Non-whitespace before first tag...“ und ohne Button an.

## Drei Workflows, die Leute tatsächlich bauen

Jeder davon endet im selben Execute-Sub-workflow-Node, der Send push aufruft. Alle drei liefen gegen den Catcher und erzeugten gültige Requests.

### Ein neues Formular-Absenden

Ein **n8n Form Trigger** mit drei Feldern, beschriftet Name, Email und Message. Die Ausgabe des Formulars verwendet die Beschriftungen als Schlüssel, daher lauten die Eingaben:

- title: `Contact form: {{ $json.Name }}`
- message: `{{ $json.Email }}` und `{{ $json.Message }}` in der nächsten Zeile
- level: `default`

Lass `url` hier leer. Ein Button `view` braucht eine `http(s)`-URL; ein `mailto:`-Link würde den Request mit `400` ablehnen lassen. Dasselbe funktioniert mit einem **Webhook**-Node hinter dem Formular deiner eigenen Website; dann liegen die Felder unter `$json.body`. Weitere Ideen findest du unter [Benachrichtigungen bei Formular-Absendungen](/use-cases/form-submission-alerts).

### Ein neuer Beitrag in einem RSS-Feed

Ein **RSS Feed Trigger**, der einen Changelog oder Blog alle 10 Minuten abfragt:

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

`contentSnippet` ist die Beschreibung ohne HTML-Tags, daher kam `<p>You can now work <b>offline</b>.</p>` als Klartext an. Der Trigger liefert nur Einträge, die neuer sind als der zuletzt gesehene, sodass dich das Einschalten nicht mit dem gesamten Archiv überflutet. Der Button **Open** führt zum Beitrag.

### Eine geplante Prüfung

Ein **Schedule Trigger** alle 5 Minuten, danach ein **HTTP Request**-Node, der deine Website per GET aufruft, mit zwei aktivierten Optionen unter **Response**: **Include Response Headers and Status** und **Never Error**. Ohne Never Error stoppt ein `503` den Node, statt den nächsten Schritt zu erreichen. Danach ein **If**-Node mit `{{ $json.statusCode }}` ist nicht gleich `200`, und im Zweig „true“:

- title: `Site check failed: {{ $json.statusCode }}`
- level: `high`
- url: die Seite, die du prüfst

Never Error deckt schlechte Statuscodes ab, nicht eine Website, die gar nicht antwortet. Ein DNS-Fehler oder ein Timeout lässt den Node weiterhin fehlschlagen, und dann sendet der Error-Workflow die Push-Benachrichtigung. Bedenke, dass dich eine solche Prüfung bei jedem Lauf anpingt, solange die Website down ist: bei einem 5-Minuten-Intervall also zwölf Pushes pro Stunde. Weitere Muster findest du unter [Benachrichtigungen für Automatisierungen](/use-cases/automation-alerts).

## Genehmigen oder ablehnen vom Sperrbildschirm

Manche Workflows sollten nicht ohne einen Menschen abgeschlossen werden: eine Erstattung über einem Limit, ein Beitrag, der rausgeht, ein KI-Agent, der die Produktion anfassen will. Die `http`-[Aktionsbuttons](/features/action-buttons) von Pocket Alert senden einen Request direkt vom Handy, und der **Wait**-Node von n8n kann pausieren, bis ein Request eintrifft. Zusammen ergibt das:

1. Ein Trigger mit dem Request, hier ein **Webhook**-Node, der `{"order":"A-1042","amount":129}` empfängt.
2. Ein **HTTP Request**-Node, der die Push-Benachrichtigung mit zwei Buttons sendet.
3. Ein **Wait**-Node: **Resume** auf **On Webhook Call**, **HTTP Method** `POST`, **Limit Wait Time** aktiviert, 2 Stunden.
4. Ein **If**-Node: `{{ $json.body.decision }}` ist gleich `approve`.

Der Body des HTTP-Request-Nodes:

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

Der `http` eines `value`-Buttons ist selbst ein JSON-String, weshalb ein `JSON.stringify` in einem `JSON.stringify` steht. `$execution.resumeUrl` ist die Adresse, auf der der Wait-Node genau für diese eine Ausführung lauscht.

Im Test ergab ein POST an die URL des Genehmigen-Buttons mit seinem Body `200`, der Workflow wurde fortgesetzt, und `$json.body.decision` war `approve`, sodass der If-Node den Zweig „true“ nahm. Ablehnen ging in den Zweig „false“. Die Details, für die es ein paar Versuche brauchte:

- **Sende die Entscheidung im Body, nicht in der URL.** In n8n 2.45.7 endet die Resume-URL bereits auf `?signature=...`. Ein angehängtes `?decision=approve` zerstört die Signatur, und n8n antwortet mit `401`. Ein JSON-Body vermeidet Stringmanipulation.
- **Der zweite Tipp wird abgelehnt.** Sobald die Ausführung fortgesetzt wurde, bekommt ein weiterer Tipp `409` „has finished already“, und die App zeigt ihre Benachrichtigung über den fehlgeschlagenen Request mit einem Button Retry. Zählt ist der erste Tipp.
- **Keine Antwort heißt nein.** Wenn das 2-Stunden-Limit abläuft, setzt der Wait-Node ohne `decision` fort, daher geht der If-Node in den Zweig „false“. Mach diesen Zweig zum sicheren.
- **Das Handy muss n8n erreichen.** Der Request kommt vom Handy, nicht von Pocket Alert. `$execution.resumeUrl` wird aus deiner Webhook-URL gebaut (`WEBHOOK_URL`, das n8n 2.45 dazu auffordert, in `N8N_WEBHOOK_URL` umzubenennen). In n8n Cloud oder hinter einer öffentlichen Domain funktioniert das einfach. Auf einem Heimserver funktioniert es, solange das Handy im selben Netzwerk ist oder über ein VPN wie Tailscale verbunden ist.
- **Buttons sind eine kostenpflichtige Funktion.** Im kostenlosen Tarif kommt die Push-Benachrichtigung trotzdem an, aber ohne Buttons. Systembenachrichtigungs-Buttons brauchen die Pocket Alert-App ab Version 2.0.1.

Dasselbe Muster für KI-Agenten findest du unter [Benachrichtigungen mit Mensch im Loop](/blog/human-in-the-loop-notifications).

## Oder POST an einen Pocket Alert-Webhook

Wenn du keinen API-Schlüssel in n8n speichern willst, erstelle einen Webhook unter [Webhooks](/webhooks) in der Konsole und lass den HTTP-Request-Node JSON an dessen URL `https://p4a.me/wh/...` senden, ohne Authentifizierung. Eine Vorlage am Webhook macht aus der Payload die Nachricht. Der Kompromiss: Der Titel lautet immer `Webhook <name>`, und der Text kommt aus der Vorlage statt aus dem Workflow. Der Webhook-Verlauf protokolliert jeden empfangenen Request, was beim Debuggen hilft.

## Limits und Fehlersuche

- **Tageskontingent.** Der kostenlose Tarif erlaubt 50 Nachrichten pro Tag, Reset um 00:00 UTC. Eine Schleife über 200 Elemente sendet 200 Pushes. Nach dem Limit antwortet die API mit `429`; lass n8n das nicht wiederholen, die Antwort ändert sich erst beim Reset. Siehe [Tageslimits](https://info.pocketalert.app/features/daily-limits.html).
- **`401`** bedeutet, dass der Schlüssel falsch ist oder der Headername im Credential nicht `Token` lautet.
- **`400`** bedeutet, dass im Body `title` oder `message` fehlt (ein Ausdruck, der leer herauskommt, zählt dazu), eine unbekannte Stufe angegeben ist oder ein Button ungültig ist: mehr als 3, eine `view`-URL, die nicht `http(s)` ist, oder ein `http`-Wert, der kein JSON-String mit einer `url` ist.
- **„not valid JSON“ in n8n** bedeutet, dass ein Wert den JSON-Body zerstört hat. Wechsle zu `JSON.stringify` wie in Schritt 2.
- **Nichts bei einem Fehler.** Prüfe, ob Error alert und Send push beide veröffentlicht sind und ob der fehlschlagende Workflow in seinen Einstellungen Error alert gesetzt hat. Manuelle Testläufe aus dem Editor lösen den Error-Workflow nicht aus.

## FAQ

### Gibt es einen Pocket Alert-Node für n8n?

Derzeit nicht. Der HTTP-Request-Node deckt die gesamte API ab, und der Sub-Workflow Send push gibt dir einen node-artigen Baustein, den du einmal einrichtest. Wenn du Make nutzt, gibt es eine offizielle [Make-App](/blog/make-com-integration).

### Funktioniert das auch auf n8n Cloud?

Ja. Alles hier nutzt eingebaute Nodes. In der Cloud sind die Ausführungs- und Resume-URLs bereits öffentlich, was dir die URL-Konfiguration erspart, die eine selbst gehostete Instanz braucht.

### Kann ich nur an ein bestimmtes Handy senden?

Füge `device_id` mit der ID des Geräts zum Body hinzu. Ohne sie geht die Push-Benachrichtigung an alle deine Geräte. Mit `application_id` ordnest du die Nachricht einer Anwendung zu, sodass n8n-Benachrichtigungen einen eigenen Kanal in der App bekommen.

[Erstelle ein kostenloses Konto](/signup), importiere den Workflow Send push und richte deinen Error-Workflow darauf aus. Der nächste fehlgeschlagene Lauf erscheint dann auf deinem Handy, statt nur in der Ausführungsliste.
