Webhook-Automationen

Basic-Plan und höher

Webhooks erfordern einen kostenpflichtigen Plan. Basic: 1 Webhook, Pro: 3, Ultra: 10.

Webhooks lassen dich TellDone mit jedem externen Dienst verbinden. Wenn du eine Sprachnotiz aufnimmst, verarbeitet TellDone sie und sendet die extrahierten Daten - Notizen, Aufgaben, Termine und Berichte - automatisch an eine URL deiner Wahl. Jede Aufgabe und jeder Termin geht als separate Zustellung raus, damit dein Automation-Tool sie einzeln behandeln kann.

Auswählen, was gesendet wird

Jede Automation hat eigene Payload-Schalter. Wähle einen oder eine beliebige Kombination:

• Notizen - die vollständige verarbeitete Notiz (Titel, Transkript, Zusammenfassung, Tags, Sprache)
• Audio - im Ultra-Plan kannst du einen 24-Stunden-Download-Link zur Audio-Datei zusätzlich zur Notiz-Payload anhängen
• Aufgaben - eine Zustellung pro extrahierter Aufgabe
• Termine - eine Zustellung pro extrahiertem Kalendertermin
• Berichte - eine Zustellung pro generiertem Tages-, Wochen-, Monats- oder Jahresbericht

Du kannst die Schalter jederzeit aus den Automation-Einstellungen ändern - Änderungen wirken sich nur auf neue Ereignisse aus.

Webhook einrichten

1. Geh zu Einstellungen > Integrationen > Webhook-Automationen
2. Tippe auf Neue Automation

3. Gib einen Namen ein (z. B. "Mein Zapier-Webhook")
4. Füg die Webhook-URL aus deinem Automation-Dienst ein
5. Wähle, welche Daten gesendet werden: Notizen, Aufgaben, Termine, Berichte (oder eine Kombination)
6. Optional einen Auth-Header hinzufügen - ein Token, der für sichere Endpunkte als Authorization-Header gesendet wird
7. Tippe auf Speichern
8. Kopiere das Signing-Secret - es wird in voller Länge nur beim ersten Erstellen der Automation oder nach einer Rotation angezeigt. Du brauchst es, um die Webhook-Authentizität zu prüfen
9. Tippe auf "Test", um eine Beispiel-Payload an deinen Endpunkt zu schicken, ohne ein echtes Ereignis zu erzeugen

Tipp

Die Webhook-URL muss HTTPS nutzen. HTTP-Adressen und private Netzwerk-IPs werden nicht akzeptiert.

Was gesendet wird

Jede Zustellung ist ein JSON-Objekt mit drei Feldern: event (der Ereignistyp), timestamp und data (der eigentliche Inhalt). So sieht jeder Ereignistyp aus.

Notizen (note.created)

Enthält den KI-generierten Titel, das vollständige Transkript, die Zusammenfassung, den Notiztyp, Tags, Priorität, Sprache und Erstellungsdatum.

{
  "event": "note.created",
  "timestamp": "2026-02-27T14:38:00Z",
  "data": {
    "note_id": "550e8400-e29b-41d4-a716-446655440000",
    "title": "Meeting notes - Project Alpha",
    "transcript": "Full transcript text...",
    "summary": "Brief AI-generated summary...",
    "type": "meeting",
    "tags": ["work", "project-alpha"],
    "priority": "high",
    "language": "en",
    "created_at": "2026-02-27T10:00:00Z"
  }
}

Im Ultra-Plan können Notiz-Zustellungen außerdem einen Link zur Audioaufnahme enthalten (audio_url, audio_format, duration_seconds). Der Link läuft nach 24 Stunden ab. Aktiviere das mit der Option "Note + Audio" beim Erstellen der Automation.

Aufgaben (task.created)

Eine Zustellung pro Aufgabe. Eine einzelne Notiz mit 3 Aufgaben sendet 3 separate Webhooks.

{
  "event": "task.created",
  "timestamp": "2026-02-27T14:38:01Z",
  "data": {
    "note_id": "550e8400-...",
    "note_title": "Meeting notes - Project Alpha",
    "task_id": "660f9511-...",
    "title": "Send proposal to client",
    "description": "Include pricing for Q2",
    "priority": "high",
    "due_date": "2026-03-01",
    "reminder_at": "2026-02-28T09:00:00Z",
    "tags": ["work"],
    "status": "todo",
    "created_at": "2026-02-27T10:00:00Z"
  }
}

Termine (calendar_event.created)

Eine Zustellung pro Kalendertermin.

{
  "event": "calendar_event.created",
  "timestamp": "2026-02-27T14:38:02Z",
  "data": {
    "note_id": "550e8400-...",
    "note_title": "Meeting notes",
    "event_id": "770a0622-...",
    "title": "Team standup",
    "description": "Weekly sync",
    "start": "2026-03-03T10:00:00+03:00",
    "end": "2026-03-03T10:30:00+03:00",
    "location": "Zoom",
    "is_all_day": false,
    "attendees": ["alice@example.com"],
    "tags": ["work"],
    "created_at": "2026-02-27T10:00:00Z"
  }
}

Berichte (report.created)

Wird gesendet, wenn ein Tages-, Wochen-, Monats- oder Jahresbericht generiert wird.

{
  "event": "report.created",
  "timestamp": "2026-02-28T00:05:00Z",
  "data": {
    "report_id": "880b1733-...",
    "report_type": "daily",
    "period_start": "2026-02-27",
    "period_end": "2026-02-27",
    "content_md": "# Daily Report\n\n...",
    "content_json": {
      "productivity_score": 72,
      "day_type": "productive",
      "tasks_created": 5,
      "tasks_completed": 3
    },
    "created_at": "2026-02-28T00:05:00Z"
  }
}

Sicherheit

Jede Zustellung wird mit HMAC-SHA256 und dem Signing-Secret deiner Automation signiert. Folgende Header sind in jeder Zustellung enthalten:

• X-LP-Signature - die HMAC-SHA256-Signatur (sha256=...)
• X-LP-Timestamp - Unix-Zeitstempel, der für die Signatur verwendet wurde
• X-LP-Event - der Ereignistyp (note.created, task.created, calendar_event.created, report.created)
• X-LP-Delivery-Id - eindeutige Zustell-ID (nützlich für Deduplizierung)
• User-Agent - immer TellDone-Webhooks/1.0

Die Signatur-Header werden bei jeder Zustellung gesendet, unabhängig von anderen Einstellungen.

Standardmäßig enthält jede Zustellung das Signing-Secret deiner Automation im Authorization-Header - Tools wie n8n Header Auth funktionieren damit direkt, indem du das Secret als Auth-Wert einfügst. Wenn du in den Einstellungen einen benutzerdefinierten Auth-Header setzt, ersetzt er diesen Standard. Du kannst zwei Formate nutzen: Header-Name: Wert (sendet den genannten Header) oder einen einfachen Wert (sendet ihn als Authorization: <Wert>).

Jede Automation hat ihr eigenes Signing-Secret, sodass das Rotieren von einem deine anderen Webhooks nicht beeinflusst. Das Secret wird in voller Länge nur beim ersten Erstellen der Automation oder nach einer Rotation angezeigt. Zu allen anderen Zeiten wird nur eine Vorschau (whsec_...letzte4) angezeigt. Um es gegen ein neues zu tauschen, tippe in den Automation-Einstellungen auf "Secret rotieren" - das erzeugt einen neuen HMAC-Schlüssel, ohne URL oder Auth-Header zu ändern. Das alte Secret wird sofort ungültig.

Es werden nur HTTPS-URLs akzeptiert. HTTP, IP-Adressen und private Netzwerkadressen werden abgelehnt.

Webhook-Signaturen verifizieren

HMAC verifizieren

Jede Zustellung enthält einen Signatur-Header in der Form X-LP-Signature: sha256=<hex>. Das Beispiel unten zeigt, wie man ihn in Python verifiziert.

Jeder Webhook ist signiert, sodass du bestätigen kannst, dass er wirklich von TellDone kommt. Die Signatur wird so berechnet:

HMAC-SHA256(signing_secret, timestamp + "." + raw_body)

Das Ergebnis ist hex-kodiert und im Signatur-Header mit sha256= präfixiert.

Nutze den rohen Request-Body

TellDone serialisiert JSON mit Leerzeichen nach den Trennern (z. B. {"event": "note.created"}). Wenn du den Body parst und neu serialisierst, passt die Signatur nicht. Verifiziere immer gegen die rohen Bytes des Request-Bodys.

Python

import hmac
import hashlib

def verify_signature(raw_body: bytes, signature: str, timestamp: str, secret: str) -> bool:
    payload = f"{timestamp}.".encode() + raw_body
    expected = "sha256=" + hmac.new(
        secret.encode(), payload, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature, expected)

# Flask example
@app.route("/webhook/telldone", methods=["POST"])
def telldone_webhook():
    raw_body = request.get_data()  # raw bytes, NOT request.json
    signature = request.headers.get("X-LP-Signature", "")
    timestamp = request.headers.get("X-LP-Timestamp", "")

    if not verify_signature(raw_body, signature, timestamp, SIGNING_SECRET):
        abort(403)

    data = request.json
    # process webhook...

Node.js

const crypto = require("crypto");

function verifySignature(rawBody, signature, timestamp, secret) {
  const payload = `${timestamp}.${rawBody}`;
  const expected =
    "sha256=" +
    crypto.createHmac("sha256", secret).update(payload).digest("hex");
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

// Express example (use express.raw to get the raw body)
app.post("/webhook/telldone", express.raw({ type: "application/json" }), (req, res) => {
  const rawBody = req.body.toString();
  const signature = req.headers["x-lp-signature"] || "";
  const timestamp = req.headers["x-lp-timestamp"] || "";

  if (!verifySignature(rawBody, signature, timestamp, SIGNING_SECRET)) {
    return res.status(403).send("Invalid signature");
  }

  const data = JSON.parse(rawBody);
  // process webhook...
});

Replay-Schutz (optional)

Um Replay-Angriffe zu verhindern, prüfe, ob der Zeitstempel aktuell ist:

import time

def verify_timestamp(timestamp: str, tolerance_seconds: int = 300) -> bool:
    try:
        return abs(time.time() - int(timestamp)) < tolerance_seconds
    except (ValueError, TypeError):
        return False

Häufige Fehler

Fehler	Lösung
Geparsten und neu serialisierten Body verwendet	Nutze den rohen Request-Body
JSON.stringify() in JS (kompakt, ohne Leerzeichen)	Nutze den rohen Body oder pass dich an Pythons Spacing an
Zeitstempel-Präfix vergessen	Payload-Format ist timestamp + "." + body
Strings direkt verglichen	Nutz hmac.compare_digest oder timingSafeEqual

Retry-Strategie

Wenn dein Endpunkt fehlschlägt, versucht TellDone jede Zustellung mit Exponential Backoff erneut (ein paar Minuten, dann längere Abstände):

Versuch	Wartezeit
1. Retry	30 Sekunden
2. Retry	2 Minuten
3. Retry	15 Minuten
4. Retry	1 Stunde
5. Retry	4 Stunden

Nach 5 fehlgeschlagenen Versuchen wird die Zustellung als dead markiert. Du kannst sie weiterhin manuell aus dem Zustell-Log erneut versuchen.

So behandelt TellDone verschiedene Antworten:

• 2xx - erfolgreich zugestellt
• 4xx (außer 429) - sofort als dead markiert, kein Retry (dein Endpunkt hat die Daten ausdrücklich abgelehnt)
• 429 (Too Many Requests) - wird wiederholt, beachtet den Retry-After-Header
• 5xx oder Timeout - wird mit dem oben genannten Plan wiederholt

Wenn Zustellungen wiederholt fehlschlagen

Du musst das Zustell-Log nicht im Auge behalten, um zu wissen, dass etwas kaputt ist. TellDone beobachtet aufeinanderfolgende Fehler für dich und meldet sich in zwei Stufen.

Nach 3 Fehlern: Posteingang-Warnung

Nach 3 hintereinander fehlgeschlagenen Zustellungen legt TellDone in deinem Posteingang eine Nachricht in der Kategorie "Webhook-Fehler" an. Die Nachricht nennt die betroffene Automation und verlinkt direkt zu Einstellungen > Integrationen > Automationen > [die fehlerhafte Automation] > Zustell-Log, damit du die Antwort prüfen und entscheiden kannst.

Tipp

Posteingang-Warnungen sorgen dafür, dass du von kaputten Automationen über das App-Icon-Badge erfährst, statt sie Wochen später durch fehlende Daten in deinem Folge-Tool zu entdecken.

Nach 20 Fehlern: Auto-Deaktivierung

Auto-Deaktivierung

Schlagen 20 aufeinanderfolgende Zustellungen für dieselbe Automation fehl (gezählt nach der Posteingang-Warnung), schaltet TellDone die Automation automatisch ab, damit ein kaputter Endpunkt nicht weiter angesprochen wird und dein Monatskontingent geschützt bleibt. Behebe das Problem am Ziel und aktiviere die Automation dann wieder unter Einstellungen > Integrationen > Automationen.

Der Zähler aufeinanderfolgender Fehler wird bei der nächsten erfolgreichen Zustellung auf null zurückgesetzt.

Webhooks verwalten

• Pause/Fortsetzen - jede Automation deaktivieren, ohne sie zu löschen, jederzeit wieder aktivieren
• Zustell-Log - alle Zustellungen mit Status, HTTP-Code und Antwortzeit anzeigen. Filter nach Zugestellt oder Fehlern. Tippe eine fehlgeschlagene Zustellung an und wähle "Erneut versuchen", um sie ohne Warten auf den nächsten geplanten Retry erneut zu schicken
• Test - tippe "Test", um eine Beispiel-Payload (mit "test": true im Body) an deinen Endpunkt zu schicken, ohne ein echtes Ereignis zu erzeugen. Test-Sendungen zählen nicht zum Monatskontingent
• Secret rotieren - frisches HMAC-Signing-Secret generieren, ohne URL oder Auth-Header zu ändern
• Bearbeiten - URL, Auth-Header oder Payload-Schalter (Notizen / Audio / Aufgaben / Termine / Berichte) aktualisieren. Änderungen sind sofort wirksam
• Löschen - entfernt die Automation und alle ihre Zustell-Logs dauerhaft

Zustell-Limits

Die Webhook-Zustellung hat zwei Limits: ein Monatskontingent (hartes Limit, je nach Plan unterschiedlich) und ein stündliches Anti-Burst-Limit (weiches Limit, identisch in allen bezahlten Plänen).

Plan	Webhooks	Zustellungen/Monat	Burst pro Stunde
Free	0	0	-
Basic	1	300	100
Pro	3	3.000	100
Ultra	10	15.000	100

Der Ultra-Plan unterstützt zusätzlich Audio-Links in Notiz-Payloads (24 Stunden gültig).

So verhalten sich die Limits:

• Monatslimit überschritten: Die Zustellung wird als fehlgeschlagen markiert, ohne erneuten Versuch. Neue Zustellungen laufen am 1. des Folgemonats wieder an, sobald der Zähler zurückgesetzt wird.
• Stundenlimit überschritten: Die Zustellung wird zurückgestellt und nach etwa 5 Minuten erneut versucht, so geht bei einem kurzen Burst nichts verloren. Das ist eine weiche Anti-Burst-Sicherung, keine endgültige Ablehnung.

Test-Sendungen und manuelle Neu-Zustellungen aus dem Zustell-Log zählen für keines der beiden Limits.

Test-Ereignisse filtern

Wenn du auf "Test" tippst, enthält die Payload "test": true auf oberster Ebene. In deinem Automation-Tool kannst du auf dieses Feld prüfen und die Verarbeitung überspringen, wenn es vorhanden ist.

Plattform-Anleitungen

Schritt-für-Schritt-Anleitungen für dein Automation-Tool:

• Zapier - TellDone mit tausenden Apps via Zaps verbinden
• Make - visuelle Automations-Szenarien bauen (früher Integromat)
• n8n - TellDone-Webhooks in selbst-gehosteten oder Cloud-Workflows nutzen
• Eigene Endpunkte - jeder Dienst, der HTTPS-POST-Anfragen akzeptiert, funktioniert mit TellDone-Webhooks

Beliebte Anwendungsfälle

• Aufgaben über Zapier in ein Google Sheet senden
• Slack-Nachrichten aus Notizen über Make erstellen
• Termine über n8n in ein eigenes CRM loggen
• Alle Notizen in einen Cloud-Speicher sichern
• Berichte an ein Team-Dashboard weiterleiten

Siehe auch

• Posteingang und Support - bei wiederholten Webhook-Fehlern siehst du eine Nachricht in deinem Posteingang
• Zapier - Schritt-für-Schritt-Setup für Zapier
• Make - Schritt-für-Schritt-Setup für Make
• n8n - Schritt-für-Schritt-Setup für n8n
• Todoist - dedizierter Zwei-Wege-Aufgaben-Sync (keine Webhooks nötig)
• Notion - dedizierte Notion-Integration
• E-Mail-Weiterleitung - Notizdaten per E-Mail erhalten