---
title: "n8n"
description: "QuickTribe-Benachrichtigungen in n8n empfangen: Webhook-Trigger mit Raw Body, Testnachricht, Signatur im Code-Node oder mit dem Crypto-Node prüfen, veröffentlichen und weiterverarbeiten"
---

Mit [n8n](https://n8n.io) verarbeitest du Nachrichten des [allgemeinen Webhooks](/handbuch/owner/integrationen/webhook) weiter – etwa um neue Mitglieder in eine Tabelle zu schreiben oder dem Team eine E-Mail zu schicken. Die Anleitung gilt für n8n 2.x (n8n Cloud und selbst gehostet); Unterschiede zu 1.x sind vermerkt.

## 1. Webhook-Trigger anlegen

1. Lege einen neuen Workflow an und füge als Trigger **Webhook** („On webhook call“) hinzu.
2. Stelle ein:
   - **HTTP Method**: `POST`
   - **Path**: z. B. `quicktribe` (oder die vorgeschlagene zufällige ID)
   - **Authentication**: `None` – die Echtheit prüft die Signatur (siehe unten)
   - **Respond**: `Immediately` – QuickTribe bekommt sofort eine Antwort
3. Unter **Options → Add Option** wähle **Raw Body** und schalte es ein. Nur dann stehen die unveränderten Bytes für die Signaturprüfung zur Verfügung (als Binärdaten `data`, zusätzlich zu `body`, `headers` usw.).
4. Oben im Node gibt es **Test URL** und **Production URL**. In QuickTribe gehört die **Production URL** (`https://<dein-n8n>/webhook/<path>`).

## 2. Kanal in QuickTribe anlegen

1. **Einstellungen → Integrationen** → **Kanal hinzufügen** → **Webhook (JSON)**.
2. Trage die Production URL ein, wähle die Ereignisse und **Speichern**.
3. Kopiere den angezeigten **Signaturschlüssel**.

Liegt n8n in eurem internen Netz, muss der Betreiber der QuickTribe-Installation den Host über `APP_INTEGRATION_ALLOWED_HOSTS` freigeben (siehe [Konfiguration](/konfiguration#integrationen)).

## 3. Testnachricht empfangen

Zum Entwerfen des Workflows kannst du vorübergehend die **Test URL** (`/webhook-test/…`) als Adresse in QuickTribe eintragen: Klicke in n8n auf **Listen for test event** und innerhalb von 120 Sekunden in QuickTribe auf **Testnachricht senden**. Die Daten erscheinen dann im Editor. Trage danach wieder die Production URL ein.

<Note>
Die Test URL lauscht nur kurz nach „Listen for test event“. Steht sie dauerhaft in QuickTribe, antwortet n8n mit 404 – QuickTribe pausiert den Kanal dann.
</Note>

## 4. Signatur prüfen

### Variante A: Code-Node mit `crypto`

Füge direkt hinter dem Webhook einen **Code**-Node hinzu (**Mode**: Run Once for All Items, **Language**: JavaScript):

```js
// QuickTribe-Signatur prüfen. Voraussetzung: Webhook-Node mit Option "Raw Body" = an.
const crypto = require('crypto');

const SECRET = 'HIER_DEN_SIGNATURSCHLUESSEL_AUS_QUICKTRIBE'; // siehe "Schlüssel ablegen"
const TOLERANCE_SECONDS = 300;

const item = $input.first();
const headers = item.json.headers ?? {};
const header = String(headers['x-quicktribe-signature'] ?? '');

const parts = {};
for (const piece of header.split(',')) {
  const i = piece.indexOf('=');
  if (i > 0) parts[piece.slice(0, i).trim()] = piece.slice(i + 1).trim();
}
const t = parts.t ?? '';
const v1 = (parts.v1 ?? '').toLowerCase();
if (!/^\d+$/.test(t) || !/^[0-9a-f]{64}$/.test(v1)) {
  throw new Error('QuickTribe-Signatur fehlt oder hat ein falsches Format');
}
if (Math.abs(Math.floor(Date.now() / 1000) - Number(t)) > TOLERANCE_SECONDS) {
  throw new Error('QuickTribe-Signatur abgelaufen (älter als 5 Minuten)');
}

// Originalbytes des Bodys – nie JSON.stringify($json.body) verwenden
const rawBody = await this.helpers.getBinaryDataBuffer(0, 'data');
const expected = crypto.createHmac('sha256', SECRET).update(t + '.').update(rawBody).digest();
const given = Buffer.from(v1, 'hex');
if (given.length !== expected.length || !crypto.timingSafeEqual(given, expected)) {
  throw new Error('QuickTribe-Signatur ungültig');
}

return [{ json: { ...item.json.body, deliveryId: headers['x-quicktribe-delivery'] ?? null } }];
```

Header-Namen sind in n8n kleingeschrieben. Ist die Signatur ungültig, bricht die Ausführung ab und erscheint unter **Executions** als Fehler (QuickTribe hat wegen „Respond: Immediately“ trotzdem schon eine Antwort bekommen).

**`crypto` freigeben:** In n8n Cloud ist `crypto` im Code-Node verfügbar. Selbst gehostet sind Modulimporte standardmäßig gesperrt: Im internen Runner-Modus setzt der n8n-Betreiber `NODE_FUNCTION_ALLOW_BUILTIN=crypto` und startet n8n neu; mit externen Task-Runnern (`n8nio/runners`) gehört die Freigabe laut n8n-Dokumentation in die Datei `/etc/n8n-task-runners.json` (`env-override`). Kannst du das nicht setzen, nimm Variante B.

### Variante B: ohne Modulfreigabe (Code → Crypto → Code)

1. **Code**-Node, bereitet die Prüfung vor:

   ```js
   const item = $input.first();
   const h = item.json.headers ?? {};
   const m = String(h['x-quicktribe-signature'] ?? '').match(/^t=(\d+),v1=([0-9a-fA-F]{64})$/);
   if (!m) throw new Error('QuickTribe-Signatur fehlt oder hat ein falsches Format');
   const [, t, v1] = m;
   if (Math.abs(Math.floor(Date.now() / 1000) - Number(t)) > 300) throw new Error('Zeitstempel außerhalb der Toleranz');
   const raw = (await this.helpers.getBinaryDataBuffer(0, 'data')).toString('utf8');
   return [{ json: { signedPayload: `${t}.${raw}`, v1: v1.toLowerCase(), body: item.json.body, deliveryId: h['x-quicktribe-delivery'] ?? null } }];
   ```

2. **Crypto**-Node: **Action** `Hmac`, **Type** `SHA256`, **Value** `{{ $json.signedPayload }}`, **Property Name** `expected`, **Encoding** `HEX`. Den Signaturschlüssel trägst du in der Credential **Crypto** im Feld **Hmac Secret** ein (in älteren n8n-Versionen steht das Feld direkt im Node).
3. **Code**-Node, vergleicht ohne Zeitunterschiede:

   ```js
   const { expected, v1, body, deliveryId } = $input.first().json;
   let diff = expected.length ^ v1.length;
   for (let i = 0; i < Math.min(expected.length, v1.length); i++) diff |= expected.charCodeAt(i) ^ v1.charCodeAt(i);
   if (diff !== 0) throw new Error('QuickTribe-Signatur ungültig');
   return [{ json: { ...body, deliveryId } }];
   ```

### Schlüssel ablegen

Seit n8n 2.0 ist der Zugriff auf Umgebungsvariablen im Code-Node standardmäßig gesperrt (`$env` funktioniert dann nicht). Steht der Schlüssel direkt im Code, sehen ihn alle, die den Workflow bearbeiten dürfen. Sicherer ist Variante B mit der **Crypto**-Credential.

## 5. Veröffentlichen

Klicke oben rechts auf **Publish** (n8n 1.x: Schalter **Active**). Erst dann ist die Production URL registriert; ohne Veröffentlichung antwortet sie mit 404 und QuickTribe pausiert den Kanal. Ausführungen über die Production URL siehst du unter **Executions**.

## Beispiel: neue Mitglieder in eine Tabelle

1. Hinter der Signaturprüfung ein **Switch** auf `{{ $json.event }}`, Regel *is equal to* `member.joined`.
2. Im Zweig `member.joined`: **Google Sheets** → **Append Row** mit den Spalten `{{ $json.occurredAt }}`, `{{ $json.community.name }}`, `{{ $json.text }}` und `{{ $json.data.userId }}`.
3. Andere Ereignisse, z. B. `member.join_requested`: **Send Email** mit Betreff `{{ $json.title }}`, Text `{{ $json.text }}` und Link `{{ $json.link.url }}`.

Speichere die `deliveryId` mit und prüfe vor dem Anhängen auf Dubletten – QuickTribe wiederholt eine Nachricht, wenn n8n nicht rechtzeitig antwortet.

## Stolpersteine

- Ohne **Raw Body** gibt es keine Originalbytes; ein `JSON.stringify($json.body)` weicht ab und die Signatur schlägt fehl.
- Hinter einem Reverse Proxy muss n8n `WEBHOOK_URL` kennen, sonst zeigt es falsche Adressen an.
