Migrate Blogger (Blogspot) to Hugo Static Site

Hey there, I’m Darian Vance. For years, I kept a personal tech blog on Blogger. It was simple, but I eventually hit a wall. The load times were lagging, the platform felt restrictive, and I had zero version control over my content. Every time I wanted to tweak the theme, it felt like performing surgery with a butter knife. I was spending more time fighting the platform than writing, which is a classic sign that a change is needed. Migrating to Hugo was a game-changer. It put me back in control, drastically improved performance, and integrated my writing directly into my Git-based workflow. Let’s walk through how you can do the same.

Prerequisites

Before we dive in, make sure you have the following ready to go. This will make the process much smoother.

• Your Blogger blog’s XML export file.
• Python 3 installed on your local machine.
• The Hugo executable installed and accessible in your system’s PATH.
• Basic comfort with using the command line and a code editor.
• Git for version control (highly recommended).

The Guide: From Dynamic to Static in 5 Steps

Step 1: Export Your Content from Blogger

First things first, we need to get your data out of Google’s ecosystem. This is thankfully the easiest part.

1. Log in to your Blogger dashboard.
2. Navigate to Settings > Manage Blog.
3. Find the “Back up content” option and click it. This will download an XML file containing all your posts, pages, and comments.
4. Save this file somewhere accessible, for example, as my_blog_export.xml.

Step 2: Prepare Your Local Environment

Now, let’s set up a clean workspace. I always recommend creating a new project directory and a dedicated Python virtual environment for a task like this to keep dependencies from clashing. I’ll skip showing the shell commands for creating directories or a virtualenv since you probably have your own preferred workflow. Once your environment is active, you’ll need to install a helpful Python library. Just run a standard pip command to install blogger-to-hugo.

Step 3: Convert the XML to Markdown

With the library installed, we can write a simple Python script to perform the conversion. This gives us more control than just running a command-line tool directly. Create a file named convert.py in your project directory.

Here’s the script I use. It’s straightforward: it reads your XML export, processes it, and spits out Hugo-compatible Markdown files into a specified output directory.

import os
from blogger_to_hugo.blogger_to_hugo import Converter

# --- Configuration ---
BLOGGER_EXPORT_FILE = 'my_blog_export.xml'
HUGO_OUTPUT_DIR = 'hugo_content'
# --- End Configuration ---

def main():
    """
    Main function to run the blog conversion process.
    """
    print(f"Starting conversion of '{BLOGGER_EXPORT_FILE}'...")

    if not os.path.exists(BLOGGER_EXPORT_FILE):
        print(f"Error: Export file not found at '{BLOGGER_EXPORT_FILE}'")
        return

    # Create the output directory if it doesn't exist
    if not os.path.exists(HUGO_OUTPUT_DIR):
        print(f"Creating output directory: '{HUGO_OUTPUT_DIR}'")
        os.makedirs(HUGO_OUTPUT_DIR)

    try:
        converter = Converter(BLOGGER_EXPORT_FILE, HUGO_OUTPUT_DIR)
        converter.convert()
        print("\nConversion complete!")
        print(f"Your Hugo-ready content is in the '{HUGO_OUTPUT_DIR}' directory.")
    except Exception as e:
        print(f"An error occurred during conversion: {e}")

if __name__ == "__main__":
    main()

Run this script from your terminal with a simple `python3 convert.py`. If all goes well, you’ll see a new directory named hugo_content containing subdirectories for your posts and pages, all neatly formatted in Markdown.

Pro Tip: Before running the script, open the XML file and do a quick search for any strange artifacts or encoding issues. I once had a blog with weird control characters that broke the parser. A quick find-and-replace in a good code editor saved me a lot of debugging time.

Step 4: Set Up Your Hugo Site

Now that we have the content, let’s build its new home. In your terminal, navigate outside your current project folder and create a new Hugo site. The command for this is typically `hugo new site your-site-name`.

This command scaffolds a complete Hugo project structure. The key folders are:

• content/: Where your Markdown files live.
• static/: For images, CSS, and JS files.
• themes/: Where you’ll place your site theme.
• hugo.toml: Your site’s main configuration file.

Next, move the converted content from our script’s output (`hugo_content/posts`) into your new Hugo site’s `content/posts` directory.

You’ll also need a theme. For starting out, you can grab a simple one from the official Hugo themes site. Follow the theme’s instructions for installation, which usually involves cloning it into the `themes` directory and adding its name to your `hugo.toml` file.

Step 5: Review, Refine, and Deploy

The conversion is just the start. The automated output is about 80% of the way there, but the last 20% is what makes it professional. Fire up the local Hugo server (usually with the `hugo server` command) to preview your site.

Now, go through your posts and check for:

• Broken Images: Image paths will still point to Blogger’s CDN. You’ll need to download these images and update the links to point to your local `static/images` folder. This is the most tedious part, but it’s critical.
• Formatting Issues: Check how code blocks, blockquotes, and other special formatting translated. You may need to clean up some of the generated Markdown.
• Internal Links: Links between your own posts will be broken. Update them to use Hugo’s `relref` shortcode for robust internal linking.
• Comments: Blogger comments are included in the export, but Hugo, being static, doesn’t have a built-in comment system. You’ll need to migrate them to a service like Disqus, Commento, or Giscus and embed it in your theme.

Common Pitfalls (Where I Usually Mess Up)

• Forgetting Permalinks: Blogger has a specific URL structure (`/YYYY/MM/post-name.html`). If you don’t replicate this in Hugo, you’ll lose all your SEO ranking and break all external links. Set this in your `hugo.toml` to preserve your URLs. For example:

  
  [permalinks]
    posts = "/:year/:month/:slug.html"
          

• Ignoring Image Migration: It’s tempting to leave images hosted on Blogger’s CDN. Don’t. It creates an external dependency that could break at any time. Take the time to download and self-host your images. I often use a script for this, but manual works for smaller blogs.
• Not Cleaning Front Matter: The conversion script does a good job, but sometimes tags or categories can be messy. Go through the generated front matter in your Markdown files to ensure it’s clean and consistent. This pays off for taxonomy and site organization later.

Conclusion

And that’s the core workflow. Migrating from Blogger to Hugo is an investment, but the payoff is huge. You get a blazing-fast, secure site that lives entirely within your own version control system. You have full control over the markup, styling, and deployment pipeline. It brings your personal blog up to the same professional standards we use for our production web applications. Welcome to the world of static site generation—you won’t look back.

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