This Automation Turns Your YouTube Videos Into Blog Posts All in Claude

Ever wish you could just tell Claude "turn my latest video into a blog post and publish it" and have it actually happen? Well, that's exactly what I built, and honestly, it feels like living in the future.

I'm talking about a complete automation that takes your YouTube video, transcribes it, writes a blog post in your style, and pushes it live to your website - all without leaving Claude Desktop. And the best part? It actually works.

Let me show you how this whole thing comes together, because once you see it in action, you're going to want to build your own version immediately.

The Magic in Action

Here's what happens when I type one simple command into Claude:

"Hey Claude, convert my latest YouTube video to a blog post and publish it directly."

First, Claude fires up a Make.com automation that finds my latest YouTube video and transcribes it into a Google Doc. Then it reads that transcript, writes a blog post based on my previous writing style, formats it as a markdown file, and pushes it to my GitHub repository where my website lives.

Within minutes, there's a new blog post live on my site - complete with the YouTube thumbnail as the header image, proper meta descriptions, and content that actually sounds like me.

Pretty wild, right? This is exactly the kind of content workflow automation I've been dreaming about.

If you’re curious about the power of prompting Claude and how a single prompt can drive complex workflows, check out how Claude-4 just one prompted this Miro whiteboard clone for inspiration.

Why This Setup is a Game-Changer

The real power here isn't just the automation - it's how MCP (Model Context Protocol) servers make Claude incredibly smart about your specific content and workflow.

Unlike traditional automations that just push content live automatically, this setup gives you a human-in-the-loop experience. Claude shows you the blog post it created, and you can give feedback, make edits, and polish it before publishing. No more AI slop getting published automatically.

Plus, because I've trained Claude on tons of my previous writing, the output actually sounds like me instead of generic AI content.

The Technical Setup: What's Happening Under the Hood

Let me break down the Make.com scenario that powers this whole thing:

Step 1: YouTube Video Extraction

• YouTube module pulls my latest video
• Set Variable extracts the full YouTube URL
• Apify scraper gets the video transcript

Step 2: Transcript Processing

• HTTP request pulls the raw caption track
• Text parsers clean up all the XML formatting
• Text aggregator combines everything into readable text
• Replace module fixes character encoding issues

Step 3: Asset Preparation

• Another Set Variable grabs the highest resolution thumbnail
• Everything gets organized into a Google Doc for Claude to read

The whole scenario runs in about 30 seconds and outputs a clean Google Doc with the video title, thumbnail URL, and formatted transcript.

Setting Up Your Own Version

Want to build this yourself? Here's the step-by-step breakdown:

Part 1: Make.com Setup

First, you'll need a Make.com account and their MCP server connected to Claude Desktop. Fair warning - I originally tried this with n8n's MCP server, but their version 1.94 is completely bugged out. Make.com worked flawlessly right out of the box.

Connect Make.com to Claude:

1. Go to your Make.com profile → API/MCP access
2. Generate a new MCP token
3. Copy the JSON configuration from Make's documentation
4. Add it to your Claude Desktop config file
5. Restart Claude and test the connection

Build the YouTube Processing Scenario:

Start with the YouTube module:

• Choose "Watch videos in a channel"
• Connect your YouTube account
• Set it to pull from your channel (Make.com can find your channel ID automatically)
• Limit to 1 video and set timing to "since specific date" for testing

Add a Set Variable to create the full YouTube URL:

• Variable name: "video URL"
• Value: https://www.youtube.com/watch?v= + the video ID from the previous step

Set up Apify for transcript extraction:

• You'll need an Apify account (they have great YouTube scrapers)
• Use the "YouTube Scraper" by API Dojo - it's 50 cents per thousand videos
• Set it to "run synchronously" so it completes before moving to the next step
• Add a second Apify module to "Get dataset items" and extract the actual data

Process the transcript with these modules:

• HTTP request to get the caption track URL
• Text parser with match pattern to extract clean text
• Text aggregator to combine everything
• Replace module to fix character encoding (like converting ' to apostrophes)

Extract the thumbnail:

• Set Variable for the highest resolution thumbnail
• Use the pattern: https://i.ytimg.com/vi/[VIDEO_ID]/maxresdefault.jpg

Finally, create a Google Doc with:

• Video title as the document name
• Content including title, thumbnail URL, and formatted transcript

Part 2: Claude Project Setup

This is where the real magic happens. Create a dedicated Claude project and upload:

• Examples of your writing style
• Previous blog posts
• YouTube transcripts
• Any content that represents your voice

Then create a prompt that Claude recognizes as the trigger. Mine is simple: "Convert my latest YouTube video to a blog post and publish it directly."

In your project instructions, include detailed guidance about:

• Your writing style and tone
• Target audience
• Blog post structure preferences
• Markdown formatting requirements
• SEO considerations

Part 3: GitHub Integration

If your website runs on GitHub (like mine does with Vercel), you'll want to set up the GitHub MCP server so Claude can push directly to your repository.

The setup is straightforward - just follow GitHub's MCP documentation and add the configuration to your Claude Desktop config file.

The Real Power: Human-in-the-Loop Automation

Here's what makes this different from typical "set it and forget it" automations: you stay in control.

When Claude finishes writing the blog post, it shows you the result. You can review it, suggest changes, ask for different angles, or polish the content before it goes live. It's automation that enhances your workflow without removing your creative control.

And because Claude is trained on your specific writing, the first draft is usually pretty solid. I rarely need major edits - just small tweaks here and there.

Why MCP Servers Change Everything

Model Context Protocol servers are what make this whole setup possible. Before MCP, you could build automations, but they were pretty dumb. Now Claude can:

• Access your Make.com scenarios directly
• Read from your Google Drive automatically
• Push to GitHub repositories
• Understand the full context of your content and style

It's like having a really smart assistant who knows exactly how you work and can execute complex workflows on your behalf.

A Few Important Notes

Make vs n8n: I originally built this in n8n, but their MCP server is broken as of version 1.94. Make.com worked perfectly from day one.

Apify costs: The YouTube scraping costs about 50 cents per thousand videos, so unless you're processing hundreds of videos, it's essentially free.

Testing: Run your Make.com scenario manually first to make sure everything works before connecting it to Claude.

Timing: Set your YouTube module to "on demand" once everything is working so Claude can trigger it properly.

The Future of Content Workflows

This automation represents something bigger than just turning videos into blog posts. It's a glimpse into how AI-assisted workflows will transform content creation.

Instead of spending hours manually transcribing, writing, formatting, and publishing, you can focus on the creative and strategic parts while AI handles the mechanical work.

And with the human-in-the-loop approach, you're not sacrificing quality for efficiency. You're getting both.

Ready to Build Your Own?

The setup takes a few hours to get right, but once it's working, it's incredibly satisfying. There's something magical about typing one sentence and watching your entire content pipeline spring into action.

If you build your own version, I'd love to hear how it works for you. And if you run into issues with the Make.com scenario or Claude setup, drop a comment - I'm happy to help troubleshoot.

This is just the beginning of what's possible with MCP servers and Claude Desktop. I've got a ton more automation ideas brewing, and honestly, I think we're just scratching the surface of what these tools can do.

The content workflow dreams are finally coming true, and it feels pretty amazing.

---

Let me know if you want me to add or adjust any other internal links!