---
title: "Zapier"
description: "QuickTribe-Benachrichtigungen in Zapier empfangen: Webhooks by Zapier mit Catch Raw Hook, Testnachricht, Signatur mit Code by Zapier prüfen (JavaScript oder Python), filtern und weiterverarbeiten"
---

In [Zapier](https://zapier.com) empfängst du Nachrichten des [allgemeinen Webhooks](/handbuch/owner/integrationen/webhook) mit **Webhooks by Zapier**. Laut Zapier ist das eine Premium-App und steht erst ab einem bezahlten Tarif (z. B. Professional) zur Verfügung; auch Zaps mit mehreren Schritten brauchen einen bezahlten Tarif.

## 1. Trigger anlegen

1. Klicke **Create → Zaps** und wähle beim **Trigger** die App **Webhooks by Zapier**.
2. **Trigger event**: **Catch Raw Hook** → **Continue**. Nur **Catch Raw Hook** liefert den unveränderten Body und die Header – mit **Catch Hook** ist keine Signaturprüfung möglich.
3. Im Reiter **Test** zeigt Zapier die Webhook-Adresse (`https://hooks.zapier.com/hooks/catch/…/…/`). Kopiere sie mit **Copy**.

## 2. Kanal in QuickTribe anlegen und testen

1. **Einstellungen → Integrationen** → **Kanal hinzufügen** → **Webhook (JSON)**, Adresse eintragen, Ereignisse wählen, **Speichern** und den **Signaturschlüssel** kopieren.
2. Klicke in QuickTribe auf **Testnachricht senden** und danach in Zapier auf **Test trigger**. Es erscheinen Felder wie **Raw Body** und die Header, voraussichtlich als **Headers Http X Quicktribe Signature**, **Headers Http X Quicktribe Event** und **Headers Http X Quicktribe Delivery** – die genauen Namen siehst du nach dem Test.

## 3. Signatur prüfen mit Code by Zapier

Füge einen Schritt **Code by Zapier** hinzu, **Event**: **Run JavaScript** oder **Run Python**. Unter **Input Data** ordnest du zu: `raw` = *Raw Body*, `signature` = *Headers Http X Quicktribe Signature*, `delivery` = *Headers Http X Quicktribe Delivery*. Dann den Code einfügen und mit **Test step** prüfen.

<CodeGroup>

```js JavaScript
const crypto = require('crypto');

const SECRET = 'HIER_DEN_SIGNATURSCHLUESSEL_AUS_QUICKTRIBE';
const TOLERANCE_SECONDS = 300;

const raw = inputData.raw || '';
const header = inputData.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();

let valid = false;
let reason = 'ok';
if (!/^\d+$/.test(t) || !/^[0-9a-f]{64}$/.test(v1)) {
  reason = 'Signatur fehlt oder falsches Format';
} else if (Math.abs(Math.floor(Date.now() / 1000) - Number(t)) > TOLERANCE_SECONDS) {
  reason = 'Zeitstempel außerhalb der Toleranz';
} else {
  const expected = crypto.createHmac('sha256', SECRET).update(`${t}.${raw}`, 'utf8').digest();
  const given = Buffer.from(v1, 'hex');
  valid = given.length === expected.length && crypto.timingSafeEqual(given, expected);
  if (!valid) reason = 'Signatur ungültig';
}

let body = {};
if (valid) {
  try { body = JSON.parse(raw); } catch (e) { valid = false; reason = 'Body ist kein JSON'; }
}

return {
  valid,
  reason,
  deliveryId: inputData.delivery || '',
  event: body.event || '',
  occurredAt: body.occurredAt || '',
  communityName: (body.community && body.community.name) || '',
  title: body.title || '',
  text: body.text || '',
  linkUrl: (body.link && body.link.url) || '',
  fieldsText: Array.isArray(body.fields) ? body.fields.map(f => `${f.label}: ${f.value}`).join('\n') : '',
};
```

```python Python
import hmac, hashlib, json, re, time

SECRET = b'HIER_DEN_SIGNATURSCHLUESSEL_AUS_QUICKTRIBE'
TOLERANCE_SECONDS = 300

raw = input_data.get('raw', '') or ''
header = input_data.get('signature', '') or ''
parts = {}
for piece in header.split(','):
    if '=' in piece:
        k, v = piece.split('=', 1)
        parts[k.strip()] = v.strip()
t = parts.get('t', '')
v1 = parts.get('v1', '').lower()

valid, reason = False, 'ok'
if not re.fullmatch(r'\d+', t) or not re.fullmatch(r'[0-9a-f]{64}', v1):
    reason = 'Signatur fehlt oder falsches Format'
elif abs(int(time.time()) - int(t)) > TOLERANCE_SECONDS:
    reason = 'Zeitstempel außerhalb der Toleranz'
else:
    expected = hmac.new(SECRET, f'{t}.{raw}'.encode('utf-8'), hashlib.sha256).hexdigest()
    valid = hmac.compare_digest(expected, v1)
    if not valid:
        reason = 'Signatur ungültig'

body = {}
if valid:
    try:
        body = json.loads(raw)
    except ValueError:
        valid, reason = False, 'Body ist kein JSON'

output = {
    'valid': valid,
    'reason': reason,
    'deliveryId': input_data.get('delivery', ''),
    'event': body.get('event', ''),
    'title': body.get('title', ''),
    'text': body.get('text', ''),
    'linkUrl': (body.get('link') or {}).get('url', ''),
}
```

</CodeGroup>

Zapier nennt als Laufzeit Node.js mit Standardbibliothek bzw. Python mit Standardbibliothek; `crypto` bzw. `hmac` und `hashlib` gehören dazu. Der Schlüssel steht im Code und ist für alle sichtbar, die den Zap bearbeiten dürfen.

<Note>
Zapier sagt nicht ausdrücklich zu, dass **Raw Body** bytegenau im Code-Schritt ankommt. Schlägt die Prüfung trotz richtigem Schlüssel fehl, prüfe das zuerst mit einer Testnachricht.
</Note>

## 4. Filtern und weiterverarbeiten

1. Schritt **Filter by Zapier** → **Only continue if…** → Feld *valid* → **(Boolean) Is true**.
2. Danach die eigentlichen Aktionen mit den Feldern aus dem Code-Schritt, z. B. **Slack → Send Channel Message** oder **Google Sheets → Create Spreadsheet Row** mit `event`, `title`, `text` und `linkUrl`.
3. Den Zap veröffentlichen bzw. einschalten (je nach Editor **Publish** oder Schalter **On**).

## Gut zu wissen

- Zapier antwortet immer mit 200. Ist der Zap aus oder gelöscht, antwortet die Adresse mit **404** – das kann laut Zapier einige Stunden dauern. QuickTribe pausiert den Kanal dann; nach dem Einschalten in QuickTribe **Fortsetzen**.
- Catch Raw Hook nimmt Bodys bis 2 MB an; QuickTribe-Nachrichten sind höchstens 64 KB groß.
- Bei hoher Last kann Zapier mit 200 antworten und trotzdem erst Minuten später verarbeiten.
