Urlaubsantrags-Benachrichtigungen mit Collabin-Webhooks an Slack senden

Wenn jemand Urlaub beantragt, sollten die Personen, die es wissen müssen, davon dort erfahren, wo sie bereits arbeiten — in Slack. Diese Anleitung verbindet die Webhooks von Collabin end-to-end mit einem Slack-Kanal: Sie abonnieren Urlaubsereignisse, überprüfen jede Zustellung kryptografisch und senden eine formatierte Nachricht. Das gleiche Muster funktioniert auch für Microsoft Teams, Discord, n8n, Make oder jedes interne System.

Wie Collabin-Webhooks funktionieren

Ein Webhook ist ein von Ihnen gehosteter HTTPS-Endpunkt; Collabin ruft ihn mit einer POST-Anfrage auf, sobald ein abonniertes Ereignis eintritt. Zwei Ereignisse sind verfügbar:

Jede Zustellung ist ein JSON-Umschlag:

{
  "event": "leave.created",
  "timestamp": "2026-06-13T09:30:00Z",
  "delivery_id": "f3a91c0d2b8e4a17",
  "organization_id": 42,
  "data": {
    "id": 1337,
    "user_id": 7,
    "user": { "id": 7, "name": "Max Mustermann" },
    "leave_type_id": 1,
    "leave_type": { "id": 1, "name": "Urlaub" },
    "start_date": "2026-07-01T00:00:00Z",
    "end_date": "2026-07-05T00:00:00Z",
    "is_half_day": false,
    "status": "PENDING"
  }
}

Drei Header begleiten jede Anfrage:

• X-Collabin-Event — der Ereignisname, sodass Sie ohne Parsen des Bodys weiterleiten können.
• X-Collabin-Delivery — eine eindeutige Zustellungs-ID, praktisch für Deduplizierung und Log-Korrelation.
• X-Collabin-Signature — sha256=<hex>, ein HMAC-SHA256 des rohen Anfrage-Bodys, berechnet mit dem Secret Ihres Webhooks. Überprüfen Sie dies immer, bevor Sie der Payload vertrauen.

Collabin wartet bis zu 10 Sekunden und behandelt jede 2xx-Antwort als Erfolg — antworten Sie schnell und führen Sie aufwendige Arbeiten asynchron aus.

Was Sie benötigen

• Ein Collabin-Konto im Plan Pro (Webhook-Verwaltung erfordert diesen).
• Einen Slack-Workspace, in dem Sie einen Incoming Webhook erstellen können.
• Eine Umgebung für ~40 Zeilen Node.js: ein kleines VPS, Cloud Run, eine Serverless-Funktion — alles mit einer öffentlichen HTTPS-URL.

Schritt 1: Incoming Webhook in Slack erstellen

Erstellen Sie in Slack eine App (oder verwenden Sie eine vorhandene), aktivieren Sie Incoming Webhooks und fügen Sie einen für den Kanal hinzu, in dem die Benachrichtigungen erscheinen sollen. Slack stellt Ihnen eine URL wie https://hooks.slack.com/services/T000/B000/XXXX zur Verfügung. Behandeln Sie diese vertraulich.

Schritt 2: Die Brücke bereitstellen

Dieser kleine Express-Server überprüft die Signatur von Collabin und leitet eine lesbare Nachricht an Slack weiter:

const crypto = require('crypto');
const express = require('express');

const COLLABIN_SECRET = process.env.COLLABIN_WEBHOOK_SECRET;
const SLACK_URL = process.env.SLACK_WEBHOOK_URL;

const app = express();
// Rohen Body beibehalten — die Signatur wird über die exakten Bytes berechnet.
app.use(express.raw({ type: 'application/json' }));

app.post('/collabin-webhook', async (req, res) => {
  const expected = 'sha256=' + crypto
    .createHmac('sha256', COLLABIN_SECRET)
    .update(req.body)
    .digest('hex');

  const received = req.get('X-Collabin-Signature') || '';
  const valid = received.length === expected.length &&
    crypto.timingSafeEqual(Buffer.from(received), Buffer.from(expected));

  if (!valid) {
    return res.status(401).send('invalid signature');
  }

  // Sofort bestätigen; Collabin benötigt nur ein 2xx.
  res.status(200).send('ok');

  const payload = JSON.parse(req.body.toString('utf8'));
  const leave = payload.data;
  const who = leave.user ? leave.user.name : `Benutzer #${leave.user_id}`;
  const type = leave.leave_type ? leave.leave_type.name : 'Urlaub';
  const from = leave.start_date.slice(0, 10);
  const to = leave.end_date.slice(0, 10);

  const text = payload.event === 'leave.created'
    ? `:palm_tree: *${who}* hat *${type}* vom *${from}* bis *${to}* beantragt`
    : `:bell: Der ${type}-Antrag von *${who}* (${from} – ${to}) hat jetzt den Status *${leave.status}*`;

  await fetch(SLACK_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text })
  });
});

app.listen(process.env.PORT || 3000);

Zwei Details sind wichtiger, als sie aussehen:

1. Gegen den rohen Body verifizieren. Wenn Ihr Framework JSON zuerst parst und Sie es erneut serialisieren, brechen Änderungen der Schlüsselreihenfolge oder von Leerzeichen den HMAC. Lesen Sie die exakten Bytes.
2. Verwenden Sie einen zeitkonstanten Vergleich (crypto.timingSafeEqual), damit die Prüfung keine Timing-Informationen verrät.

Schritt 3: Webhook in Collabin registrieren

1. Öffnen Sie in Ihrem Collabin-Dashboard Webhooks.
2. Fügen Sie einen neuen Webhook hinzu: Fügen Sie die URL Ihres Endpunkts ein und wählen Sie die Ereignisse (leave.created, leave.status_changed oder beide).
3. Collabin weist dem Webhook ein Secret zu — kopieren Sie es in die Umgebungsvariable COLLABIN_WEBHOOK_SECRET Ihrer Brücke.

Reichen Sie einen Test-Urlaubsantrag ein, und die Nachricht sollte innerhalb von ein bis zwei Sekunden in Slack erscheinen.

Betriebshinweise

• Keine automatischen Wiederholungsversuche. Die Zustellung erfolgt nach dem Fire-and-Forget-Prinzip: Ist Ihr Endpunkt nicht erreichbar oder liefert einen Status außerhalb von 2xx, wird das Ereignis nicht erneut gesendet — der fehlgeschlagene Versuch wird jedoch im System-Fehlerprotokoll von Collabin aufgezeichnet, sodass Sie genau sehen können, was wann schiefgelaufen ist.
• Deaktivieren statt löschen beim Debuggen: Ein Webhook kann auf inaktiv gesetzt und später wieder aktiviert werden, ohne dass die Konfiguration erneut eingegeben werden muss.
• Ein Webhook pro Empfänger. Jeder Webhook hat sein eigenes Secret; geben Sie jedem nachgeschalteten System eine eigene Registrierung, statt einen Endpunkt zu teilen.

Mehr als nur Slack

Die obige Brücke ist bewusst minimal gehalten. Mit derselben verifizierten Payload können Sie Personen automatisch als abwesend markieren, mit einem internen HR-System synchronisieren oder ein No-Code-Tool versorgen — richten Sie einen n8n- oder Make-Webhook-Trigger auf Collabin und nutzen Sie einen Function-Schritt für die Signaturprüfung.