Aller au contenu principal

Automatisations webhook

Basic et plus

Les automatisations nécessitent Basic ou plus. Basic : 1 automatisation, Pro : 3, Ultra : 10. Avec Free, la ligne affiche Passe à Pro pour débloquer les automatisations.

Un webhook est une adresse web qui reçoit des données automatiquement. Avec les Automatisations, TellDone envoie chaque nouvelle note avec ses tâches et ses événements à cette adresse dès que la note est prête, et chaque nouveau rapport dès qu’il est prêt, pour que des outils comme Zapier, Make ou n8n puissent s’en servir. Chaque tâche et chaque événement est envoyé dans un envoi distinct.

Choisir quoi envoyer​

Chaque automatisation a ses propres réglages sous Quoi envoyer. Choisis une option ou n’importe quelle combinaison :

  • Note - la note complète après traitement (titre, transcription, résumé, type, tags, priorité, langue et date de création)
  • Note + audio - avec le plan Ultra, ajoute à chaque envoi de note un lien de téléchargement du fichier audio, valable 24 heures. Laisse Note activé : sans lui, aucune note n’est envoyée
  • Tâches - un envoi par tâche extraite
  • Événements - un envoi par événement de calendrier extrait
  • Rapports - un envoi par rapport quotidien, hebdomadaire, mensuel ou annuel généré (les types de rapports inclus dans ton plan). Les rapports de remplacement des jours calmes et les courts rapports des semaines calmes ne sont pas envoyés

Tu peux modifier ces choix à tout moment dans les réglages de l’automatisation : les changements ne s’appliquent qu’aux nouveaux envois.

Choisir quand envoyer​

Sous les choix de données, quatre boutons distincts décident quels changements déclenchent un envoi : Créé, Mis à jour, Terminées et Supprimé. Un déclencheur ne fonctionne qu’avec le bouton de données correspondant au-dessus. Par exemple, Terminées envoie les tâches terminées seulement si Tâches est activé.

Créé est envoyé pour les notes que TellDone fait à partir d’un enregistrement ou d’une note texte, et pour les tâches et événements qu’elles contiennent. Les tâches et événements que tu ajoutes à la main ou avec un assistant IA, et les nouveaux éléments d’Ajouter à la voix, ne sont pas envoyés comme Créé. Mis à jour, Terminées et Supprimé sont envoyés quand tu modifies un élément dans l’app ou avec Ajouter à la voix. Les changements faits par Smart Context, par un assistant IA ou dans Todoist, Notion ou Microsoft To Do ne déclenchent pas d’envoi.

Le champ event de chaque envoi indique ce qui s’est passé, par exemple task.created, task.completed ou calendar_event.updated.

Configurer un webhook​

Réglages des automatisations pour Zapier, Make et n8n

  1. Va dans Réglages > Intégrations > Automatisations
  2. Touche Nouvelle automatisation

Configuration d’un nouveau webhook d’automatisation

  1. Saisis un nom (par exemple « Mon webhook Zapier »)
  2. Colle l’URL du webhook de ton service d’automatisation
  3. Choisis les données à envoyer (Note, Note + audio avec Ultra, Tâches, Événements, Rapports) et les déclencheurs à utiliser (Créé, Mis à jour, Terminées, Supprimé)
  4. Si tu veux, ajoute un en-tête d’authentification - un jeton envoyé dans l’en-tête Authorization pour les endpoints sécurisés
  5. Touche Enregistrer
  6. Copie la clé de signature - elle n’est affichée en entier que lorsque tu crées l’automatisation ou après l’avoir régénérée. Tu en as besoin pour vérifier que les envois viennent bien de TellDone (voir Vérifier les signatures des webhooks)
  7. Touche Tester l’envoi pour envoyer un exemple de payload à ton endpoint sans modifier aucune de tes données. Tu verras Succès avec le code HTTP et le temps de réponse, ou Erreur avec la raison. Les envois de test n’apparaissent pas dans le journal des envois

Ce qui est envoyé​

Chaque envoi est un objet JSON avec trois champs : event (le type d’événement), timestamp et data (le contenu). Les envois de test incluent aussi "test": true. Voici à quoi ressemble chaque type d’événement.

Notes (note.created)​

Contient le titre généré par l’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:00.512345+00:00",
  "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:00.284117+00:00"
  }
}

Avec le plan Ultra, les envois de notes peuvent aussi inclure un lien vers l’enregistrement audio (audio_url, audio_format, duration_seconds). Le lien expire après 24 heures. Active-le avec l’option Note + audio de l’automatisation.

Tâches (task.created)​

Un envoi par tâche. Une note avec 3 tâches envoie 3 envois distincts.

{
  "event": "task.created",
  "timestamp": "2026-02-27T14:38:01.204718+00:00",
  "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:00+00:00",
    "tags": ["work"],
    "status": "todo",
    "cancel_reason": null,
    "cancelled_at": null,
    "created_at": "2026-02-27T10:00:00.284117+00:00"
  }
}

Événements (calendar_event.created)​

Un envoi par événement de calendrier.

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

start et end sont en UTC. start_local, end_local, start_date et end_date utilisent ton fuseau horaire (timezone). Pour un événement sur toute la journée, end_date est le dernier jour de l’événement.

Rapports (report.created)​

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

{
  "event": "report.created",
  "timestamp": "2026-02-28T00:05:00.731902+00:00",
  "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": "planning",
      "tasks_created": 5,
      "tasks_completed": 3
    },
    "created_at": "2026-02-28T00:05:00.418253+00:00"
  }
}

Sécurité​

Chaque envoi est signé en HMAC-SHA256 avec la clé de signature de ton automatisation. Les en-têtes suivants sont inclus dans chaque envoi :

  • X-LP-Signature - la signature HMAC-SHA256 (sha256=...)
  • X-LP-Timestamp - l’horodatage Unix utilisé pour la signature
  • X-LP-Event - le type d’événement (par exemple note.created, task.completed, calendar_event.updated, report.created)
  • X-LP-Delivery-Id - l’identifiant unique de l’envoi (utile pour dédupliquer)
  • User-Agent - toujours TellDone-Webhooks/1.0

TellDone n’envoie un en-tête Authorization que si tu ajoutes un en-tête d’authentification dans l’automatisation. Tu peux utiliser deux formats : Header-Name: value envoie un en-tête nommé, et une simple valeur envoie Authorization: <value>. Ta clé de signature n’est jamais envoyée dans un en-tête.

Chaque automatisation a sa propre clé de signature : en régénérer une n’affecte donc aucun de tes autres webhooks. La clé n’est affichée en entier que lorsque tu crées l’automatisation ou après l’avoir régénérée. Le reste du temps, seul un aperçu (whsec_...last4) est affiché. Pour la remplacer par une nouvelle, touche Régénérer la clé dans les réglages de l’automatisation : cela génère une nouvelle clé HMAC sans changer l’URL ni l’en-tête d’authentification. L’ancienne clé cesse de fonctionner immédiatement.

Seules les URL HTTPS avec un nom de domaine sont acceptées. Le HTTP, les adresses IP (publiques ou privées), les URL avec un nom d’utilisateur ou un mot de passe, et les domaines qui pointent vers des adresses de réseau privé sont refusés. TellDone vérifie l’adresse de nouveau à chaque envoi. Si cette vérification échoue, par exemple parce que le domaine ne se résout pas à ce moment-là, l’envoi est arrêté et n’est pas réessayé.

Vérifier les signatures des webhooks​

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

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

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

Utilise le corps brut de la requête

TellDone sérialise le JSON avec des espaces après les séparateurs (par exemple {"event": "note.created"}). Si tu analyses puis resérialises le corps, la signature ne correspondra pas. Vérifie toujours à partir des octets bruts du corps de la 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");
  const a = Buffer.from(signature);
  const b = Buffer.from(expected);
  // timingSafeEqual throws if the lengths differ, e.g. when the header is missing
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

// 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 l’horodatage 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​

ErreurSolution
Utiliser le corps analysé puis resérialiséUtilise le corps brut de la requête
JSON.stringify() en JS (compact, sans espaces)Utilise le corps brut de la requête
Oublier le préfixe d’horodatageLe format du payload est timestamp + "." + body
Comparer les chaînes directementUtilise hmac.compare_digest ou timingSafeEqual

Politique de nouvelles tentatives​

Si ton endpoint échoue, TellDone réessaie chaque envoi selon ce calendrier :

TentativeDélai
1re nouvelle tentative30 secondes
2e nouvelle tentative2 minutes
3e nouvelle tentative15 minutes
4e nouvelle tentative1 heure
5e nouvelle tentative4 heures

Si la 5e nouvelle tentative échoue aussi, l’envoi est marqué comme échoué et n’est plus réessayé. Dans l’app, il s’affiche avec une croix rouge. Tu peux quand même le renvoyer toi-même depuis le journal complet des envois : ouvre Tous les envois (le lien apparaît quand une automatisation a plus de 5 envois) et touche Réessayer sur l’envoi échoué. La courte liste Envois récents ne propose pas de nouvelle tentative.

Comment TellDone traite les différentes réponses :

  • 2xx - envoyé avec succès
  • 4xx (sauf 429) - marqué comme échoué tout de suite et non réessayé (ton endpoint a explicitement refusé les données)
  • 429 (Too Many Requests) - réessayé après le nombre de secondes indiqué dans Retry-After (60 secondes s’il n’y en a pas). Ces nouvelles tentatives ne sont pas limitées à 5, mais chacune compte dans les 20 échecs qui désactivent l’automatisation
  • 5xx ou délai dépassé - nouvelles tentatives selon le calendrier ci-dessus

Quand les envois échouent à répétition​

Si les envois échouent sans arrêt, TellDone te prévient et finit par désactiver l’automatisation.

Après 3 échecs : avertissement dans la Boîte de réception​

Après 3 échecs d’affilée (les nouvelles tentatives comptent aussi), TellDone envoie un message dans ta Boîte de réception intitulé Ton automatisation « Nom » échoue, avec le nom de ton automatisation entre guillemets. Tu peux alors l’ouvrir dans Réglages > Intégrations > Automatisations, vérifier ses envois et décider quoi faire.

Après 20 échecs : désactivation automatique​

Désactivation automatique

Si 20 tentatives d’affilée échouent pour la même automatisation (les nouvelles tentatives comptent aussi), TellDone la désactive pour qu’elle cesse d’envoyer vers une adresse qui ne fonctionne pas. Corrige le problème dans ton outil d’automatisation, puis réactive son bouton Active dans Réglages > Intégrations > Automatisations. La réactiver ne remet pas le compteur d’échecs à zéro : tant qu’un envoi n’a pas réussi, un seul échec la désactive de nouveau.

Chaque tentative échouée compte : un envoi qui échoue à ses 5 nouvelles tentatives ajoute donc 6 au compteur. Une automatisation peut ainsi se désactiver après environ 4 envois en échec. Le compteur revient à zéro au prochain envoi réussi.

Gérer les webhooks​

  • Active - désactive ce bouton pour arrêter une automatisation sans la supprimer, et réactive-le quand tu veux. Rien n’est envoyé tant qu’il est désactivé : les notes et rapports de cette période ne sont pas envoyés plus tard, et les envois en attente d’une nouvelle tentative sont abandonnés
  • Envois - Envois récents affiche les 5 derniers avec leur statut, le code HTTP et le temps de réponse. Quand il y en a plus, Tous les envois ouvre le journal des 30 derniers jours, où tu peux filtrer par Tous, Envoyés ou Erreurs et toucher Réessayer sur un envoi échoué pour le renvoyer sans attendre la prochaine nouvelle tentative prévue
  • Tester l’envoi - envoie un exemple de note (note.created, avec "test": true dans le corps), quels que soient les types de données choisis, sans modifier aucune de tes données. Disponible une fois l’automatisation enregistrée. Les envois de test ne comptent pas dans ta limite mensuelle
  • Régénérer la clé - génère une nouvelle clé de signature HMAC sans changer l’URL ni l’en-tête d’authentification
  • Modifier - change l’URL, l’en-tête d’authentification, les choix de données (Note / Note + audio / Tâches / Événements / Rapports) ou les déclencheurs (Créé / Mis à jour / Terminées / Supprimé). Les changements prennent effet immédiatement
  • Supprimer l’automatisation - supprime définitivement l’automatisation et tous ses journaux d’envoi

Chaque envoi affiche son statut sous forme d’icône :

IcôneSignification
Coche verteEnvoyé
Horloge jauneEn attente ou en cours d’envoi
Triangle rougeÉchec, TellDone va réessayer
Croix rougeÉchec, plus de nouvelle tentative automatique

Tu peux toucher Réessayer sur les envois avec un triangle rouge ou une croix rouge dans le journal complet.

Limites d’envoi​

Il y a deux limites : une limite mensuelle qui dépend de ton plan, et une limite horaire de 100 envois sur tous les plans payants, qui protège contre les pics soudains.

PlanAutomatisationsEnvois par moisLimite horaire
Free00-
Basic1300100
Pro33 000100
Ultra1015 000100

Comment les limites se comportent :

  • Limite mensuelle atteinte - l’envoi attend. Il s’affiche comme échoué (« Monthly webhook limit exceeded »), et TellDone réessaie toutes les 5 minutes. Il part après la réinitialisation de ta limite à 00:00 UTC le 1er du mois, sauf s’il a alors plus de 30 jours. Les envois effectués après la réinitialisation comptent dans le nouveau mois.
  • Limite horaire atteinte - l’envoi est reporté et réessayé après environ 5 minutes, donc un pic bref ne fait perdre aucune donnée.

Seuls les envois réussis comptent dans la limite mensuelle. La limite horaire compte chaque tentative, nouvelles tentatives comprises. Les envois de test ne comptent dans aucune des deux limites.

Si tu changes de plan, tes automatisations et leurs réglages sont conservés. Avec Free, elles cessent d’envoyer et tu ne peux plus les ouvrir tant que tu ne passes pas à un plan supérieur. Avec Basic, les automatisations que tu avais déjà continuent d’envoyer dans la limite de 300 envois par mois, mais tu ne peux pas en ajouter ni en activer plus d’une.

Filtrer les événements de test​

Quand tu touches Tester l’envoi, le payload inclut "test": true au niveau supérieur. Dans ton outil d’automatisation, tu peux vérifier ce champ et ignorer le traitement quand il est présent.

Guides par plateforme​

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

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

Idées​

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

Voir aussi​

  • Boîte de réception et assistance - si un webhook échoue à répétition, tu verras un message dans ta Boîte de réception
  • Zapier - configuration pas à pas de Zapier
  • Make - configuration pas à pas de Make
  • n8n - configuration pas à pas de n8n
  • Todoist - synchro des tâches dédiée dans les deux sens (sans webhooks)
  • Notion - intégration Notion dédiée
  • Transfert d’e-mails - reçois les données de tes notes par e-mail
Dernière mise à jour le