Connecter Datalume à Make, Zapier et n8n : webhook, signature et 3 scénarios

Pour envoyer vers un tableur sans passer par une plateforme d’automatisation, lis plutôt envoyer tes prospects vers Google Sheets. La version courte de ce guide est dans la documentation de l’envoi direct.

Le webhook Datalume en bref

Datalume envoie un POST JSON signé par lot de 100 fiches maximum, vers une URL https publique, et attend un code 2xx en moins de 10 secondes.

Dans Compte › Intégrations, choisis Webhook, donne un nom, colle l’URL fournie par ta plateforme et clique sur « Ajouter ». Datalume affiche alors le secret de signature (whsec_…) ; le bouton « Secret » le réaffiche. Ensuite, dans une liste, « Envoyer vers… » envoie toute la liste ou ta sélection.

• Lots. 100 fiches au plus par requête : une liste de 250 fiches arrive en 3 requêtes (lot.index de 1 à 3, lot.total égal à 3). Un envoi est limité à 2 000 fiches.
• Réponse attendue. N’importe quel code 2xx, en moins de 10 secondes. Une redirection est considérée comme un échec et n’est jamais suivie.
• Nouvel essai. Après une erreur 5xx, une erreur 429, un délai dépassé ou une erreur réseau, Datalume refait un seul essai, avec le même deliveryId. Un refus d’adresse n’est pas retenté.
• URL acceptées. https uniquement, sans identifiants dans l’adresse, port 443 ou 1024 et plus, et une adresse publique : une URL qui pointe vers un réseau privé (un n8n chez toi, sur ton réseau local, par exemple) est refusée.
• Bouton « Tester ». Il envoie l’événement test avec une fiche d’exemple (« Fiche de test Datalume », id égal à 0). Ignore cet événement dans tes scénarios réels.

Les en-têtes de chaque requête

Quatre en-têtes X-Datalume-* décrivent l’événement, l’envoi, l’heure et la signature.

Le Content-Type est application/json; charset=utf-8 et le User-Agent commence par Datalume-Integrations/1.

La charge utile

Le corps JSON porte la version du format, l’événement, l’envoi, la liste, le lot, la description des colonnes et les fiches.

{
  "version": 1,
  "event": "fiches.envoi",
  "deliveryId": "4f1c…",
  "sentAt": "2026-10-27T10:00:00.000Z",
  "liste": { "id": 42, "nom": "Plombiers Lyon", "source": "pagesjaunes" },
  "lot": { "index": 1, "total": 3 },
  "colonnes": [
    { "key": "id", "label": "ID Datalume" },
    { "key": "nom", "label": "Nom" },
    { "key": "note", "label": "Note" },
    …
  ],
  "fiches": [
    {
      "id": 123,
      "nom": "Plomberie Exemple",
      "telephone": "04 00 00 00 00",
      "cp": "69003",
      "ville": "Lyon",
      "siret": "00000000000000",
      "emails": "[email protected] ; …",
      "emailStatut": "confirmé (2 sources) ; …",
      …
    }
  ]
}

Chaque fiche porte id, l’identifiant Datalume stable de la fiche, puis les mêmes clés que l’export CSV. Toutes les valeurs sont du texte brut, et une chaîne vide quand l’information manque (par exemple tant que la liste n’est pas enrichie). Plusieurs e-mails ou numéros sont joints par « ; » dans une seule valeur. Les 33 clés :

Vérifier la signature

Recalcule le HMAC-SHA256 de « timestamp, point, corps brut » avec ton secret, compare-le en temps constant à l’en-tête et refuse les messages de plus de 5 minutes.

La signature protège ton récepteur contre les faux envois et le rejeu d’un vieux message, parce que l’heure fait partie du texte signé. Trois règles : signer le corps brut, exactement comme reçu (pas un JSON relu puis réécrit, qui peut changer l’ordre ou les espaces) ; comparer en temps constant ; refuser un horodatage éloigné de plus de 300 secondes.

const crypto = require('node:crypto');

// secret : celui de ton intégration Datalume (whsec_...)
// headers : les en-têtes de la requête, clés en minuscules (comme Node les fournit)
// corpsBrut : le corps de la requête tel qu'il est arrivé (string ou Buffer), PAS le JSON re-sérialisé
function signatureDatalumeValide(secret, headers, corpsBrut) {
  const timestamp = headers['x-datalume-timestamp'];
  const recue = headers['x-datalume-signature'];
  if (!timestamp || !recue) return false;

  // Refuse un message vieux de plus de 5 minutes (protection contre le rejeu)
  if (Math.abs(Date.now() / 1000 - Number(timestamp)) > 300) return false;

  const attendue =
    'sha256=' +
    crypto.createHmac('sha256', secret).update(timestamp + '.').update(corpsBrut).digest('hex');

  const a = Buffer.from(recue);
  const b = Buffer.from(attendue);
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

module.exports = { signatureDatalumeValide };

Cet extrait est exécuté par un test automatique de Datalume contre la vraie fonction de signature du produit (envoi réel avec accents, corps modifié, autre secret, en-tête absent, horodatage trop ancien ou trop récent). Branché sur un serveur Express, il donne ceci :

const express = require('express');
const { signatureDatalumeValide } = require('./verification');

const app = express();

// Le corps doit rester brut pour que la signature se recalcule à l'identique
app.post('/datalume', express.raw({ type: 'application/json', limit: '2mb' }), (req, res) => {
  if (!signatureDatalumeValide(process.env.DATALUME_SECRET, req.headers, req.body)) {
    return res.status(401).end();
  }
  const envoi = JSON.parse(req.body.toString('utf8'));
  if (envoi.event === 'test') return res.status(200).end();

  // Un nouvel essai garde le même deliveryId et le même lot.index : ignore ce que tu as déjà traité
  console.log(envoi.deliveryId, envoi.lot.index, envoi.fiches.length);
  res.status(200).end();
});

app.listen(3000);

Scénario 1 · Make vers un CRM

Un module « Webhooks › Custom webhook » reçoit l’envoi, un Iterator sépare les fiches et un module de ton CRM crée une entreprise par fiche.

1. 1Dans Make, crée un scénario et ajoute le module Webhooks › Custom webhook. À côté de la liste « Webhook », clique sur Add, donne un nom au webhook et clique sur Save : Make génère l’URL et se met à l’écoute. Copie l’URL.
2. 2Dans Datalume, ajoute un Webhook avec cette URL (Compte › Intégrations). Garde le secret si tu comptes vérifier la signature plus tard.
3. 3Dans Make, lance le scénario pour que le module attende un appel, puis clique sur « Tester » dans Datalume. D’après la documentation de Make, l’envoi d’un échantillon permet à Make de détecter les champs : tu retrouves event, liste, lot et le tableau fiches. Si les champs changent, le bouton « Detect new values » du module relit la structure.
4. 4Ajoute un module Iterator et mets le tableau fiches dans son champ Array : chaque élément du tableau sort comme un bundle séparé, donc une fiche par exécution du module suivant.
5. 5Entre le module Custom webhook et l’Iterator, ajoute un filtre qui laisse passer seulement event égal à fiches.envoi, pour ignorer l’événement de test.
6. 6Après l’Iterator, ajoute le module de ton CRM. Avec HubSpot CRM, la documentation de Make liste notamment Create a Company, Create a Contact, Create or Update a Contact et Search for Companies. Associe les champs : nom, telephone, site, ville, cp… aux champs du module.

Deux précautions. D’abord, Make répond par défaut « Accepted » avec un code 200 dès que la requête est mise en file, ce qui tient largement dans les 10 secondes de Datalume, même si le traitement des fiches est long. Ensuite, évite les doublons si tu renvoies une liste : place un module de recherche (par exemple Search for Companies) avant la création et utilise l’id Datalume ou le siret comme critère.

Scénario 2 · Zapier vers un outil d’e-mailing

Le déclencheur « Webhooks by Zapier » en mode Catch Hook reçoit l’envoi, « Looping by Zapier » traite chaque fiche et une action d’e-mailing ajoute le contact.

1. 1Dans l’éditeur de Zap, clique sur l’étape Trigger, choisis Webhooks by Zapier, puis l’événement Catch Hook (corps analysé) et continue. Tu peux laisser vide le champ facultatif « Pick Off A Child Key ».
2. 2Dans l’onglet Test, Zapier affiche l’URL du webhook : clique sur Copy.
3. 3Dans Datalume, ajoute un Webhook avec cette URL, puis clique sur « Tester ». Retourne dans Zapier et clique sur Test trigger : l’envoi de test apparaît, avec ses champs.
4. 4Ajoute une action Looping by Zapier, événement Create Loop From Line Items. Dans « Values to Loop », nomme chaque valeur à gauche et choisis à droite le champ correspondant des fiches (emails, nom, emailStatut…) : les actions suivantes s’exécutent pour chaque fiche.
5. 5Ajoute une étape de filtre pour ne garder que les fiches qui ont un e-mail et dont le statut te convient. La colonne emails peut contenir plusieurs adresses séparées par « ; » : isole la première avec une étape de mise en forme du texte.
6. 6Ajoute l’action de ton outil d’e-mailing. Exemple avec Mailchimp : Add/Update Subscriber, dont les champs obligatoires, d’après la fiche Zapier de l’application, sont list_id, email et member_status.

Zapier accepte jusqu’à 10 Mo par requête pour ce déclencheur : un lot de 100 fiches reste très en dessous. Zapier répond lui-même 200 à Datalume. Pense aussi au cadre légal avant d’importer des contacts dans un outil d’e-mailing : lis RGPD et prospection B2B et filtre sur le statut d’e-mail avec le guide sur la fiabilité des e-mails.

Scénario 3 · n8n vers Slack ou Notion

Le nœud Webhook de n8n reçoit le POST ; un nœud Slack peut annoncer chaque lot, ou un nœud Split Out sépare les fiches pour les créer une à une dans Notion.

1. 1Ajoute un nœud Webhook : HTTP Method sur POST, Path au choix (n8n en propose un aléatoire), et sous « Respond » l’option Immediately pour répondre tout de suite.
2. 2Le nœud affiche deux URL. Pour tester, copie l’URL de test, clique sur Listen for Test Event, puis lance « Tester » dans Datalume : l’envoi s’affiche dans l’éditeur. Pour les vrais envois, utilise l’URL de production, qui n’est enregistrée que lorsque tu publies le workflow ; les exécutions apparaissent alors dans l’onglet Executions.
3. 3Les données arrivent dans $json.body (les en-têtes dans $json.headers). Pour Slack, ajoute un nœud Slack, ressource Message, opération Send a message, et compose un texte avec des expressions, par exemple : Datalume : lot {{ $json.body.lot.index }}/{{ $json.body.lot.total }} de {{ $json.body.liste.nom }}, {{ $json.body.fiches.length }} fiches. Le nœud Slack demande d’abord tes identifiants Slack (voir la documentation n8n).
4. 4Pour Notion, ajoute d’abord un nœud Split Out avec Field to Split Out sur body.fiches : chaque fiche devient un élément. Puis ajoute un nœud Notion, ressource Database Page, opération Create, et associe les propriétés de ta base (nom, téléphone, site, ville…) aux champs de la fiche.

Dépannage

Le bouton « Tester » et le journal des envois affichent le message d’erreur du côté de ton récepteur : voici les plus courants.

Questions fréquentes

Documentation officielle consultée le 28/10/2026 : Make, Webhooks, Make, Iterator, Zapier, Webhooks, Zapier, Looping, n8n, nœud Webhook et n8n, Split Out. Les interfaces évoluent : en cas d’écart, la documentation de la plateforme fait foi.