HubSpot + IA Apresentação: Guia de Automação de Sales Decks (2026)

Para equipes de vendas no HubSpot em 2026, o ROI da automação de sales decks por conta é mensurável: economia média de tempo de 2–4 horas por semana por AE, um aumento de 12–18% na progressão entre reuniões, e uma redução de 30-60% na variação de preparação de decks em toda a equipe. O fluxo de trabalho HubSpot + 2Slides de 2026 gera um sales deck totalmente personalizado para qualquer conta usando dados já existentes no HubSpot (empresa, estágio do negócio, interesse em produtos, contato do champion, alternativas competitivas) através de três caminhos de integração: Fluxo de Trabalho HubSpot → Webhook → API 2Slides; HubSpot App Card personalizado com botão Gerar Deck; lote agendado diariamente para todos os negócios em um estágio específico. Este guia inclui o payload exato do webhook, o template de prompt que transforma campos do HubSpot em conteúdo de deck, e o fluxo da API 2Slides (generate → jobs/:id → download) usado por equipes de RevOps reais em produção hoje.

Se você gerencia operações de receita para uma equipe de vendas no HubSpot, você já conhece o problema: todo AE está pedindo ao marketing ou à capacitação de vendas "apenas um pequeno ajuste" no deck antes da próxima ligação. Multiplique isso por quarenta representantes e trezentos negócios em andamento, e você tem um trabalho em tempo integral colando templates do Google Slides em dados de CRM estilo Salesforce — exceto que você está no HubSpot, que não tem equivalente nativo ao módulo de Geração de Documentos do Salesforce.

Este guia mostra como conectar o HubSpot à API V1 do 2Slides para que qualquer negócio em qualquer estágio possa gerar um sales deck personalizado, consistente com a marca e pronto para o canal — sem um humano tocar em um slide mestre. Os padrões abaixo são usados por equipes de RevOps em empresas de B2B SaaS, cibersegurança e IA empresarial para impulsionar valores médios de contrato de $40K a $400K+.

Por Que Apresentações Geradas pelo HubSpot Vencem

O argumento comercial para automatizar apresentações de vendas a partir do HubSpot vem de três alavancas mensuráveis.

Alavanca 1: Tempo de executivo de contas recuperado. Observação interna entre clientes da 2Slides com implantações de 20+ licenças mostra que executivos de contas gastam 2–4 horas por semana na personalização de apresentações — reescrevendo slides de introdução, atualizando logotipos, colando a fraqueza do concorrente, trocando calculadoras de ROI. Com um custo total de executivo de contas de $160K/ano, isso representa $6.400–$12.800 por executivo por ano em trabalho puro com slides. Para uma equipe de vendas de 40 pessoas, você está olhando para conservadores $256K/ano em capacidade recuperada.

Alavanca 2: Conversão de reunião para reunião. Apresentações geradas a partir de dados ao vivo do CRM — ou seja, a faixa real de receita da empresa, o cargo real do champion, o concorrente realmente listado no registro do negócio — convertem agendamentos de próximas reuniões 12–18% mais do que apresentações de template genérico. A razão é simples: especificidade sinaliza preparação, e preparação sinaliza que um vendedor vale uma segunda reunião.

Alavanca 3: Redução de variância. Seus melhores executivos de contas constroem ótimas apresentações. Seus executivos no quartil inferior constroem apresentações medíocres que vazam pipeline. A automação eleva o nível inferior. Em dados de coorte, equipes de RevOps executando geração de apresentações acionada pelo HubSpot relatam uma redução de 30–60% na variância de qualidade das apresentações medida por pontuações de QA do gerente.

O padrão comum entre as três: a apresentação não é o produto, a preparação é o produto. Automatizar a preparação é o movimento de maior alavancagem que RevOps pode fazer em 2026. Para uma visão mais profunda do lado de enablement, veja nosso guia sobre como criar apresentações de sales enablement com AI.

A Arquitetura HubSpot + 2Slides de 2026

Antes de mergulhar em cada método, aqui está a arquitetura que toda implementação segue:

HubSpot CRM (negócios, empresas, contatos)
        │
        ├── Gatilho (workflow, cartão de app, cron)
        │
        ▼
  Camada de Transformação (função serverless / Zapier / Make)
        │  - Constrói prompt a partir de campos do CRM
        │  - Chama a API V1 do 2Slides
        │
        ▼
  API V1 do 2Slides
        ├── POST /api/v1/slides/generate    (retorna jobId)
        ├── GET  /api/v1/jobs/{id}          (consulta até status = success)
        └── GET  /api/v1/slides/download-slides-pages-voices  (URLs de assets)
        │
        ▼
  Entrega (de volta ao negócio do HubSpot como nota, email para AE, DM no Slack)

A API do 2Slides é stateless por job, assíncrona e medida por créditos. Você autentica com um header de chave API

. Cada geração de deck retorna um imediatamente, e você consulta até que o status transite de → → . Uma vez bem-sucedido, você obtém o PPTX final, PDF ou URLs de assets por página.

Método 1: Workflow do HubSpot → Webhook → API da 2Slides

Este é o caminho de integração mais comum. Um Workflow do HubSpot monitora mudanças de estágio no pipeline de negócios e dispara um webhook para uma função serverless que se comunica com a API da 2Slides.

Passo 1: Criar o Workflow do HubSpot

No HubSpot, vá para Automação → Workflows → Criar workflow → Baseado em negócio. Configure o gatilho de inscrição:

• Filtro:
  Estágio do negócio
  é qualquer um de
  Descoberta Concluída
  ,
  Demo Agendada
  ,
  Proposta Enviada
• Re-inscrição: habilitada na mudança de estágio

Adicione uma ação Enviar webhook:

• Método:
  POST
• URL:
  https://your-revops-fn.vercel.app/api/hubspot/generate-deck
• Inclua grupos de propriedades
  negócio
  ,
  empresa associada
  e
  contato principal

Passo 2: Função Transformadora

Implante isso no Vercel, Cloudflare Workers ou AWS Lambda. A função recebe o webhook do HubSpot, compõe o prompt da 2Slides e inicia a geração.

// /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, // seu tema de marca bloqueado
      metadata: {
        hubspot_deal_id: deal.hs_object_id,
        account: company.name,
      },
    }),
  })

  const { jobId } = await generateRes.json()

  // Persista a associação jobId -> negócio para consulta posterior
  await kv.set(`deal:${deal.hs_object_id}:job`, jobId, { ex: 86400 })

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

Passo 3: Consultar e Entregar

Uma segunda função (chamada por um Cron do Vercel a cada 90 segundos, ou pela re-entrada atrasada do workflow do HubSpot) consulta

e, em caso de sucesso, escreve a URL da apresentação de volta ao negócio como uma nota de engajamento:

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: `Apresentação nova pronta: ${assets.pptx_url}`,
      hs_timestamp: Date.now(),
    },
    associations: [{ to: { id: deal.hs_object_id }, types: [{ category: 'HUBSPOT_DEFINED', typeId: 214 }] }],
  })
}

Este é o mesmo padrão que usamos em nossa automação de relatórios semanais com Zapier — uma chamada de geração, uma consulta, uma entrega — apenas conectado através do HubSpot em vez do Zapier.

Método 2: Cartão de App HubSpot com Botão Gerar Deck

O Método 1 é automático. O Método 2 é sob demanda: o AE abre um negócio no HubSpot, vê um cartão personalizado na barra lateral direita, clica em Gerar Deck e o deck chega na caixa de entrada dele dois minutos depois.

Isso usa uma Extensão de UI do HubSpot (parte da plataforma Developer Projects).

Código da Extensão de UI

// 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>Gere um deck de vendas personalizado para esta conta usando 2Slides.</Text>
      {state === 'idle' && <Button onClick={onClick}>Gerar Deck</Button>}
      {state === 'working' && <LoadingSpinner label="Criando deck (90–120s)" />}
      {state === 'done' && deckUrl && (
        <Alert title="Deck pronto">
          <a href={deckUrl} target="_blank" rel="noreferrer">Abrir deck</a>
        </Alert>
      )}
      {state === 'error' && <Alert variant="danger">Falha na geração — verifique os logs de RevOps.</Alert>}
    </Flex>
  )
}

O Companheiro Serverless

A função serverless referenciada acima (

) vive no mesmo projeto de app HubSpot e chama o mesmo fluxo + do Método 1, mas ela aguarda até que o job seja bem-sucedido (ou expire) antes de retornar a URL do deck para o cartão.

// 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())

  // Fazer polling por até 3 minutos
  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 || 'falha na geração')
  }
  throw new Error('timeout')
}

Esse padrão — objeto CRM → cartão de extensão → chamada API → resultado inline — é a mesma abordagem que equipes de marketing usam quando escalam a produção de conteúdo; veja como equipes de marketing executam decks de apresentação com IA em escala.

Método 3: Geração em Lote Agendada

Nem toda apresentação precisa ser gerada sob demanda. Para revisões previsíveis de pipeline — toda segunda-feira de manhã, toda revisão trimestral de negócios, toda atualização de estágio MEDDPICC — um lote agendado por cron é mais barato e confiável do que webhooks em tempo real.

O Padrão

Execute uma tarefa noturna que consulta o HubSpot para cada negócio em um estágio-alvo, gera uma apresentação atualizada para cada um e envia por email ao AE um resumo matinal.

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

export async function GET(req: Request) {
  // Proteção do Vercel Cron com 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 })
}

Agende no

:

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

Seis da manhã, dias úteis. O AE abre o email e a apresentação está esperando.

O Template de Prompt Que Converte Campos de CRM em Conteúdo de Apresentação

O maior determinante isolado da qualidade da apresentação é o prompt. Bons prompts codificam o que um AE sênior diria a um novo contratado: "quando a empresa é X, com um champion no cargo Y, focado no resultado Z, construa a apresentação assim." Template pronto para copiar:

function buildDeckPrompt({ deal, company, contact }: Ctx) {
  return `
Gere uma apresentação de vendas de 10-12 slides para uma avaliação de software B2B.

CONTEXTO DA CONTA
- Empresa: ${company.name}
- Indústria: ${company.industry ?? 'não especificado'}
- Faixa de receita anual: ${company.annualrevenue ?? 'não especificado'}
- Funcionários: ${company.numberofemployees ?? 'não especificado'}
- Website: ${company.domain}

CONTEXTO DO NEGÓCIO
- Estágio do negócio: ${deal.dealstage}
- Valor do negócio: $${deal.amount}
- Interesse em produto: ${deal.product_interest}
- Caso de uso prioritário: ${deal.primary_use_case}
- Lista de concorrentes: ${deal.competitors /* separados por vírgula */}
- Cronograma de avaliação: ${deal.close_date}

CONTEXTO DO CHAMPION
- Nome: ${contact.firstname} ${contact.lastname}
- Cargo: ${contact.jobtitle}
- Prioridades reportadas: ${contact.priorities}

ESTRUTURA DA APRESENTAÇÃO
1. Slide de título — "${company.name} × <Sua Marca>: ${deal.primary_use_case}"
2. O mundo deles hoje — 3 bullets, específico para ${company.industry}
3. O custo de não fazer nada — quantificar usando faixa de ${company.annualrevenue}
4. Nossa abordagem — 3 pilares alinhados a ${deal.primary_use_case}
5. Prova — 2 estudos de caso de ${company.industry} (ou adjacente)
6. Diferenciação vs ${deal.competitors} — veja seção de battlecard abaixo
7. Plano de implementação — 30/60/90 ajustado a ${deal.close_date}
8. Resumo comercial — faixa ancorada em $${deal.amount}
9. Riscos e mitigações
10. Próximos passos — alinhados a ${deal.dealstage}

TOM
- Combinar com audiência: ${contact.jobtitle}
- Formal se o cargo incluir VP, SVP, Chief, Diretor; conversacional caso contrário.
- Todo slide: uma ideia, um gráfico ou uma citação destacada, sem paredes de texto.
  `.trim()
}

Mantenha o template sob controle de versão. Quando o marketing atualizar o framework de mensagens, você altera um arquivo e a próxima execução do cron o adota.

Tratamento de Alternativas Competitivas

O campo

no HubSpot — seja um campo de texto personalizado de linha única, uma caixa de seleção múltipla ou um menu suspenso — é ouro. Injete um bloco de battlecard no prompt condicionalmente:

const BATTLECARDS: Record<string, string> = {
  'Competitor A': `
Competitor A se posiciona em <sua afirmação>.
Contra-argumento: <seu ponto de prova> + <slogan de 3 palavras>.
Pergunta-armadilha para plantar: "Quando foi publicada a última auditoria de segurança deles?"
`,
  'Competitor B': `
Competitor B lidera com <seu ângulo>.
Contra-argumento: <seu contra-argumento> — faça referência ao caso de migração do <nome do cliente>.
Armadilha: "Pergunte sobre os limites por usuário após 500 usuários."
`,
}

function battlecardSection(competitorsCsv: string) {
  const names = competitorsCsv.split(',').map(s => s.trim()).filter(Boolean)
  if (!names.length) return ''
  return `
BATTLECARDS COMPETITIVOS
${names.map(n => BATTLECARDS[n] ?? '').filter(Boolean).join('\n')}
Use isso para preencher o slide de Diferenciação. Nunca mencione o concorrente mais de duas vezes.
  `.trim()
}

Anexe o resultado de

ao seu prompt. O deck agora carrega um enquadramento competitivo de nível AE — o tipo que normalmente requer uma chamada de trinta minutos com o líder de inteligência competitiva.

Armazene battlecards em uma tabela de banco de dados em vez de codificá-los diretamente assim que tiver mais de dez. Seu Head de Product Marketing pode editá-los sem precisar abrir um PR.

Perguntas Frequentes

Como evitar que o HubSpot gere decks duplicados a cada atualização de propriedade?

Adicione uma propriedade chamada

ao objeto deal e inclua um filtro no Workflow do HubSpot: é desconhecido ou mais de 7 dias atrás. Sua função transformer deve escrever esse timestamp de volta ao HubSpot via API de Deal após uma geração bem-sucedida. Isso sozinho evita 90% das chamadas de API desperdiçadas.

Quanto isso custa em créditos do 2Slides?

Cada chamada

debita créditos com base na contagem de slides e quaisquer add-ons (geração de imagens, narração de voz). Para um deck de vendas típico de 10 slides com imagens de marca, considere 20–40 créditos por deck. Uma equipe de RevOps gerando 500 decks por mês fica na faixa de $150–$400 — bem abaixo do custo de trabalho do AE economizado em um único deal enterprise.

Posso gerar o deck em um idioma diferente do inglês?

Sim. Passe

, , , etc. no payload . O template de prompt também deve incluir um preâmbulo localizado quando o registro de contato do seu champion mostrar um idioma preferido diferente do inglês.

Como fixar a identidade visual da marca para que todos os decks fiquem idênticos?

Use um

fixo em cada solicitação de geração. Crie seu tema de marca uma vez na interface do 2Slides, copie seu ID e armazene-o como nas suas variáveis de ambiente. O tema controla fontes, paleta, posicionamento do logotipo e layouts mestres — assim o conteúdo varia por conta enquanto a estrutura visual permanece pixel-idêntica.

E se o job de geração falhar?

Consulte

e inspecione . Em , a resposta contém com um código legível por máquina. Tente novamente uma vez com backoff exponencial; se falhar uma segunda vez, poste um alerta no Slack para o canal de RevOps e use como fallback um deck de template estático para que o AE não fique bloqueado antes da sua ligação.

A Conclusão

O HubSpot não está tentando ser o Salesforce, e está tudo bem — sua simplicidade é o diferencial. Mas a simplicidade também significa que ele não oferece automação de documentos nativamente. A lacuna é um recurso, não um defeito, porque significa que a equipe de RevOps que conecta o HubSpot a uma API de apresentações com IA controla a área de superfície mais valiosa em sua pilha de tecnologia de vendas: o deck que chega na frente do comprador.

Os três métodos acima — webhook de workflow, botão de cartão de app, lote agendado — cobrem toda a gama de gatilhos de geração que uma equipe de vendas precisa. Escolha aquele que corresponde ao estágio do seu funil. Os estágios de Descoberta e Demonstração quase sempre querem sob demanda (o cartão de app). Os estágios de Proposta e Negociação se beneficiam mais da automação na mudança de estágio (o webhook de workflow). Revisões de pipeline e preparação de QBR são em lote (o cron). Execute os três e cada negócio no pipeline terá um deck atualizado e verdadeiro ao CRM ao alcance das mãos, todos os dias.

Automatize seus decks de vendas a partir do HubSpot — obtenha uma chave de API do 2Slides e conecte-a ao seu próximo workflow em menos de um dia.