HubSpot + IA Présentation : Guide d'automatisation des présentations commerciales (2026)

Pour les équipes commerciales utilisant HubSpot en 2026, le retour sur investissement de l'automatisation des présentations par compte est mesurable : gain de temps moyen de 2 à 4 heures par semaine pour chaque AE, augmentation de 12 à 18 % de la progression entre réunions, et réduction de 30 à 60 % de la variance dans la préparation des présentations au sein de l'équipe. Le workflow HubSpot + 2Slides 2026 génère une présentation commerciale entièrement personnalisée pour n'importe quel compte en utilisant les données déjà présentes dans HubSpot (entreprise, étape de la transaction, intérêt produit, contact champion, alternatives concurrentes) via trois chemins d'intégration : Workflow HubSpot → Webhook → API 2Slides ; carte d'application HubSpot personnalisée avec bouton Générer présentation ; traitement par lot quotidien programmé pour toutes les transactions à une étape spécifique. Ce guide inclut la charge utile webhook exacte, le modèle de prompt qui transforme les champs HubSpot en contenu de présentation, et le flux API 2Slides (generate → jobs/:id → download) utilisé par de vraies équipes RevOps en production aujourd'hui.

Si vous gérez les opérations commerciales pour une équipe sur HubSpot, vous connaissez déjà le problème : chaque AE demande au marketing ou au service d'activation commerciale « juste une petite modification » de la présentation avant leur prochain appel. Multipliez cela par quarante commerciaux et trois cents transactions en cours, et vous obtenez un poste à temps plein à coller des modèles Google Slides aux données CRM de type Salesforce — sauf que vous êtes sur HubSpot, qui n'a pas d'équivalent natif du module Document Generation de Salesforce.

Ce guide vous montre comment connecter HubSpot à l'API V1 de 2Slides afin que n'importe quelle transaction à n'importe quelle étape puisse générer une présentation commerciale personnalisée, cohérente avec la marque et prête pour le canal — sans qu'un humain ne touche à un masque de diapositive. Les schémas ci-dessous sont utilisés par les équipes RevOps dans le SaaS B2B, la cybersécurité et les entreprises d'IA d'entreprise pour générer des valeurs de contrat moyennes de 40 000 $ à plus de 400 000 $.

Pourquoi les présentations pilotées par HubSpot gagnent

L'argument commercial en faveur de l'automatisation des présentations commerciales à partir de HubSpot repose sur trois leviers mesurables.

Levier 1 : Temps récupéré pour les commerciaux. L'observation interne auprès des clients 2Slides avec des déploiements de 20+ sièges montre que les account executives consacrent 2 à 4 heures par semaine à la personnalisation des présentations — réécriture des slides d'introduction, mise à jour des logos, insertion des faiblesses du concurrent, remplacement des calculateurs de ROI. Avec un coût total chargé de 160 000 $/an par commercial, cela représente 6 400 à 12 800 $ par commercial et par an en pur travail de slides. Pour une équipe commerciale de 40 personnes, vous envisagez une capacité récupérée conservatrice de 256 000 $/an.

Levier 2 : Conversion d'un rendez-vous à l'autre. Les présentations générées à partir de données CRM en temps réel — c'est-à-dire la tranche de revenu réelle de l'entreprise, le titre réel du sponsor, le concurrent réellement listé dans l'enregistrement de l'opportunité — convertissent les prises de rendez-vous suivants de 12 à 18 % de plus que les présentations modèles génériques. La raison est simple : la spécificité signale la préparation, et la préparation signale qu'un commercial mérite un second rendez-vous.

Levier 3 : Réduction de la variance. Vos commerciaux du quartile supérieur créent d'excellentes présentations. Votre quartile inférieur crée des présentations médiocres qui font fuir les opportunités. L'automatisation tire le bas vers le haut. Dans les données de cohorte, les équipes RevOps utilisant la génération de présentations déclenchée par HubSpot signalent une réduction de 30 à 60 % de la variance de qualité des présentations, mesurée par les scores d'assurance qualité des managers.

Le schéma commun aux trois : la présentation n'est pas le produit, la préparation est le produit. Automatiser la préparation est l'action à plus fort effet de levier que les RevOps peuvent entreprendre en 2026. Pour un examen approfondi du côté enablement, consultez notre guide sur comment créer des présentations d'aide à la vente avec l'IA.

L'Architecture HubSpot + 2Slides 2026

Avant de plonger dans chaque méthode, voici l'architecture que suit chaque implémentation :

HubSpot CRM (deals, companies, contacts)
        │
        ├── Trigger (workflow, app card, cron)
        │
        ▼
  Couche de Transformation (serverless fn / Zapier / Make)
        │  - Construit le prompt depuis les champs CRM
        │  - Appelle l'API V1 de 2Slides
        │
        ▼
  API V1 2Slides
        ├── POST /api/v1/slides/generate    (retourne jobId)
        ├── GET  /api/v1/jobs/{id}          (polling jusqu'à status = success)
        └── GET  /api/v1/slides/download-slides-pages-voices  (URLs des assets)
        │
        ▼
  Livraison (retour dans HubSpot deal comme note, email au AE, Slack DM)

L'API 2Slides est sans état par job, asynchrone et facturée en crédits. Vous vous authentifiez avec un en-tête de clé API

x-api-key: sk-2slides-...

. Chaque génération de deck retourne un

jobId

immédiatement, et vous interrogez

/api/v1/jobs/{id}

jusqu'à ce que le statut passe de

pending

→

processing

→

success

. Une fois terminé avec succès, vous récupérez le PPTX final, le PDF ou les URLs des assets par page.

Méthode 1 : Workflow HubSpot → Webhook → API 2Slides

Il s'agit du parcours d'intégration le plus courant. Un Workflow HubSpot surveille un changement d'étape dans le pipeline d'affaires et déclenche un webhook vers une fonction serverless qui communique avec l'API 2Slides.

Étape 1 : Créer le Workflow HubSpot

Dans HubSpot, allez dans Automation → Workflows → Créer un workflow → Basé sur les affaires. Configurez le déclencheur d'inscription :

Filtre :
Étape de l'affaire
correspond à
Découverte terminée
,
Démo planifiée
,
Proposition envoyée
Réinscription : activée lors du changement d'étape

Ajoutez une action Envoyer un webhook :

Méthode :
POST
URL :
https://your-revops-fn.vercel.app/api/hubspot/generate-deck
Inclure les groupes de propriétés
affaire
,
entreprise associée
et
contact principal

Étape 2 : Fonction de Transformation

Déployez ceci sur Vercel, Cloudflare Workers ou AWS Lambda. La fonction reçoit le webhook HubSpot, compose le prompt 2Slides et lance la génération.

// /api/hubspot/generate-deck.ts
export async function POST(req: Request) {
  const payload = await req.json()
  const deal = payload.properties
  const company = payload.associations?.company?.properties ?? {}
  const contact = payload.associations?.contact?.properties ?? {}

  const prompt = buildDeckPrompt({ deal, company, contact })

  const generateRes = await fetch('https://2slides.com/api/v1/slides/generate', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': process.env.TWOSLIDES_API_KEY!,
    },
    body: JSON.stringify({
      prompt,
      slide_count: 12,
      language: 'en',
      aspect_ratio: '16:9',
      theme_id: process.env.BRAND_THEME_ID, // votre thème de marque verrouillé
      metadata: {
        hubspot_deal_id: deal.hs_object_id,
        account: company.name,
      },
    }),
  })

  const { jobId } = await generateRes.json()

  // Persister l'association jobId -> affaire pour consultation ultérieure
  await kv.set(`deal:${deal.hs_object_id}:job`, jobId, { ex: 86400 })

  return Response.json({ ok: true, jobId })
}

Étape 3 : Interroger et Livrer

Une seconde fonction (appelée par un Cron Vercel toutes les 90 secondes, ou par la réentrée différée du workflow HubSpot) interroge

/api/v1/jobs/{id}

et, en cas de succès, écrit l'URL de la présentation dans l'affaire sous forme de note d'engagement :

const jobRes = await fetch(`https://2slides.com/api/v1/jobs/${jobId}`, {
  headers: { 'x-api-key': process.env.TWOSLIDES_API_KEY! },
})
const job = await jobRes.json()

if (job.status === 'success') {
  const assets = await fetch(
    `https://2slides.com/api/v1/slides/download-slides-pages-voices?jobId=${jobId}`,
    { headers: { 'x-api-key': process.env.TWOSLIDES_API_KEY! } }
  ).then(r => r.json())

  await hubspotClient.crm.objects.notes.basicApi.create({
    properties: {
      hs_note_body: `Nouvelle présentation prête : ${assets.pptx_url}`,
      hs_timestamp: Date.now(),
    },
    associations: [{ to: { id: deal.hs_object_id }, types: [{ category: 'HUBSPOT_DEFINED', typeId: 214 }] }],
  })
}

C'est le même modèle que nous utilisons dans notre automatisation de rapports hebdomadaires avec Zapier — un appel de génération, une interrogation, une livraison — simplement connecté via HubSpot au lieu de Zapier.

Méthode 2 : Carte d'application HubSpot avec bouton de génération de deck

La méthode 1 est automatique. La méthode 2 fonctionne à la demande : l'AE ouvre une transaction dans HubSpot, voit une carte personnalisée dans la barre latérale droite, clique sur Générer un deck, et le deck arrive dans sa boîte de réception deux minutes plus tard.

Cette méthode utilise une UI Extension HubSpot (qui fait partie de la plateforme Developer Projects).

Code de l'UI Extension

// src/app/extensions/DealDeckCard.tsx
import {
  hubspot,
  Button,
  Flex,
  Text,
  Alert,
  LoadingSpinner,
} from '@hubspot/ui-extensions'
import { useState } from 'react'

hubspot.extend(({ context, runServerlessFunction }) => (
  <DeckCard context={context} runServerless={runServerlessFunction} />
))

function DeckCard({ context, runServerless }) {
  const [state, setState] = useState<'idle' | 'working' | 'done' | 'error'>('idle')
  const [deckUrl, setDeckUrl] = useState<string | null>(null)

  async function onClick() {
    setState('working')
    const { response } = await runServerless({
      name: 'generateDeck',
      parameters: { dealId: context.crm.objectId },
    })
    if (response.deckUrl) {
      setDeckUrl(response.deckUrl)
      setState('done')
    } else {
      setState('error')
    }
  }

  return (
    <Flex direction="column" gap="sm">
      <Text>Générez un deck de vente personnalisé pour ce compte en utilisant 2Slides.</Text>
      {state === 'idle' && <Button onClick={onClick}>Générer un deck</Button>}
      {state === 'working' && <LoadingSpinner label="Création du deck (90–120s)" />}
      {state === 'done' && deckUrl && (
        <Alert title="Deck prêt">
          <a href={deckUrl} target="_blank" rel="noreferrer">Ouvrir le deck</a>
        </Alert>
      )}
      {state === 'error' && <Alert variant="danger">Échec de la génération — vérifiez les logs RevOps.</Alert>}
    </Flex>
  )
}

La fonction serverless associée

La fonction serverless référencée ci-dessus (

generateDeck

) se trouve dans le même projet d'application HubSpot et appelle le même flux

/api/v1/slides/generate

/api/v1/jobs/{id}

que la méthode 1, mais elle se bloque jusqu'à ce que la tâche réussisse (ou expire) avant de renvoyer l'URL du deck à la carte.

// src/app/app.functions/generateDeck.js
exports.main = async (context) => {
  const { dealId } = context.parameters
  const deal = await hubspotFetchDeal(dealId)
  const prompt = buildDeckPrompt(deal)

  const gen = await fetch('https://2slides.com/api/v1/slides/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'x-api-key': process.env.TWOSLIDES_API_KEY },
    body: JSON.stringify({ prompt, slide_count: 12, theme_id: process.env.BRAND_THEME_ID }),
  }).then(r => r.json())

  // Interroger jusqu'à 3 minutes
  for (let i = 0; i < 36; i++) {
    await new Promise(r => setTimeout(r, 5000))
    const job = await fetch(`https://2slides.com/api/v1/jobs/${gen.jobId}`, {
      headers: { 'x-api-key': process.env.TWOSLIDES_API_KEY },
    }).then(r => r.json())
    if (job.status === 'success') {
      return { deckUrl: job.result?.pptx_url }
    }
    if (job.status === 'failed') throw new Error(job.error || 'generation failed')
  }
  throw new Error('timeout')
}

Ce modèle — objet CRM → carte d'extension → appel API → résultat en ligne — est la même approche que les équipes marketing utilisent lorsqu'elles augmentent leur production de contenu ; consultez comment les équipes marketing créent des présentations AI à grande échelle.

Méthode 3 : Génération par lots planifiée

Toutes les présentations n'ont pas besoin d'être générées à la demande. Pour les revues de pipeline prévisibles — chaque lundi matin, chaque revue trimestrielle, chaque actualisation d'étape MEDDPICC — un traitement par lots planifié par cron est moins coûteux et plus fiable que les webhooks en temps réel.

Le modèle

Exécutez une tâche nocturne qui interroge HubSpot pour chaque affaire dans une étape cible, génère une présentation actualisée pour chacune et envoie par e-mail un récapitulatif matinal à l'AE.

// /api/cron/nightly-deck-refresh.ts
export const runtime = 'nodejs'
export const maxDuration = 300

export async function GET(req: Request) {
  // Protection Vercel Cron avec CRON_SECRET
  if (req.headers.get('authorization') !== `Bearer ${process.env.CRON_SECRET}`) {
    return new Response('Unauthorized', { status: 401 })
  }

  const deals = await hubspotClient.crm.deals.searchApi.doSearch({
    filterGroups: [{
      filters: [
        { propertyName: 'dealstage', operator: 'EQ', value: 'proposal_sent' },
        { propertyName: 'hs_lastmodifieddate', operator: 'GT', value: String(Date.now() - 86400000) },
      ],
    }],
    properties: ['dealname', 'amount', 'competitor', 'product_interest', 'champion_title'],
    limit: 100,
  })

  const jobs = await Promise.all(deals.results.map(async (deal) => {
    const prompt = buildDeckPrompt(deal)
    const res = await fetch('https://2slides.com/api/v1/slides/generate', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'x-api-key': process.env.TWOSLIDES_API_KEY! },
      body: JSON.stringify({ prompt, slide_count: 10, theme_id: process.env.BRAND_THEME_ID }),
    }).then(r => r.json())
    return { dealId: deal.id, jobId: res.jobId, owner: deal.properties.hubspot_owner_id }
  }))

  await enqueueDeliveryJobs(jobs) // SQS / Upstash QStash / Trigger.dev
  return Response.json({ enqueued: jobs.length })
}

Planification dans

vercel.json

{
  "crons": [
    { "path": "/api/cron/nightly-deck-refresh", "schedule": "0 6 * * 1-5" }
  ]
}

Six heures du matin, en semaine. L'AE ouvre son e-mail, la présentation l'attend.

Le Modèle de Prompt Qui Convertit les Champs CRM en Contenu de Présentation

Le facteur le plus déterminant de la qualité d'une présentation est le prompt. Les bons prompts encodent ce qu'un AE senior dirait à une nouvelle recrue : "quand l'entreprise est X, avec un champion dans le rôle Y, concentré sur le résultat Z, construis la présentation comme ceci." Modèle prêt à coller :

function buildDeckPrompt({ deal, company, contact }: Ctx) {
  return `
Générer une présentation commerciale de 10 à 12 slides pour une évaluation de logiciel B2B.

CONTEXTE DU COMPTE
- Entreprise : ${company.name}
- Secteur : ${company.industry ?? 'non spécifié'}
- Tranche de chiffre d'affaires annuel : ${company.annualrevenue ?? 'non spécifié'}
- Employés : ${company.numberofemployees ?? 'non spécifié'}
- Site web : ${company.domain}

CONTEXTE DE L'OPPORTUNITÉ
- Étape de l'opportunité : ${deal.dealstage}
- Montant de l'opportunité : $${deal.amount}
- Intérêt produit : ${deal.product_interest}
- Cas d'usage prioritaire : ${deal.primary_use_case}
- Liste restreinte de concurrents : ${deal.competitors /* séparés par des virgules */}
- Calendrier d'évaluation : ${deal.close_date}

CONTEXTE DU CHAMPION
- Nom : ${contact.firstname} ${contact.lastname}
- Titre : ${contact.jobtitle}
- Priorités déclarées : ${contact.priorities}

STRUCTURE DE LA PRÉSENTATION
1. Slide de titre — "${company.name} × <Votre Marque> : ${deal.primary_use_case}"
2. Leur monde aujourd'hui — 3 points, spécifiques à ${company.industry}
3. Le coût de l'inaction — quantifier en utilisant la tranche ${company.annualrevenue}
4. Notre approche — 3 piliers alignés sur ${deal.primary_use_case}
5. Preuves — 2 études de cas du secteur ${company.industry} (ou adjacent)
6. Différenciation vs ${deal.competitors} — voir la section battlecard ci-dessous
7. Plan de mise en œuvre — 30/60/90 adapté à ${deal.close_date}
8. Résumé commercial — fourchette ancrée à $${deal.amount}
9. Risques et mitigations
10. Prochaines étapes — alignées sur ${deal.dealstage}

TON
- Adapter à l'audience : ${contact.jobtitle}
- Formel si le titre inclut VP, SVP, Chief, Director ; conversationnel sinon.
- Chaque slide : une idée, un graphique ou une citation mise en avant, pas de murs de texte.
  `.trim()
}

Conservez le modèle sous contrôle de version. Lorsque le marketing met à jour le framework de messaging, vous modifiez un seul fichier et la prochaine exécution cron le récupère.

Gestion des alternatives concurrentes

Le champ

deal.competitors

dans HubSpot — qu'il s'agisse d'un champ texte personnalisé à ligne unique, de cases à cocher multiples ou d'un menu déroulant — est une mine d'or. Injectez conditionnellement un bloc de battlecard dans le prompt :

const BATTLECARDS: Record<string, string> = {
  'Concurrent A': `
Le Concurrent A se positionne sur <leur argument>.
Contre-argument : <votre élément de preuve> + <slogan en 3 mots>.
Question piège à suggérer : "Quelle est la date de publication de leur dernier audit de sécurité ?"
`,
  'Concurrent B': `
Le Concurrent B met en avant <leur angle>.
Contre-argument : <votre réponse> — référencez le cas de migration de <nom du client>.
Question piège : "Renseignez-vous sur leurs plafonds par utilisateur au-delà de 500 sièges."
`,
}

function battlecardSection(competitorsCsv: string) {
  const names = competitorsCsv.split(',').map(s => s.trim()).filter(Boolean)
  if (!names.length) return ''
  return `
BATTLECARDS CONCURRENTIELLES
${names.map(n => BATTLECARDS[n] ?? '').filter(Boolean).join('\n')}
Utilisez ceci pour alimenter la diapositive Différenciation. Ne citez jamais le concurrent plus de deux fois.
  `.trim()
}

Ajoutez le résultat de

battlecardSection(deal.competitors)

à votre prompt. La présentation intègre désormais un cadrage concurrentiel de niveau AE — le type de contenu qui nécessite normalement un appel de trente minutes avec le responsable de la veille concurrentielle.

Stockez les battlecards dans une table de base de données plutôt que de les coder en dur dès que vous en avez plus d'une dizaine. Votre Head of Product Marketing pourra les modifier sans avoir à soumettre une PR.

Foire aux questions

Comment empêcher HubSpot de générer des présentations en double à chaque mise à jour de propriété ?

Ajoutez une propriété nommée

last_deck_generated_at

à l'objet transaction et incluez un filtre dans le Workflow HubSpot :

last_deck_generated_at

est inconnu ou remonte à plus de 7 jours. Votre fonction de transformation doit renvoyer cet horodatage à HubSpot via l'API Deal après une génération réussie. Cela seul prévient 90 % des appels API inutiles.

Quel est le coût en crédits 2Slides ?

Chaque appel

/api/v1/slides/generate

débite des crédits en fonction du nombre de diapositives et des modules complémentaires (génération d'images, narration vocale). Pour une présentation commerciale type de 10 diapositives avec des visuels de marque, prévoyez 20 à 40 crédits par présentation. Une équipe RevOps générant 500 présentations par mois se situe dans la fourchette de 150 à 400 $ — bien en dessous du temps d'AE économisé sur une seule transaction entreprise.

Puis-je générer la présentation dans une langue autre que l'anglais ?

Oui. Transmettez

language: 'de'

language: 'ja'

language: 'es'

, etc. dans la charge utile

/api/v1/slides/generate

. Le modèle de prompt doit également inclure un préambule localisé lorsque l'enregistrement de contact de votre champion indique une langue préférée autre que l'anglais.

Comment verrouiller l'identité visuelle pour que chaque présentation soit identique ?

Utilisez un

theme_id

verrouillé dans chaque requête de génération. Créez votre thème de marque une fois dans l'interface 2Slides, copiez son ID et stockez-le comme

BRAND_THEME_ID

dans vos variables d'environnement. Le thème contrôle les polices, la palette, le placement du logo et les mises en page principales — ainsi le contenu varie par compte tandis que l'habillage reste pixel par pixel identique.

Que se passe-t-il si la tâche de génération échoue ?

Interrogez

/api/v1/jobs/{id}

et inspectez

status

. En cas de

failed

, la réponse contient

error

avec un code lisible par machine. Réessayez une fois avec un backoff exponentiel ; si cela échoue une seconde fois, postez une alerte Slack sur le canal RevOps et basculez vers une présentation modèle statique afin que l'AE ne soit pas bloqué avant son appel.

À retenir

HubSpot n'essaie pas d'être Salesforce, et c'est très bien ainsi — sa simplicité est sa fonctionnalité. Mais la simplicité signifie également qu'il ne propose pas d'automatisation documentaire native. Ce manque est une fonctionnalité, pas un défaut, car cela signifie que l'équipe RevOps qui connecte HubSpot à une API de présentation IA possède la surface la plus précieuse de sa pile technologique commerciale : le deck qui arrive devant l'acheteur.

Les trois méthodes ci-dessus — webhook de workflow, bouton de carte d'application, lot programmé — couvrent toute la gamme de déclencheurs de génération dont une équipe commerciale a besoin. Choisissez celle qui correspond à votre étape d'entonnoir. Les étapes Découverte et Démo nécessitent presque toujours une génération à la demande (la carte d'application). Les étapes Proposition et Négociation bénéficient le plus de l'automatisation lors du changement d'étape (le webhook de workflow). Les revues de pipeline et la préparation des QBR sont en lot (le cron). Exécutez les trois et chaque affaire du pipeline dispose d'un deck frais et fidèle au CRM à portée de main, chaque jour.

Automatisez vos decks commerciaux depuis HubSpot — obtenez une clé API 2Slides et connectez-la à votre prochain workflow en moins d'un jour.