Here’s how to create automated video prospecting messages in HubSpot with HeyGen

Imagine a top-performing sales development representative, let’s call her Sarah. Her pipeline is fueled by personalized outreach. She spends two hours every morning crafting bespoke emails and, more importantly, recording one-to-one video messages for her top prospects. She knows video converts, but the process is a soul-crushing grind. Record, flub a line, re-record, save, upload, find the contact in the CRM, paste the link, write an accompanying note, and hit send. Repeat fifty times. The ROI is there, but it comes at the cost of her time, energy, and ability to handle other high-value tasks, like actually talking to engaged prospects.

This is the prospecting paradox of the modern sales era. Personalization is no longer a luxury; it’s the price of entry into a prospect’s inbox. Generic, templated outreach is routed directly to the trash folder. Yet, true, scalable personalization feels like an operational impossibility. A recent Andreessen Horowitz (a16z) analysis found that while most companies are experimenting with AI, only a mere 9% have managed to deploy it in production-ready applications. The primary hurdles? Reliability, accuracy, and the immense challenge of integrating AI into existing business workflows in a way that delivers tangible value. How can teams like Sarah’s break this barrier and automate the deeply personal without sounding like a robot?

The solution lies not just in AI, but in intelligent orchestration. It’s about creating a smart bridge between the rich, contextual data locked inside your CRM and the powerful generative capabilities of today’s AI platforms. This is where Retrieval-Augmented Generation (RAG) becomes a game-changer for sales and marketing teams. By building a RAG-powered pipeline, you can connect HubSpot’s customer data directly to an AI video generator like HeyGen, transforming static contact properties into dynamic, hyper-personalized video messages created on-demand. This isn’t science fiction; it’s a practical, buildable system that turns a manual, time-intensive task into an automated, scalable engine for growth.

This guide will walk you through the exact architecture and steps required to build this system. We’ll move beyond theoretical concepts and provide a clear, technical blueprint for integrating HubSpot with HeyGen. You’ll learn how to set up the triggers, process the data, and automate the creation and delivery of video messages that feel like they were made one-to-one, by hand, for every single prospect. It’s time to help Sarah—and your entire sales team—get their mornings back.

The Architecture of Hyper-Personalized Prospecting

To build a system that generates video at scale, we first need to understand why traditional automation tools fall short and how a RAG-based approach provides the necessary intelligence. It’s about shifting from static merge fields to a dynamic, context-aware workflow.

Why Standard Automation Falls Short

Basic marketing automation has been around for years. Tools allow you to insert a contact’s {{first_name}} or {{company_name}} into an email template. While better than nothing, this is a shallow form of personalization. It doesn’t adapt the core message, the tone, or the value proposition based on the prospect’s unique attributes, like their industry, job title, or recent interactions with your brand. The result is an email that is technically personalized but feels generic and fails to resonate.

Video adds another layer of complexity. You can’t just ‘merge’ a name into a video file. This is why salespeople like Sarah resort to manual recording, which is fundamentally unscalable.

The RAG-Powered Difference: From Data to Dynamic Video

Our proposed system uses a lightweight RAG-inspired architecture to solve this problem. Here’s the high-level data flow:

1. Trigger: A new lead is added to a specific list in HubSpot (e.g., “MQL – Ready for Video Outreach”). This action fires a webhook.
2. Retrieve & Augment: The webhook sends a payload of data to a serverless function. This function acts as the ‘brain’ of our system. It retrieves prospect data from the webhook (name, company, industry) and can optionally ‘augment’ this by querying other internal sources or pre-defined script libraries.
3. Generate: The function then constructs a precise API call to HeyGen. It sends the retrieved data, instructing HeyGen’s AI to generate a video using a pre-defined template but with dynamic text spoken by an AI avatar. For example: “Hi, {{first_name}}. I saw you work at {{company_name}} in the {{industry}} space and wanted to share how we help…”
4. Deliver: HeyGen processes the request and returns a URL for the finished video. Our serverless function then takes this URL and uses the HubSpot API to push it back into a custom property on the contact’s record. This can then trigger a follow-up action, like notifying the assigned sales rep to send the video.

This workflow transforms your HubSpot CRM from a simple database into the fuel for a hyper-personalization engine.

Sourcing Your Data: The Role of HubSpot CRM

The quality of your output depends entirely on the quality of your input. For this system to be effective, your HubSpot data must be clean, structured, and reliable. Key properties to focus on include:

• First Name: Crucial for the video’s greeting.
• Company Name: For referencing the prospect’s organization.
• Job Title: Allows for role-specific messaging.
• Industry: Enables you to tailor the value proposition to their specific market.

Maintaining data hygiene isn’t just a best practice; it’s a prerequisite for successful automation.

Step-by-Step Guide: Building Your HubSpot-to-HeyGen Pipeline

Now, let’s get to the practical implementation. This guide assumes a basic familiarity with APIs and serverless functions. Don’t worry if you’re not a developer; the steps are broken down so you can work with a technical team member to execute them.

Prerequisites: What You’ll Need

• HubSpot Account: A Professional or Enterprise subscription is required for workflow automation and webhooks.
• HeyGen Account: You will need an account with API access to programmatically generate videos. You can try for free now.
• Serverless Environment: A platform to host our ‘brain’. AWS Lambda, Google Cloud Functions, or Vercel are excellent choices. We’ll use Python in our examples.
• API Keys: You will need API keys for both HubSpot and HeyGen to allow the different systems to communicate.

Step 1: Setting Up Your HeyGen Video Template

Before you can generate a video, you need a template. In your HeyGen account, create a new video with your chosen AI avatar. Write a script, but mark the parts you want to be dynamic. For instance, in the script editor, you can define variables like {{name}} and {{company}}.

Once you have your template, locate its template_id. You will need this for the API call.

Step 2: Configuring the HubSpot Webhook Trigger

In your HubSpot portal:

1. Navigate to Automation > Workflows and create a new contact-based workflow.
2. Set the enrollment trigger. For example, “Contact property: Lifecycle stage is Marketing Qualified Lead” and “List membership: Contact is a member of ‘Video Outreach List’.”
3. Add a new action and select “Send a webhook.”
4. You’ll need to provide the URL for your serverless function (which we’ll create in the next step). For now, you can use a service like webhook.site to get a temporary URL to inspect the data HubSpot sends.
5. Customize the properties sent in the webhook. Ensure you include First Name, Company Name, Industry, and any other data points you need for personalization.

Step 3: The RAG Core: The Serverless Function (with Code Snippets)

This is where the magic happens. We’ll create a simple Python function using the Flask framework that can be deployed on any serverless platform.

from flask import Flask, request, jsonify
import requests
import os

app = Flask(__name__)

HUBSPOT_API_KEY = os.environ.get('HUBSPOT_API_KEY')
HEYGEN_API_KEY = os.environ.get('HEYGEN_API_KEY')
HEYGEN_TEMPLATE_ID = 'YOUR_TEMPLATE_ID_HERE'

@app.route('/create-video', methods=['POST'])
def create_video():
    # 1. Receive data from HubSpot Webhook
    prospect_data = request.json
    first_name = prospect_data.get('firstname')
    company_name = prospect_data.get('company')
    prospect_vid = prospect_data.get('vid') # HubSpot Contact ID

    if not all([first_name, company_name, prospect_vid]):
        return jsonify({'error': 'Missing required data'}), 400

    # 2. Construct and send request to HeyGen API
    heygen_url = "https://api.heygen.com/v2/video/generate"
    headers = {
        "X-Api-Key": HEYGEN_API_KEY,
        "Content-Type": "application/json"
    }
    payload = {
        "video_inputs": [
            {
                "character": {
                    "character_id": "YOUR_AVATAR_ID_HERE",
                    "voice": {
                        "voice_id": "YOUR_VOICE_ID_HERE"
                    }
                },
                "video_background": {
                     "type": "color",
                     "value": "#ffffff"
                },
                 "script": {
                    "type": "text",
                    "input_text": f"Hi {first_name}! I noticed you work at {company_name}. I wanted to share a quick idea..."
                 }
            }
        ],
        "test": False
    }

    response = requests.post(heygen_url, json=payload, headers=headers)
    if response.status_code != 200:
        return jsonify({'error': 'Failed to generate video'}), 500

    video_id = response.json().get('data', {}).get('video_id')

    # WARNING: In production, you would need a mechanism to check 
    # when the video is ready, as generation is not instantaneous.
    # This often involves polling a status endpoint.
    # For simplicity, we assume we get a video URL back. A placeholder:
    video_url = f"https://videos.heygen.com/{video_id}.mp4"

    # 3. Push the video URL back to HubSpot
    hubspot_update_url = f"https://api.hubapi.com/crm/v3/objects/contacts/{prospect_vid}"
    hubspot_headers = {
        'Authorization': f'Bearer {HUBSPOT_API_KEY}',
        'Content-Type': 'application/json'
    }
    hubspot_payload = {
        "properties": {
            "personalized_video_url": video_url
        }
    }
    requests.patch(hubspot_update_url, json=hubspot_payload, headers=hubspot_headers)

    return jsonify({'status': 'success', 'video_url': video_url}), 200

if __name__ == '__main__':
    app.run(debug=True)

Note: This code is a simplified example. A production system would require more robust error handling and a method to poll for video generation status.

Step 4: Pushing the Video Back to HubSpot

As seen in the code above, the final step for our function is to use the HubSpot API to update the contact record. You must first create a custom property in HubSpot (e.g., a text field named “Personalized Video URL”) to store the link to the generated video.

Once the property is updated, you can create another step in your HubSpot workflow to notify the contact owner that a new video is ready for them to review and send.

Beyond the Basics: Advanced Personalization Tactics

Once you have the basic pipeline running, you can add more layers of sophistication to make your outreach even more effective.

Dynamic Scripts Based on Industry

Instead of a single hardcoded script, your serverless function can act like a true RAG system. It can retrieve different script templates based on the prospect’s industry. If the industry property from HubSpot is “Manufacturing,” it pulls a script focusing on supply chain solutions. If it’s “SaaS,” it pulls a script about customer retention.

Leveraging Multimodality: Using a Prospect’s Company Logo

Many modern video APIs, including HeyGen’s, allow for image overlays. You could use an API like Clearbit to fetch the prospect’s company logo and dynamically insert it into the video background, creating an incredible level of personalization that is impossible to replicate manually at scale.

Measuring Success: Tracking Engagement in HubSpot

Ensure the video link you send is a trackable HubSpot link. This allows you to monitor who is clicking and watching your videos. You can then create new workflows to automatically follow up with engaged prospects or alert sales reps to a hot lead, closing the loop and proving the ROI of your automated system.

This closed-loop system finally solves the prospecting paradox. Scalable, hyper-personalized outreach is no longer a contradiction in terms. By intelligently connecting the data you already have in HubSpot with the generative power of HeyGen, you can build a prospecting machine that works 24/7, freeing up your team to do what they do best: building relationships and closing deals.

Remember Sarah, our SDR who spent her mornings in a repetitive recording cycle? She now comes in to a list of engaged prospects who have already received and watched a video tailored just for them. Her job has shifted from manual labor to strategic engagement. That is the transformative potential of integrating enterprise-grade RAG with your sales stack. The tools and the blueprint are here. The first step is getting your AI video generation platform set up. To get started, we recommend HeyGen for its robust API and high-quality avatars. You can try for free now.