How to Automate Personalized AI Video Summaries from Slack Channels Using HeyGen and ElevenLabs

The dread is universal. You sign in after a day of focused work—or, heaven forbid, a day off—and see the little red notification on your Slack icon. Inside, the project channel has exploded. There are hundreds of new messages, a dozen sprawling threads, and a palpable sense of urgency. You start scrolling, your eyes glazing over as you try to piece together fragmented conversations, hunt for key decisions, and identify action items that might have your name on them. This isn’t just catching up; it’s digital archaeology. You spend the next hour trying to reconstruct the narrative, all while the fear of missing something critical hangs over you. What if you misinterpret a thread? What if the most important takeaway is buried 80 messages deep in a side conversation?

This phenomenon of “asynchronous overload” is a major tax on productivity in modern workplaces. The very tools designed to facilitate constant communication have created a new problem: communication debt. In fast-moving development, marketing, or support teams, critical context is often lost in the sheer volume of real-time chatter. Manually rereading and summarizing is not just tedious; it’s inefficient and prone to human error. While AI-powered text summarization tools have emerged, they often lack the engagement and nuance of a human debrief. A block of summarized text is still just more text to read.

But what if you could transform that chaotic stream of messages into a concise, engaging, and personalized video briefing? Imagine starting your morning with a two-minute video from a custom AI avatar that breaks down everything you missed: key decisions, new action items, and outstanding questions, all delivered in a natural, human-like voice. This isn’t science fiction. By integrating the power of the Slack API, a Large Language Model (LLM) for intelligent summarization, the hyper-realistic voice synthesis of ElevenLabs, and the cutting-edge AI video generation of HeyGen, you can build a fully automated workflow that delivers exactly this. It’s a solution that elevates summarization from a simple text-based utility to a powerful, high-impact communication experience.

This article will serve as your technical blueprint. We will walk you through, step-by-step, the process of building this powerful automation. You will learn how to architect the system, extract and clean conversations from Slack, use an LLM to generate a cogent summary script, synthesize that script into lifelike audio with ElevenLabs, and generate a final, polished video with a HeyGen avatar. Prepare to move beyond just managing information and start truly mastering it.

The Architectural Blueprint: Connecting Slack, RAG, and AI Media Generation

Before diving into the code, it’s crucial to understand the architecture of our automated summarizer. This system works by creating a data pipeline where conversation transcripts flow from Slack and are progressively transformed into a final video asset. Each component plays a distinct and vital role in this workflow.

Core Components of Our Automated Summarizer

Our system is built on four key pillars:

1. Slack API: This is our data source. We’ll use it to authenticate with our Slack workspace and fetch the message history from a designated channel.
2. Large Language Model (LLM): This is the ‘brain’ of the operation. After retrieving the conversation data, we will feed it to an LLM (like one from OpenAI or Anthropic) to perform the summarization. This leverages the principles of Retrieval-Augmented Generation (RAG) by providing the model with specific, retrieved context (the Slack transcript) to generate a new, concise output (the summary script).
3. ElevenLabs API: This tool transforms our text-based summary script into natural, human-sounding speech. Its ability to produce expressive audio is key to making the final video feel personal and engaging.
4. HeyGen API: This is the final production step. HeyGen takes the audio generated by ElevenLabs and maps it to a digital avatar, creating a video of that avatar speaking the summary.

The Workflow Logic: From Message Scraping to Video Delivery

The entire process can be visualized as a linear sequence of events, typically triggered on a schedule (e.g., once every morning).

1. Trigger: An automated scheduler (like a cron job or a serverless function) initiates the script.
2. Fetch: The script connects to the Slack API and pulls all new messages from a target channel since the last run.
3. Process: The raw message data (in JSON format) is cleaned and formatted into a simple, readable transcript.
4. Summarize: The cleaned transcript is sent to an LLM with a carefully crafted prompt, which instructs it to generate a summary script.
5. Synthesize: The resulting script is passed to the ElevenLabs API, which returns an audio file of the spoken summary.
6. Generate: The audio file is sent to the HeyGen API, which produces the final video of the AI avatar.
7. Deliver: The script posts a link to the finished video back into a Slack channel or sends it as a direct message.

Prerequisites and Setup

To follow this guide, you will need:

• A Slack workspace with administrative permissions to create an app.
• An active account with HeyGen and your API key.
• An active account with ElevenLabs and your API key.
• An API key from an LLM provider (e.g., OpenAI).
• A Python 3.8+ environment with libraries like slack_sdk, openai, requests.
• A platform to host and run your script, such as a local machine for testing or a cloud service like AWS Lambda for production.

Step 1: Extracting and Processing Slack Channel Conversations

The foundation of our system is clean, well-structured data. This begins with correctly accessing and fetching conversations from your Slack workspace. This process involves creating a dedicated Slack app to handle the API communication securely.

Setting Up a Slack App and Obtaining API Credentials

First, navigate to the Slack API website and create a new app from scratch. Give it a name like “Video Summarizer Bot.” Your app needs permission to read channel history. Go to the “OAuth & Permissions” section in the sidebar and add the following Bot Token Scopes:

• channels:history: Allows the app to view messages in public channels it’s a part of.
• chat:write: Allows the app to post messages back into a channel.

After adding these scopes, install the app to your workspace. This will generate a “Bot User OAuth Token” (it starts with xoxb-). This token is your key to interacting with the Slack API, so keep it secure.

Fetching Channel History with the Slack API

With your token ready, you can now write a Python script to fetch messages. The slack_sdk library makes this straightforward. You’ll need to know the ID of the channel you want to summarize. You can find this in the URL of the channel or by right-clicking the channel name and selecting “Copy Link.”

Here is a Python snippet to get you started:

import os
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError

# --- Configuration ---
SLACK_BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN")
SLACK_CHANNEL_ID = "C0XXXXXXXXX" # Your channel ID here

client = WebClient(token=SLACK_BOT_TOKEN)

try:
    # Fetch channel history
    result = client.conversations_history(channel=SLACK_CHANNEL_ID, limit=200)
    messages = result["messages"]
    print(f"{len(messages)} messages found in channel {SLACK_CHANNEL_ID}")

except SlackApiError as e:
    print(f"Error fetching messages: {e.response['error']}")

This script initializes a client with your bot token and uses the conversations_history method to pull the last 200 messages. For a real-world application, you would add logic to fetch messages only within a specific timeframe (e.g., the last 24 hours) using the oldest and latest timestamp parameters.

Cleaning and Structuring the Conversation Data

The API returns a list of messages in JSON format, which includes user IDs, timestamps, and other metadata. To make this useful for an LLM, we need to format it into a human-readable transcript. A good practice is to create a string that includes the user’s name and the message content, ordered chronologically.

# (Continuing from the previous snippet)

def format_messages_for_llm(messages, client):
    transcript = ""
    user_cache = {}

    # Reverse messages to be in chronological order
    for msg in reversed(messages):
        if 'user' in msg and 'text' in msg:
            user_id = msg['user']
            # Cache user info to avoid repeated API calls
            if user_id not in user_cache:
                try:
                    user_info = client.users_info(user=user_id)
                    user_cache[user_id] = user_info['user']['real_name']
                except SlackApiError:
                    user_cache[user_id] = 'Unknown User'

            user_name = user_cache[user_id]
            text = msg['text']
            transcript += f"{user_name}: {text}\n"

    return transcript

cleaned_transcript = format_messages_for_llm(messages, client)
print(cleaned_transcript)

This function iterates through the messages, fetches the real name of the user (and caches it to reduce API calls), and constructs a simple Name: Message format. This clean transcript is the perfect context to feed our LLM.

Step 2: Generating a Coherent Summary with an LLM

With a clean transcript in hand, the next step is to distill it into a concise summary. This is where the power of a Large Language Model comes in. By providing the transcript as context, we can prompt the LLM to act as an intelligent project manager, extracting only the most salient points.

Crafting the Perfect Summarization Prompt

Prompt engineering is key to getting a high-quality output. Simply asking the LLM to “summarize this” will produce generic results. Instead, we need to provide a specific role, context, and format for the desired output. This ensures the summary is structured as a video script, focusing on the information that truly matters.

Here’s an effective prompt template:

You are an expert project manager tasked with creating a daily video briefing. Below is a transcript of conversations from the '#project-falcon' Slack channel over the past 24 hours.

Your task is to generate a concise script for a 1-2 minute video summary. The script must be engaging and easy to understand.

Focus on these key areas:
1.  **Key Decisions Made:** What was agreed upon?
2.  **Action Items:** List all new tasks and who they were assigned to.
3.  **Open Questions & Blockers:** What issues remain unresolved or are preventing progress?

Format the output as a natural-sounding script, ready to be read by a voice actor. Start with a friendly greeting. Do not include any preamble before the script itself.

--- Transcript ---
{cleaned_transcript}
--- End Transcript ---

Script:

Integrating with an LLM via API

Using the openai Python library, you can send this prompt and the transcript to the GPT model. The response will be the summary script we need for the next step.

import openai

# --- Configuration ---
openai.api_key = os.environ.get("OPENAI_API_KEY")

def generate_summary_script(transcript):
    prompt = f"""... (insert prompt template here, with {transcript} replacing placeholder) ..."""

    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "You are an expert project manager creating a video briefing script."},
            {"role": "user", "content": prompt}
        ],
        temperature=0.5,
    )
    return response.choices[0].message.content

summary_script = generate_summary_script(cleaned_transcript)
print(summary_script)

This function packages our request and returns the LLM’s generated script, which is now ready to be brought to life.

Step 3: Bringing the Summary to Life with ElevenLabs and HeyGen

This is where the magic happens. We’ll convert our text script into a professional video presentation using two powerful generative AI media APIs. This step transforms a dry summary into a dynamic and highly engaging piece of content.

Generating Natural-Sounding Audio with the ElevenLabs API

ElevenLabs specializes in creating lifelike, expressive speech from text. You can choose from a library of pre-made voices or even clone your own for a truly personalized touch. For a professional summary, a calm and clear voice works best.

Here’s how to call the ElevenLabs API using Python’s requests library:

import requests

# --- Configuration ---
ELEVENLABS_API_KEY = os.environ.get("ELEVENLABS_API_KEY")
VOICE_ID = "21m00Tcm4TlvDq8ikWAM" # Example: 'Rachel' voice

headers = {
    "Accept": "audio/mpeg",
    "Content-Type": "application/json",
    "xi-api-key": ELEVENLABS_API_KEY
}

data = {
    "text": summary_script,
    "model_id": "eleven_multilingual_v2",
    "voice_settings": {
        "stability": 0.5,
        "similarity_boost": 0.75
    }
}

response = requests.post(f"https://api.elevenlabs.io/v1/text-to-speech/{VOICE_ID}", json=data, headers=headers)

with open('summary_audio.mp3', 'wb') as f:
    f.write(response.content)

print("Audio file 'summary_audio.mp3' created successfully.")

This script sends our summary script to the ElevenLabs text-to-speech endpoint and saves the returned audio as an MP3 file.

Creating a Personalized Video Avatar with the HeyGen API

Finally, we’ll use HeyGen to generate the video. HeyGen allows you to choose a stock avatar or create a custom one. You then provide the audio and instruct the API to create a video of the avatar speaking those words.

While HeyGen’s API offers direct audio file upload, a more streamlined approach is to integrate it directly with ElevenLabs. You can pass your ElevenLabs API key and voice ID to HeyGen, which then handles the audio generation and video creation in a single step.

import requests
import time

# --- Configuration ---
HEYGEN_API_KEY = os.environ.get("HEYGEN_API_KEY")

# 1. Start video generation with ElevenLabs integration
video_payload = {
    "video_inputs": [
        {
            "character": {
                "type": "avatar",
                "avatar_id": "Your-Avatar-ID-Here", # Your chosen avatar ID
            },
            "voice": {
                "type": "eleven_labs",
                "eleven_labs": {
                    "api_key": ELEVENLABS_API_KEY,
                    "voice_id": VOICE_ID,
                    "text": summary_script
                }
            }
        }
    ],
    "test": True, # Set to False for production
    "title": "Daily Slack Summary"
}

headers = {
    "X-Api-Key": HEYGEN_API_KEY,
    "Content-Type": "application/json"
}

response = requests.post("https://api.heygen.com/v2/video/generate", json=video_payload, headers=headers)
video_id = response.json()['data']['video_id']

print(f"Video generation started with ID: {video_id}")

# 2. Poll for video status
video_url = None
while True:
    status_response = requests.get(f"https://api.heygen.com/v1/video_status.get?video_id={video_id}", headers=headers)
    status_data = status_response.json()
    if status_data['data']['status'] == 'completed':
        video_url = status_data['data']['video_url']
        print(f"Video completed! URL: {video_url}")
        break
    elif status_data['data']['status'] == 'failed':
        print("Video generation failed.")
        break
    time.sleep(10)

This two-part script first initiates the video generation process and then periodically checks the status until it’s complete, finally providing the URL to the finished video.

Step 4: Automating and Delivering the Video Summary

With the core logic in place, the final step is to automate the workflow and deliver the summary where it’s most useful—right back in Slack.

Deploying the Workflow on a Schedule

For this automation to be effective, it needs to run without manual intervention. You have several options:

• Serverless Functions: Services like AWS Lambda or Google Cloud Functions are perfect for this. You can package your Python script, upload it, and configure a scheduler (like Amazon EventBridge) to trigger it at a set time, such as 7 AM every weekday.
• GitHub Actions: If your project lives in a GitHub repository, you can use a scheduled workflow (on: schedule:) to run the script directly from the runner environment.
• Cron Job: For a simpler setup on a server you control, a classic cron job can execute your Python script on a recurring schedule.

Delivering the Summary Back to Slack

To complete the loop, we’ll use the Slack chat.postMessage method to share the video summary. You can post it in a dedicated announcements channel (e.g., #daily-briefings) or even send it as a direct message.

# (Assuming `video_url` is available from the HeyGen step)

if video_url:
    try:
        summary_message = f"👋 Good morning! Here's your personalized video summary for the '#project-falcon' channel:\n{video_url}"
        client.chat_postMessage(channel="#daily-briefings", text=summary_message)
        print("Summary video posted to Slack successfully.")
    except SlackApiError as e:
        print(f"Error posting message to Slack: {e.response['error']}")

This final snippet crafts a friendly message containing the video link and posts it to the specified channel, bringing valuable, automated insights directly to your team.

By chaining these powerful APIs together, we’ve built a system that moves far beyond simple text summarization. We have tackled the very real problem of asynchronous overload, not with more text, but with an engaging, automated video briefing system. Instead of facing a daunting wall of unread messages, your team can now start their day with a clear, concise, and personalized update, ensuring everyone stays in the loop without the cognitive drain. This workflow is just one powerful example of how generative AI media can transform routine internal communications. Ready to build even more advanced AI-driven solutions? Explore the creative possibilities with lifelike voice synthesis from ElevenLabs and create your own custom AI avatars with HeyGen. Sign up and start building for free today to revolutionize how your team shares information.