Automatisations webhook

Forfait Basic et au-dessus

Les webhooks nécessitent un forfait payant. Basic : 1 webhook, Pro : 3, Ultra : 10.

Les webhooks te permettent de connecter TellDone à n'importe quel service externe. Quand tu crées une note vocale, TellDone la traite et envoie automatiquement les données extraites - notes, tâches, événements et rapports - à une URL que tu spécifies. Chaque tâche et chaque événement est envoyé en livraison séparée, donc ton outil d'automatisation peut les traiter individuellement.

Choisir ce qu'il faut envoyer

Chaque automatisation a ses propres bascules de payload. Choisis une seule ou n'importe quelle combinaison :

• Notes - la note traitée complète (titre, transcription, résumé, tags, langue)
• Audio - sur le forfait Ultra, joins un lien de téléchargement de 24 heures vers le fichier audio à côté du payload de note
• Tâches - une livraison par tâche extraite
• Événements - une livraison par événement de calendrier extrait
• Rapports - une livraison par rapport quotidien, hebdomadaire, mensuel ou annuel généré

Tu peux changer les bascules à tout moment depuis les paramètres de l'automatisation - les modifications s'appliquent uniquement aux nouveaux événements.

Configurer un webhook

1. Va dans Paramètres > Intégrations > Automatisations webhook
2. Appuie sur Nouvelle automatisation

3. Saisis un nom (par exemple, « Mon webhook Zapier »)
4. Colle l'URL de webhook depuis ton service d'automatisation
5. Choisis quelles données envoyer : notes, tâches, événements, rapports (ou n'importe quelle combinaison)
6. Ajoute en option un en-tête d'auth - un token envoyé comme en-tête Authorization pour les endpoints sécurisés
7. Appuie sur Enregistrer
8. Copie le secret de signature - il est affiché en entier uniquement lors de la première création de l'automatisation ou après une rotation. Tu en auras besoin pour vérifier l'authenticité du webhook
9. Appuie sur « Tester » pour envoyer un payload exemple à ton endpoint sans créer de vrai événement

astuce

L'URL du webhook doit utiliser HTTPS. Les adresses HTTP et les IP de réseau privé ne sont pas acceptées.

Ce qui est envoyé

Chaque livraison est un objet JSON avec trois champs : event (le type d'événement), timestamp et data (le contenu réel). Voici à quoi ressemble chaque type d'événement.

Notes (note.created)

Contient le titre généré par IA, la transcription complète, le résumé, le type de note, les tags, la priorité, la langue et la date de création.

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

Sur le forfait Ultra, les livraisons de notes peuvent aussi inclure un lien vers l'enregistrement audio (audio_url, audio_format, duration_seconds). Le lien expire au bout de 24 heures. Active cela avec l'option « Note + Audio » lors de la création de l'automatisation.

Tâches (task.created)

Une livraison par tâche. Une seule note avec 3 tâches envoie 3 webhooks séparés.

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

Événements (calendar_event.created)

Une livraison par événement de calendrier.

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

Rapports (report.created)

Envoyé quand un rapport quotidien, hebdomadaire, mensuel ou annuel est généré.

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

Sécurité

Chaque livraison est signée avec HMAC-SHA256 en utilisant le secret de signature de ton automatisation. Les en-têtes suivants sont inclus à chaque livraison :

• X-LP-Signature - la signature HMAC-SHA256 (sha256=...)
• X-LP-Timestamp - timestamp Unix utilisé pour la signature
• X-LP-Event - le type d'événement (note.created, task.created, calendar_event.created, report.created)
• X-LP-Delivery-Id - ID unique de livraison (utile pour la déduplication)
• User-Agent - toujours TellDone-Webhooks/1.0

Les en-têtes de signature sont envoyés avec chaque livraison, indépendamment des autres réglages.

Par défaut, chaque livraison inclut le secret de signature de ton automatisation dans l'en-tête Authorization - ainsi des outils comme le Header Auth de n8n fonctionnent directement en collant le secret comme valeur d'auth. Si tu définis un en-tête d'auth personnalisé dans les paramètres, il remplace ce comportement par défaut. Tu peux utiliser deux formats : Nom-En-tête: valeur (envoie l'en-tête nommé) ou une valeur simple (l'envoie comme Authorization: <valeur>).

Chaque automatisation a son propre secret de signature, donc en tourner un n'affecte aucun de tes autres webhooks. Le secret est affiché en entier uniquement lors de la première création de l'automatisation ou après une rotation. À tout autre moment, seul un aperçu (whsec_...last4) est affiché. Pour le remplacer par un nouveau, appuie sur « Régénérer le secret » dans les paramètres de l'automatisation - cela génère une nouvelle clé HMAC sans changer l'URL ni l'en-tête d'auth. L'ancien secret cesse de fonctionner immédiatement.

Seules les URL HTTPS sont acceptées. HTTP, adresses IP et adresses de réseau privé sont rejetées.

Vérifier les signatures de webhook

Vérifier le HMAC

Chaque livraison inclut un en-tête de signature au format X-LP-Signature: sha256=<hex>. L'exemple ci-dessous montre comment le vérifier en Python.

Chaque webhook est signé pour que tu puisses confirmer qu'il vient bien de TellDone. La signature est calculée comme :

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

Le résultat est encodé en hex et préfixé par sha256= dans l'en-tête de signature.

Utilise le corps de requête brut

TellDone sérialise le JSON avec des espaces après les séparateurs (par exemple {"event": "note.created"}). Si tu parses puis re-sérialises le corps, la signature ne correspondra pas. Vérifie toujours par rapport aux octets bruts du corps de requête.

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...
});

Protection contre le rejeu (facultatif)

Pour empêcher les attaques par rejeu, vérifie que le timestamp est récent :

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

Erreurs courantes

Erreur	Correction
Utiliser le corps parsé puis re-sérialisé	Utilise le corps brut de la requête
JSON.stringify() en JS (compact, sans espaces)	Utilise le corps brut ou aligne les espaces sur Python
Oublier le préfixe timestamp	Le format du payload est timestamp + "." + body
Comparer les chaînes directement	Utilise hmac.compare_digest ou timingSafeEqual

Politique de réessai

Si ton endpoint échoue, TellDone réessaie chaque livraison avec un backoff exponentiel (quelques minutes, puis intervalles plus longs) :

Tentative	Délai
1er réessai	30 secondes
2e réessai	2 minutes
3e réessai	15 minutes
4e réessai	1 heure
5e réessai	4 heures

Après 5 tentatives échouées, la livraison est marquée comme morte. Tu peux toujours la réessayer manuellement depuis le journal de livraison.

Comment TellDone gère les différentes réponses :

• 2xx - livré avec succès
• 4xx (sauf 429) - marqué mort immédiatement, pas de réessai (ton endpoint a explicitement rejeté les données)
• 429 (Trop de requêtes) - réessaie, respecte l'en-tête Retry-After
• 5xx ou timeout - réessaie selon le calendrier ci-dessus

Quand les livraisons échouent à répétition

Tu n'es pas obligé de surveiller le journal de livraison pour savoir si quelque chose est cassé. TellDone surveille les échecs consécutifs pour toi et te contacte en deux étapes.

Après 3 échecs : alerte Boîte de réception

Après 3 livraisons échouées consécutives, TellDone crée un message dans ta Boîte de réception sous la catégorie « Échecs de webhook ». Le message nomme l'automatisation concernée et te renvoie directement à Paramètres > Intégrations > Automatisations > [l'automatisation en échec] > Journal de livraison pour inspecter la réponse et décider quoi faire.

astuce

Les alertes Boîte de réception veulent dire que tu découvres les automatisations cassées via le badge d'icône de l'application au lieu de les découvrir des semaines plus tard via des données manquantes dans ton outil aval.

Après 20 échecs : auto-désactivation

Auto-désactivation

Si 20 livraisons consécutives pour la même automatisation échouent (comptées après l'alerte Boîte de réception), TellDone désactive automatiquement l'automatisation pour cesser de cogner sur un endpoint cassé et protéger ton quota de livraison mensuel. Corrige le problème côté destination, puis réactive l'automatisation depuis Paramètres > Intégrations > Automatisations.

Le compteur d'échecs consécutifs est remis à zéro à la prochaine livraison réussie.

Gérer les webhooks

• Pause/reprise - désactive n'importe quelle automatisation sans la supprimer, réactive à tout moment
• Journal de livraison - vois toutes les livraisons avec statut, code HTTP et temps de réponse. Filtre par Livré ou Erreurs. Appuie sur n'importe quelle livraison échouée et choisis « Réessayer » pour la renvoyer sans attendre le prochain réessai planifié
• Tester - appuie sur « Tester » pour envoyer un payload exemple (avec "test": true dans le corps) à ton endpoint sans créer de vrai événement. Les envois de test ne sont pas comptés dans ton quota mensuel
• Régénérer le secret - génère un nouveau secret de signature HMAC sans changer l'URL ni l'en-tête d'auth
• Modifier - mets à jour l'URL, l'en-tête d'auth ou les bascules de payload (notes / audio / tâches / événements / rapports). Les modifications prennent effet immédiatement
• Supprimer - retire définitivement l'automatisation et tous ses journaux de livraison

Limites de livraison

La livraison des webhooks a deux limites : un quota mensuel (limite stricte, varie selon le forfait) et une limite anti-rafale horaire (limite souple, identique sur tous les forfaits payants).

Forfait	Webhooks	Livraisons mensuelles	Rafale par heure
Free	0	0	-
Basic	1	300	100
Pro	3	3 000	100
Ultra	10	15 000	100

Le forfait Ultra prend aussi en charge les liens audio dans les payloads de notes (expiration 24 heures).

Comportement des limites :

• Quota mensuel dépassé : la livraison est marquée comme échouée sans nouvelle tentative. Les livraisons reprennent le 1er du mois suivant, quand le compteur est remis à zéro.
• Limite horaire dépassée : la livraison est différée et retentée après environ 5 minutes, donc une courte rafale ne perd pas de données. C'est une protection anti-rafale souple, pas un rejet définitif.

Les envois de test et les nouvelles tentatives manuelles depuis le journal de livraison ne sont comptés dans aucune des deux limites.

Filtrer les événements de test

Quand tu appuies sur « Tester », le payload inclut "test": true au niveau supérieur. Dans ton outil d'automatisation, tu peux vérifier ce champ et sauter le traitement quand il est présent.

Guides de plateformes

Pour des instructions de configuration pas à pas avec ton outil d'automatisation :

• Zapier - connecte TellDone à des milliers d'apps avec des Zaps
• Make - construis des scénarios visuels d'automatisation (anciennement Integromat)
• n8n - utilise les webhooks TellDone dans des workflows auto-hébergés ou cloud
• Endpoints personnalisés - tout service qui accepte des requêtes HTTPS POST fonctionne avec les webhooks TellDone

Cas d'usage populaires

• Envoyer des tâches vers une Google Sheet via Zapier
• Créer des messages Slack depuis des notes via Make
• Journaliser des événements vers un CRM personnalisé via n8n
• Sauvegarder toutes les notes vers un stockage cloud
• Transférer les rapports vers un tableau de bord d'équipe

Voir aussi

• Boîte de réception et support - si un webhook échoue à répétition, tu verras un message dans ta Boîte de réception
• Zapier - configuration Zapier pas à pas
• Make - configuration Make pas à pas
• n8n - configuration n8n pas à pas
• Todoist - synchro bidirectionnelle dédiée des tâches (pas de webhook nécessaire)
• Notion - intégration Notion dédiée
• Transfert d'e-mails - reçois les données de notes par e-mail