Convert Blog Post content to LinkedIn Carousel PDF

Hey team, Darian here. Let’s talk about efficiency. We all spend a lot of time writing detailed, high-value blog posts. But once they’re published, what’s the next step? For a long time, my process was to manually copy-paste snippets into a design tool to create a LinkedIn carousel. I was easily losing an hour or two a week on this repetitive task. That’s a waste of an engineer’s time.

So, I built a simple Python script to automate it. It scrapes the blog post, chunks the content into slides, designs them, and spits out a ready-to-upload PDF. This isn’t just about saving time; it’s about maximizing the impact of the content we work so hard to create. Let me walk you through how to set it up.

Prerequisites

• Python 3.9 or newer.
• A good code editor (I’m a VS Code fan, but you do you).
• The URL of a blog post you want to convert.
• The following Python libraries: requests, beautifulsoup4, and Pillow.

The Guide: Step-by-Step

Step 1: Setting Up Your Project

First things first, get your project folder organized. I’ll skip the standard virtual environment setup since you likely have your own workflow for that. The key is to make sure you install the necessary libraries for your project. You can do this with pip, for example: `pip install requests beautifulsoup4 Pillow`.

I also like to create an `output` directory to store the generated PDF and an `assets` folder for things like fonts or a logo watermark.

Step 2: Fetch and Parse the Blog Content

The first part of our script needs to act like a browser. It will fetch the blog post’s HTML and then parse it to find the actual article content, ignoring headers, footers, and sidebars.

We’ll use `requests` to get the page and `BeautifulSoup` to make sense of the HTML. The trickiest part is identifying the unique CSS selector for the main content block.

import requests
from bs4 import BeautifulSoup

def get_blog_content(url):
    """Fetches and extracts the main text content from a blog post."""
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()  # This will raise an HTTPError for bad responses (4xx or 5xx)

        soup = BeautifulSoup(response.content, 'html.parser')

        # This is the part you'll need to customize.
        # Use your browser's "Inspect" tool to find the right tag and class/id.
        content_div = soup.find('article', class_='blog-content') 
        
        if not content_div:
            print("Error: Could not find the main content container.")
            return None

        # Get all text, separating paragraphs with a newline
        paragraphs = [p.get_text() for p in content_div.find_all(['p', 'h2', 'h3', 'li'])]
        return '\n'.join(paragraphs)

    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")
        return None

# Example usage:
# BLOG_URL = "https://your-company-blog.com/your-awesome-post"
# article_text = get_blog_content(BLOG_URL)
# if article_text:
#     print("Successfully fetched content!")

Pro Tip: Every website is different. Open your target blog post in Chrome or Firefox, right-click on the main text, and select “Inspect.” Look for a containing element like `<article>` or `<div id=”main-content”>` that wraps all the text you want. This will give you the selector you need for the `soup.find()` method.

Step 3: Chunk Content into Carousel Slides

A good carousel slide is short and to the point. We can’t just dump the whole blog post onto one page. This function takes our extracted text and splits it into smaller, digestible chunks suitable for a single slide.

My approach is to split by newlines (paragraphs) and then group them together without exceeding a character limit per slide. This keeps thoughts together.

def chunk_text_for_slides(text, max_chars_per_slide=300):
    """Splits a large block of text into smaller chunks for slides."""
    slides = []
    current_slide = ""
    
    # Split the text into paragraphs
    paragraphs = text.split('\n')
    
    for p in paragraphs:
        p = p.strip()
        if not p:
            continue
            
        if len(current_slide) + len(p) + 1 <= max_chars_per_slide:
            current_slide += p + "\n\n"
        else:
            if current_slide:
                slides.append(current_slide.strip())
            current_slide = p + "\n\n"
            
    # Add the last remaining slide
    if current_slide:
        slides.append(current_slide.strip())
        
    return slides

# Example usage:
# text_chunks = chunk_text_for_slides(article_text)
# print(f"Split content into {len(text_chunks)} slides.")

Step 4: Generate an Image for Each Slide

Now for the fun part. We’ll use the `Pillow` library to programmatically create an image for each chunk of text. This involves creating a blank canvas, choosing fonts and colors, and drawing the text onto it.

For this example, I’m creating simple, clean slides with a title, body text, and a footer.

from PIL import Image, ImageDraw, ImageFont
import textwrap

def create_slide_image(text, slide_number, total_slides, output_folder="output"):
    """Creates a PNG image for a single carousel slide."""
    WIDTH, HEIGHT = 1080, 1080  # LinkedIn square post size
    BG_COLOR = "#0D2447"  # A nice dark blue
    TEXT_COLOR = "#FFFFFF"
    FOOTER_COLOR = "#CCCCCC"
    
    # I recommend downloading a nice open-source font like 'Inter'
    try:
        font = ImageFont.truetype("assets/Inter-Bold.ttf", size=60)
        font_small = ImageFont.truetype("assets/Inter-Regular.ttf", size=30)
    except IOError:
        font = ImageFont.load_default()
        font_small = ImageFont.load_default()

    img = Image.new('RGB', (WIDTH, HEIGHT), color=BG_COLOR)
    draw = ImageDraw.Draw(img)

    # Wrap text to fit the slide width
    lines = textwrap.wrap(text, width=35)
    
    # Calculate text position to center it vertically
    text_height = sum([font.getbbox(line)[3] - font.getbbox(line)[1] for line in lines])
    y_start = (HEIGHT - text_height) / 2

    for line in lines:
        line_width, line_height = draw.textbbox((0,0), line, font=font)[2:4]
        draw.text(((WIDTH - line_width) / 2, y_start), line, font=font, fill=TEXT_COLOR)
        y_start += line_height + 15 # Add a little spacing

    # Add footer
    footer_text = f"Slide {slide_number}/{total_slides} | TechResolve Blog"
    footer_width = draw.textbbox((0,0), footer_text, font=font_small)[2]
    draw.text(((WIDTH - footer_width) / 2, HEIGHT - 70), footer_text, font=font_small, fill=FOOTER_COLOR)

    # Save the image
    filename = f"{output_folder}/slide_{slide_number}.png"
    img.save(filename)
    return filename

Step 5: Assemble the Final PDF

With a folder full of slide images, the final step is to stitch them together into a single PDF file. `Pillow` makes this surprisingly easy.

def create_pdf_from_images(image_files, output_filename="carousel.pdf"):
    """Combines a list of images into a single PDF."""
    if not image_files:
        print("No images to create a PDF from.")
        return

    images = [Image.open(f).convert('RGB') for f in image_files]
    
    first_image = images[0]
    other_images = images[1:]
    
    first_image.save(output_filename, "PDF" ,resolution=100.0, save_all=True, append_images=other_images)
    print(f"Successfully created PDF: {output_filename}")

# --- Bringing It All Together ---
# URL = "..."
# text = get_blog_content(URL)
# if text:
#     chunks = chunk_text_for_slides(text)
#     image_paths = []
#     total = len(chunks)
#     for i, chunk in enumerate(chunks):
#         path = create_slide_image(chunk, i + 1, total)
#         image_paths.append(path)
#     
#     create_pdf_from_images(image_paths, "output/linkedin_carousel.pdf")

Pro Tip for Production: In my production setups, I parameterize this script. Instead of hardcoding the URL and output filename, I use Python’s `argparse` library to pass them as command-line arguments. This makes it much more flexible and reusable for the whole team.

Common Pitfalls

Here are a few places I’ve tripped up in the past:

• Fragile Scrapers: The number one point of failure is the web scraper. If the blog’s HTML structure changes, `soup.find()` will return `None` and the script will fail. You have to be prepared to update your selectors occasionally.
• Text Overflow: My chunking logic is simple. Sometimes a very long paragraph or a headline can still be too big for a slide, causing text to get cut off. You may need to manually edit the source text or add more sophisticated splitting logic to handle this.
• Missing Fonts: The `ImageFont.truetype()` call will fail if the font file isn’t where you specified. I recommend keeping your fonts in an `assets` folder within your project to avoid path issues. If it can’t find it, it’ll fall back to a default font that doesn’t look nearly as good.

Conclusion

And that’s the core of it. This script is a powerful starting point for automating your content repurposing workflow. From here, you can add your company logo, experiment with different color schemes, or even pull from a list of URLs to process in a batch.

The goal is to stop doing repetitive manual work and focus our energy where it matters most. I hope this helps you reclaim some valuable time in your week. Let me know if you have any questions.

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions