Connecter Rodz à HubSpot : synchroniser signaux et CRM

Q: Comment tester l'intégration avant de la mettre en production ?

Utilisez l'événement de test de l'API Rodz (`POST /webhooks/{id}/test`) pour envoyer un payload fictif a votre middleware. Vérifiez que l'entreprise et le contact sont bien créés dans HubSpot. Pour les tests locaux, utilisez ngrok pour exposer votre endpoint en HTTPS. Créez également un portail HubSpot de test (sandbox) pour éviter de polluer vos données de production.

En résumé : Ce guide vous montre comment connecter Rodz a HubSpot pour synchroniser automatiquement vos signaux d’affaires dans votre CRM. Vous apprendrez a configurer un webhook Rodz, a créer un middleware (ou un scénario Make) pour transformer les données, puis a créer ou mettre a jour des contacts, entreprises et deals dans HubSpot via son API. Résultat : vos commerciaux disposent des signaux directement dans leur CRM, sans saisie manuelle.

Pourquoi connecter Rodz a HubSpot ?

Les signaux d’affaires détectés par Rodz (levées de fonds, recrutements, déménagements, changements de dirigeant) sont des informations précieuses pour vos équipes commerciales. Mais leur valeur diminue si elles restent isolées dans un outil séparé. Le véritable levier, c’est de les injecter dans le CRM que vos commerciaux utilisent au quotidien.

En connectant Rodz a HubSpot, vous obtenez trois bénéfices concrets. Premièrement, vous centralisez l’intelligence commerciale. Chaque signal enrichit automatiquement la fiche entreprise ou contact correspondante dans HubSpot. Vos commerciaux n’ont plus besoin de basculer entre deux interfaces. Deuxièmement, vous pouvez déclencher des workflows automatisés. Un signal de levée de fonds peut automatiquement créer une tâche de rappel, assigner un commercial ou démarrer une séquence d’emails. Troisièmement, vous enrichissez votre CRM avec des données fraîches et contextuelles que HubSpot seul ne peut pas fournir.

L’intégration repose sur une architecture simple : Rodz envoie un webhook a chaque nouveau signal, un middleware transforme et route les données, puis l’API HubSpot crée ou met a jour les enregistrements. Ce guide couvre chaque étape en détail.

Pour comprendre comment Rodz détecte et structure ses signaux, consultez le guide des signaux RH et recrutement ou l’article sur les workflows commerciaux dans le CRM.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

Un compte Rodz actif avec accès API. Vous aurez besoin de votre clé API pour configurer les webhooks. Consultez la documentation de l’API Rodz si vous ne l’avez pas encore.
Un compte HubSpot avec accès API. Un compte HubSpot Pro ou Enterprise est recommandé pour bénéficier des propriétés personnalisées et des workflows. Générez une clé d’accès privée (Private App) depuis les paramètres de votre portail.
Au moins un signal Rodz configuré. L’intégration n’a de sens que si vous recevez des signaux. Suivez le guide de configuration des webhooks Rodz pour les activer.
Un middleware pour recevoir et transformer les données. Vous avez deux options : un endpoint custom (Node.js, Python, etc.) ou un outil no-code comme Make. Ce guide couvre les deux approches.
Des connaissances de base en HTTP et JSON. Vous devez comprendre les requêtes POST, les headers d’authentification et les corps JSON.
Un outil de test HTTP. cURL, Postman ou Insomnia pour tester vos appels API.

Architecture de l’intégration

L’intégration suit un flux en trois étapes :

Rodz (webhook) → Middleware (transformation) → HubSpot (API)

Rodz envoie un payload JSON a chaque nouveau signal. Ce payload contient les données de l’entreprise, du contact associé et les métadonnées du signal (montant de la levée, poste recruté, etc.). Le middleware reçoit ce payload, le transforme pour correspondre au format attendu par HubSpot, puis appelle l’API HubSpot pour créer ou mettre a jour les enregistrements.

Pourquoi un middleware ? Parce que les formats de données de Rodz et de HubSpot sont différents. Les noms de propriétés ne correspondent pas, la structure des objets est différente, et certaines logiques métier (déduplication, enrichissement complémentaire, routage par équipe) doivent être appliquées avant l’écriture dans le CRM.

Pour une référence complète des endpoints et des formats de l’API Rodz, consultez la documentation de référence.

Étape 1 : Configurer le webhook Rodz

La première étape consiste a créer un webhook dans Rodz pour recevoir les signaux en temps réel. Si vous avez déja suivi le guide de configuration des webhooks, vous pouvez passer a l’étape suivante.

Enregistrez votre webhook via l’API Rodz :

curl -X POST https://api.rodz.io/webhooks \
  -H "Authorization: Bearer VOTRE_CLE_API_RODZ" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://votre-middleware.com/rodz-to-hubspot",
    "events": ["signal.new", "signal.updated"],
    "secret": "votre_secret_hmac_256"
  }'

L’URL pointe vers votre middleware (votre serveur custom ou votre endpoint Make). Le paramètre events filtre les types d’événements que vous souhaitez recevoir. Pour une intégration CRM, signal.new et signal.updated couvrent la majorité des cas.

Le paramètre secret est facultatif mais fortement recommandé. Il vous permet de vérifier la signature HMAC-SHA256 de chaque requête entrante pour garantir qu’elle provient bien de Rodz.

Payload reçu

Chaque notification contient un payload structuré. Voici un exemple pour un signal de type “levée de fonds” :

{
  "event_id": "evt_20260310_xyz789",
  "event_type": "signal.new",
  "signal_type": "fundraising",
  "timestamp": "2026-03-10T09:15:00Z",
  "company": {
    "id": "comp_123abc",
    "name": "DataFlow SAS",
    "domain": "dataflow.io",
    "siren": "987654321",
    "industry": "SaaS",
    "size": "50-200",
    "location": {
      "city": "Lyon",
      "country": "FR"
    }
  },
  "contact": {
    "id": "cont_456def",
    "first_name": "Julien",
    "last_name": "Martin",
    "title": "CEO",
    "email": "julien.martin@dataflow.io",
    "linkedin_url": "https://linkedin.com/in/julienmartin"
  },
  "metadata": {
    "amount": 8000000,
    "currency": "EUR",
    "round": "Series A",
    "investors": ["VC Capital", "Growth Partners"],
    "source_url": "https://example.com/dataflow-levee"
  }
}

C’est ce payload que votre middleware va transformer avant de l’envoyer a HubSpot.

Étape 2 : Créer le middleware de transformation

Vous avez deux options pour le middleware : un endpoint custom ou un scénario Make. Commençons par l’approche custom.

Option A : Middleware custom (Node.js)

Créez un serveur Express.js qui reçoit le webhook Rodz, transforme les données et appelle l’API HubSpot :

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

app.use(express.json());

// Vérification de la signature HMAC
function verifySignature(req, secret) {
  const signature = req.headers['x-rodz-signature'];
  const computed = crypto.createHmac('sha256', secret).update(JSON.stringify(req.body)).digest('hex');
  return signature === computed;
}

app.post('/rodz-to-hubspot', async (req, res) => {
  // 1. Vérifier la signature
  if (!verifySignature(req, process.env.RODZ_WEBHOOK_SECRET)) {
    return res.status(401).json({ error: 'Signature invalide' });
  }

  const signal = req.body;

  try {
    // 2. Créer ou mettre a jour l'entreprise dans HubSpot
    const company = await upsertHubSpotCompany(signal.company, signal);

    // 3. Créer ou mettre a jour le contact
    const contact = await upsertHubSpotContact(signal.contact, company.id);

    // 4. Créer un événement timeline
    await createTimelineEvent(signal, company.id);

    res.status(200).json({ received: true });
  } catch (error) {
    console.error('Erreur HubSpot:', error.message);
    res.status(500).json({ error: 'Erreur de traitement' });
  }
});

app.listen(3000, () => {
  console.log('Middleware Rodz-HubSpot actif sur le port 3000');
});

Ce squelette gère la vérification de signature, la création des enregistrements HubSpot et la gestion des erreurs. Les fonctions upsertHubSpotCompany, upsertHubSpotContact et createTimelineEvent sont détaillées dans les étapes suivantes.

Option B : Scénario Make (no-code)

Si vous préférez une approche sans code, Make est une excellente alternative. Voici le scénario a créer :

Module Webhook (déclencheur). Créez un webhook custom dans Make. Copiez l’URL générée et utilisez-la comme URL de webhook dans Rodz.
Module Router. Ajoutez un routeur pour gérer différents types de signaux (levée de fonds, recrutement, changement de poste) avec des traitements spécifiques.
Module HTTP (recherche HubSpot). Pour chaque branche, commencez par chercher si l’entreprise existe déja dans HubSpot via une requête GET sur /crm/v3/objects/companies/search.
Module HTTP (création/mise a jour). Selon le résultat de la recherche, créez une nouvelle entreprise ou mettez a jour l’existante via l’API HubSpot.
Module HTTP (contact). Répétez la logique recherche/création pour le contact, en l’associant a l’entreprise.
Module HTTP (timeline event). Créez un événement timeline pour tracer le signal dans l’historique de l’entreprise.

Ce scénario Make se déclenche a chaque réception de webhook Rodz et exécute toute la chaîne de transformation en quelques secondes. L’avantage : pas de serveur a maintenir, pas de code a déployer.

Étape 3 : Mapper les données Rodz vers HubSpot

Le mapping des champs est la clé d’une intégration réussie. Voici la correspondance entre les champs du payload Rodz et les propriétés HubSpot.

Mapping entreprise

Champ Rodz	Propriété HubSpot	Notes
`company.name`	`name`	Nom de l’entreprise
`company.domain`	`domain`	Domaine web, utilisé comme clé de déduplication
`company.industry`	`industry`	Secteur d’activité
`company.size`	`numberofemployees`	Convertir la plage en nombre (ex. “50-200” → 125)
`company.location.city`	`city`	Ville du siège
`company.location.country`	`country`	Code pays ISO
`company.siren`	`rodz_siren` (custom)	Propriété personnalisée a créer dans HubSpot
`signal_type`	`rodz_last_signal_type` (custom)	Dernier type de signal détecté
`timestamp`	`rodz_last_signal_date` (custom)	Date du dernier signal
`metadata.amount`	`rodz_fundraising_amount` (custom)	Montant de la levée (si applicable)

Mapping contact

Champ Rodz	Propriété HubSpot	Notes
`contact.first_name`	`firstname`	Prénom
`contact.last_name`	`lastname`	Nom
`contact.email`	`email`	Email, utilisé comme clé de déduplication
`contact.title`	`jobtitle`	Intitulé de poste
`contact.linkedin_url`	`hs_linkedinid`	URL LinkedIn

Créer les propriétés personnalisées dans HubSpot

Avant de pouvoir écrire les données de signaux dans HubSpot, vous devez créer les propriétés personnalisées. Voici l’appel API pour créer la propriété rodz_last_signal_type sur l’objet Company :

curl -X POST https://api.hubapi.com/crm/v3/properties/companies \
  -H "Authorization: Bearer VOTRE_TOKEN_HUBSPOT" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "rodz_last_signal_type",
    "label": "Dernier signal Rodz",
    "type": "enumeration",
    "fieldType": "select",
    "groupName": "companyinformation",
    "options": [
      { "label": "Levée de fonds", "value": "fundraising" },
      { "label": "Recrutement", "value": "hiring" },
      { "label": "Déménagement", "value": "relocation" },
      { "label": "Changement de dirigeant", "value": "leadership_change" },
      { "label": "Appel d offres", "value": "tender" }
    ]
  }'

Répétez cette opération pour chaque propriété personnalisée : rodz_last_signal_date (type date), rodz_siren (type string), rodz_fundraising_amount (type number).

Étape 4 : Créer et mettre a jour les enregistrements HubSpot

Rechercher une entreprise existante

Avant de créer une entreprise, vérifiez si elle existe déja dans HubSpot en cherchant par domaine :

curl -X POST https://api.hubapi.com/crm/v3/objects/companies/search \
  -H "Authorization: Bearer VOTRE_TOKEN_HUBSPOT" \
  -H "Content-Type: application/json" \
  -d '{
    "filterGroups": [{
      "filters": [{
        "propertyName": "domain",
        "operator": "EQ",
        "value": "dataflow.io"
      }]
    }],
    "properties": ["name", "domain", "rodz_last_signal_type"]
  }'

Créer une nouvelle entreprise

Si la recherche ne retourne aucun résultat, créez l’entreprise :

curl -X POST https://api.hubapi.com/crm/v3/objects/companies \
  -H "Authorization: Bearer VOTRE_TOKEN_HUBSPOT" \
  -H "Content-Type: application/json" \
  -d '{
    "properties": {
      "name": "DataFlow SAS",
      "domain": "dataflow.io",
      "industry": "SaaS",
      "numberofemployees": "125",
      "city": "Lyon",
      "country": "FR",
      "rodz_siren": "987654321",
      "rodz_last_signal_type": "fundraising",
      "rodz_last_signal_date": "2026-03-10",
      "rodz_fundraising_amount": "8000000"
    }
  }'

Mettre a jour une entreprise existante

Si l’entreprise existe déja, mettez a jour ses propriétés avec les données du signal :

curl -X PATCH https://api.hubapi.com/crm/v3/objects/companies/COMPANY_ID \
  -H "Authorization: Bearer VOTRE_TOKEN_HUBSPOT" \
  -H "Content-Type: application/json" \
  -d '{
    "properties": {
      "rodz_last_signal_type": "fundraising",
      "rodz_last_signal_date": "2026-03-10",
      "rodz_fundraising_amount": "8000000"
    }
  }'

Créer ou mettre a jour un contact

La logique est identique pour les contacts. Cherchez par email, puis créez ou mettez a jour :

curl -X POST https://api.hubapi.com/crm/v3/objects/contacts/search \
  -H "Authorization: Bearer VOTRE_TOKEN_HUBSPOT" \
  -H "Content-Type: application/json" \
  -d '{
    "filterGroups": [{
      "filters": [{
        "propertyName": "email",
        "operator": "EQ",
        "value": "julien.martin@dataflow.io"
      }]
    }]
  }'

Si le contact n’existe pas :

curl -X POST https://api.hubapi.com/crm/v3/objects/contacts \
  -H "Authorization: Bearer VOTRE_TOKEN_HUBSPOT" \
  -H "Content-Type: application/json" \
  -d '{
    "properties": {
      "firstname": "Julien",
      "lastname": "Martin",
      "email": "julien.martin@dataflow.io",
      "jobtitle": "CEO",
      "hs_linkedinid": "https://linkedin.com/in/julienmartin"
    }
  }'

Associer le contact a l’entreprise

Une fois le contact et l’entreprise créés, associez-les :

curl -X PUT https://api.hubapi.com/crm/v3/objects/contacts/CONTACT_ID/associations/companies/COMPANY_ID/1 \
  -H "Authorization: Bearer VOTRE_TOKEN_HUBSPOT"

Le 1 a la fin de l’URL correspond au type d’association par défaut (contact vers entreprise).

Étape 5 : Créer des événements timeline dans HubSpot

Les événements timeline permettent de tracer chaque signal dans l’historique de l’entreprise ou du contact dans HubSpot. Vos commerciaux voient ainsi l’historique complet des signaux directement sur la fiche CRM.

Créer le modèle d’événement

Commencez par créer un modèle d’événement timeline via l’API HubSpot. Cette opération ne se fait qu’une seule fois :

curl -X POST https://api.hubapi.com/crm/v3/timeline/event-templates \
  -H "Authorization: Bearer VOTRE_TOKEN_HUBSPOT" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Signal Rodz",
    "objectType": "COMPANY",
    "headerTemplate": "Signal Rodz : {{signal_type}}",
    "detailTemplate": "Signal détecté le {{timestamp}}. {{details}}",
    "tokens": [
      {
        "name": "signal_type",
        "label": "Type de signal",
        "type": "string"
      },
      {
        "name": "timestamp",
        "label": "Date de détection",
        "type": "date"
      },
      {
        "name": "details",
        "label": "Détails",
        "type": "string"
      }
    ]
  }'

Notez l’identifiant du modèle retourné dans la réponse. Vous en aurez besoin pour créer les événements.

Créer un événement timeline

Pour chaque signal reçu, créez un événement associé a l’entreprise :

curl -X POST https://api.hubapi.com/crm/v3/timeline/events \
  -H "Authorization: Bearer VOTRE_TOKEN_HUBSPOT" \
  -H "Content-Type: application/json" \
  -d '{
    "eventTemplateId": "VOTRE_TEMPLATE_ID",
    "objectId": "COMPANY_ID",
    "tokens": {
      "signal_type": "Levée de fonds",
      "timestamp": "2026-03-10T09:15:00Z",
      "details": "DataFlow SAS a levé 8 000 000 EUR en Series A auprès de VC Capital et Growth Partners."
    }
  }'

Le résultat : une entrée visible dans la timeline de la fiche entreprise dans HubSpot, avec le type de signal, la date et les détails. Vos commerciaux peuvent ainsi consulter l’historique des signaux sans quitter leur CRM.

Étape 6 : Déclencher des workflows HubSpot a partir des signaux

C’est ici que l’intégration prend toute sa valeur. Une fois les propriétés de signaux renseignées dans HubSpot, vous pouvez créer des workflows automatisés.

Exemple 1 : Notification au commercial lors d’une levée de fonds

Créez un workflow basé sur la propriété entreprise avec ces paramètres :

Déclencheur : la propriété rodz_last_signal_type est définie sur fundraising
Action 1 : Créer une tâche pour le propriétaire du contact avec le titre “Signal Rodz : levée de fonds détectée”
Action 2 : Envoyer une notification interne au commercial assigné
Action 3 : Ajouter l’entreprise a une liste statique “Entreprises en levée de fonds”

Exemple 2 : Séquence d’emails sur un signal de recrutement

Déclencheur : la propriété rodz_last_signal_type est définie sur hiring
Condition : le nombre d’employés est supérieur a 50
Action : Inscrire le contact dans une séquence d’emails personnalisée pour les entreprises en croissance

Exemple 3 : Scoring automatique

Ajoutez des points de scoring en fonction du type de signal :

Levée de fonds : +30 points
Recrutement massif (>5 postes) : +20 points
Changement de dirigeant : +15 points
Déménagement : +10 points

Ce scoring s’ajoute a votre scoring HubSpot existant et permet de prioriser les entreprises les plus susceptibles d’acheter.

Implémentation complète du middleware (Node.js)

Voici le code complet du middleware, rassemblant toutes les fonctions décrites précédemment :

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

app.use(express.json());

const HUBSPOT_TOKEN = process.env.HUBSPOT_TOKEN;
const RODZ_SECRET = process.env.RODZ_WEBHOOK_SECRET;
const TIMELINE_TEMPLATE_ID = process.env.HUBSPOT_TIMELINE_TEMPLATE_ID;

// Vérification HMAC
function verifySignature(req) {
  const signature = req.headers['x-rodz-signature'];
  const computed = crypto.createHmac('sha256', RODZ_SECRET).update(JSON.stringify(req.body)).digest('hex');
  return signature === computed;
}

// Appels HubSpot
async function hubspotRequest(method, endpoint, body) {
  const response = await fetch(`https://api.hubapi.com${endpoint}`, {
    method,
    headers: {
      Authorization: `Bearer ${HUBSPOT_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: body ? JSON.stringify(body) : undefined,
  });

  if (!response.ok) {
    const error = await response.text();
    throw new Error(`HubSpot API error: ${response.status} - ${error}`);
  }

  return response.json();
}

// Recherche et création/mise a jour d'une entreprise
async function upsertHubSpotCompany(companyData, signal) {
  // Recherche par domaine
  const search = await hubspotRequest('POST', '/crm/v3/objects/companies/search', {
    filterGroups: [
      {
        filters: [
          {
            propertyName: 'domain',
            operator: 'EQ',
            value: companyData.domain,
          },
        ],
      },
    ],
  });

  const properties = {
    name: companyData.name,
    domain: companyData.domain,
    industry: companyData.industry,
    city: companyData.location?.city,
    country: companyData.location?.country,
    rodz_last_signal_type: signal.signal_type,
    rodz_last_signal_date: signal.timestamp.split('T')[0],
  };

  // Ajouter les métadonnées spécifiques au type de signal
  if (signal.signal_type === 'fundraising' && signal.metadata?.amount) {
    properties.rodz_fundraising_amount = String(signal.metadata.amount);
  }

  if (search.total > 0) {
    const companyId = search.results[0].id;
    await hubspotRequest('PATCH', `/crm/v3/objects/companies/${companyId}`, { properties });
    return { id: companyId, created: false };
  }

  // Création
  if (companyData.siren) {
    properties.rodz_siren = companyData.siren;
  }
  const created = await hubspotRequest('POST', '/crm/v3/objects/companies', { properties });
  return { id: created.id, created: true };
}

// Recherche et création/mise a jour d'un contact
async function upsertHubSpotContact(contactData, companyId) {
  const search = await hubspotRequest('POST', '/crm/v3/objects/contacts/search', {
    filterGroups: [
      {
        filters: [
          {
            propertyName: 'email',
            operator: 'EQ',
            value: contactData.email,
          },
        ],
      },
    ],
  });

  const properties = {
    firstname: contactData.first_name,
    lastname: contactData.last_name,
    email: contactData.email,
    jobtitle: contactData.title,
  };

  if (contactData.linkedin_url) {
    properties.hs_linkedinid = contactData.linkedin_url;
  }

  let contactId;
  if (search.total > 0) {
    contactId = search.results[0].id;
    await hubspotRequest('PATCH', `/crm/v3/objects/contacts/${contactId}`, { properties });
  } else {
    const created = await hubspotRequest('POST', '/crm/v3/objects/contacts', { properties });
    contactId = created.id;
  }

  // Association contact → entreprise
  await hubspotRequest('PUT', `/crm/v3/objects/contacts/${contactId}/associations/companies/${companyId}/1`, null);

  return { id: contactId };
}

// Création d'un événement timeline
async function createTimelineEvent(signal, companyId) {
  const signalLabels = {
    fundraising: 'Levée de fonds',
    hiring: 'Recrutement',
    relocation: 'Déménagement',
    leadership_change: 'Changement de dirigeant',
    tender: 'Appel d offres',
  };

  let details = `Signal détecté pour ${signal.company.name}.`;
  if (signal.signal_type === 'fundraising' && signal.metadata) {
    details = `${signal.company.name} a levé ${signal.metadata.amount.toLocaleString('fr-FR')} ${signal.metadata.currency} en ${signal.metadata.round}.`;
  }

  await hubspotRequest('POST', '/crm/v3/timeline/events', {
    eventTemplateId: TIMELINE_TEMPLATE_ID,
    objectId: companyId,
    tokens: {
      signal_type: signalLabels[signal.signal_type] || signal.signal_type,
      timestamp: signal.timestamp,
      details,
    },
  });
}

// Endpoint principal
app.post('/rodz-to-hubspot', async (req, res) => {
  if (!verifySignature(req)) {
    return res.status(401).json({ error: 'Signature invalide' });
  }

  const signal = req.body;
  console.log(`Signal reçu: ${signal.signal_type} pour ${signal.company.name}`);

  try {
    const company = await upsertHubSpotCompany(signal.company, signal);
    const contact = await upsertHubSpotContact(signal.contact, company.id);
    await createTimelineEvent(signal, company.id);

    console.log(`Traitement terminé. Entreprise: ${company.id}, Contact: ${contact.id}`);
    res.status(200).json({ received: true });
  } catch (error) {
    console.error('Erreur:', error.message);
    res.status(500).json({ error: 'Erreur de traitement' });
  }
});

app.listen(3000, () => {
  console.log('Middleware Rodz → HubSpot actif sur le port 3000');
});

Variables d’environnement

Configurez les variables suivantes avant de lancer le middleware :

export HUBSPOT_TOKEN="pat-na1-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
export RODZ_WEBHOOK_SECRET="votre_secret_hmac_256"
export HUBSPOT_TIMELINE_TEMPLATE_ID="12345"

Bonnes pratiques pour l’intégration

Gestion des erreurs et retries

Votre middleware doit répondre avec un code 200 dans les 10 secondes suivant la réception du webhook. Si le traitement HubSpot échoue, enregistrez le payload en file d’attente (Redis, SQS, ou tout système de queue) et retentez plus tard. Ne bloquez jamais la réponse au webhook.

Déduplication

Utilisez le champ event_id du payload Rodz pour dédupliquer les événements. Stockez les identifiants traités dans une base de données ou un cache, et ignorez les doublons. Les retries de webhook peuvent envoyer le même événement plusieurs fois.

Limites de l’API HubSpot

L’API HubSpot applique des limites de débit (rate limits). Pour les Private Apps, la limite standard est de 100 requêtes par 10 secondes. Si vous recevez beaucoup de signaux simultanément, implémentez un système de batch ou un délai entre les appels.

Surveillance et logs

Loguez chaque signal traité et chaque erreur rencontrée. Mettez en place des alertes (email, Slack) en cas d’échec répété. Surveillez particulièrement les erreurs 429 (rate limit) et 401 (token expiré) de l’API HubSpot.

Questions fréquentes

Ai-je besoin d’un plan HubSpot spécifique pour cette intégration ?

Vous pouvez utiliser l’API HubSpot avec un plan gratuit, mais les propriétés personnalisées et les workflows automatisés nécessitent un plan Pro ou Enterprise. Si vous utilisez un plan gratuit, vous pourrez créer et mettre a jour des contacts et entreprises, mais vous ne pourrez pas déclencher de workflows basés sur les propriétés de signaux.

Puis-je utiliser Make au lieu d’un middleware custom ?

Oui. Make est parfaitement adapté si vous ne souhaitez pas maintenir de code. Le scénario décrit dans ce guide couvre les mêmes fonctionnalités. L’avantage : aucune infrastructure a gérer. L’inconvénient : vous dépendez d’un service tiers, et les scénarios complexes (déduplication avancée, logique métier custom) peuvent devenir difficiles a maintenir.

Comment gérer les signaux pour des entreprises qui n’existent pas encore dans HubSpot ?

Le middleware les crée automatiquement. La logique d’upsert (recherche puis création ou mise a jour) gère les deux cas. Si l’entreprise n’existe pas dans HubSpot, elle est créée avec toutes les données du signal. Si elle existe déja, seules les propriétés liées au signal sont mises a jour.

Les données Rodz écrasent-elles mes données HubSpot existantes ?

Non, pas si vous configurez correctement le mapping. Le middleware ne met a jour que les propriétés personnalisées Rodz (rodz_last_signal_type, rodz_last_signal_date, etc.). Les propriétés HubSpot natives (propriétaire, lifecycle stage, pipeline) ne sont pas modifiées. Si vous souhaitez mettre a jour des propriétés comme le secteur d’activité ou la ville, ajustez le mapping en conséquence.

Comment tester l’intégration avant de la mettre en production ?

Utilisez l’événement de test de l’API Rodz (POST /webhooks/{id}/test) pour envoyer un payload fictif a votre middleware. Vérifiez que l’entreprise et le contact sont bien créés dans HubSpot. Pour les tests locaux, utilisez ngrok pour exposer votre endpoint en HTTPS. Créez également un portail HubSpot de test (sandbox) pour éviter de polluer vos données de production.

Quelle est la latence entre la détection d’un signal et son apparition dans HubSpot ?

En conditions normales, le signal apparaît dans HubSpot quelques secondes après sa détection par Rodz. Le webhook est envoyé quasi instantanément, et les appels API HubSpot prennent généralement moins d’une seconde. Le délai total est de l’ordre de 2 a 5 secondes. Si vous utilisez Make, ajoutez 1 a 2 secondes supplémentaires pour le traitement du scénario.

Puis-je filtrer les signaux avant de les envoyer a HubSpot ?

Oui, a deux niveaux. Premièrement, au niveau du webhook Rodz : configurez les types de signaux que vous souhaitez recevoir via le paramètre events. Deuxièmement, au niveau du middleware : ajoutez une logique de filtrage basée sur le type de signal, la taille de l’entreprise, le secteur d’activité, ou tout autre critère. Seuls les signaux qui passent le filtre sont envoyés a HubSpot.

Puis-je bénéficier d’un accompagnement pour cette intégration ?

Absolument. Si vous souhaitez être accompagné dans la mise en place de cette intégration, contactez Rodz pour un accompagnement personnalisé. L’équipe peut vous aider a configurer les webhooks, le middleware et les workflows HubSpot adaptés a votre processus commercial. Rendez-vous sur la documentation de l’API pour commencer, ou contactez directement l’équipe Rodz.