ChadOS

    Claude Code · vidIQ · Python · YouTube API

    How I Automated YouTube Uploads

    The video is finished. The busywork isn’t. I built a workflow that prepares the title, description, tags, thumbnail, and captions—then lets me review everything before uploading.

    Watch the workflow Subscribe

    I still make the videos. I still approve the upload. Stream Deck is optional.

    The working version

    Less copying. Still my call.

    Watch the finished export become a reviewed upload package, then follow the Python uploader into YouTube Studio. The errors and limitations are part of the story too.

    Human approval firstOptional one-button launch
    Watch on YouTube
    0:44 · Prepare the package1:57 · The time comparison2:34 · YouTube API & OAuth3:24 · Python troubleshooting3:59 · What it cannot do

    What the workflow handles

    The repetitive parts, not the creativity.

    Start with the finished video

    Claude Code analyzes the final export and generates a fresh transcript. The video I actually made—not my original idea—is the source of truth.

    Research that matches the content

    vidIQ looks for keywords and search opportunities connected to that transcript, rather than packaging the video around a guess.

    Prepare the upload package

    The workflow generates a title, description, tags, thumbnail, and SRT caption file. Preparing an asset is not the same as successfully attaching it through the API.

    Keep a human approval step

    I see the complete package and can change anything before approving it. Claude does not get to publish whatever it wants.

    Let Python handle the upload

    After Google sign-in, my Python uploader connects to the YouTube Data API. I check the result in YouTube Studio afterward.

    Use a button—or don’t

    My Windows .bat launcher runs the uploader. I mapped it to a Stream Deck button, but running the launcher directly works too.

    My same-video time test

    Four minutes manually. Roughly two with the workflow.

    4 min

    Manual YouTube upload process

    ~2 min

    Workflow + remaining Studio tasks

    For this video, it cut that work roughly in half. When I’m uploading multiple videos each week, small savings start adding up.

    One recorded comparison—not a guarantee, and not a measurement of total production, AI processing, or network upload time. Building and troubleshooting the system took additional time.

    How my workflow fits together

    Prepare. Approve. Upload.

    This is the workflow overview. My script saves the full Google Cloud and YouTube API setup for a separate video—not a complete installation tutorial here.

    1. Step 01

      Prepare from the final export

      Give Claude Code the finished video. Generate a fresh transcript, use vidIQ for relevant research, and assemble the title, description, tags, thumbnail, and SRT captions in a reviewable package.

    2. Step 02

      Review before authorizing anything

      Check that the title and thumbnail match the video, proofread the description, and spot-check captions. Make corrections and explicitly approve the package before launching an upload.

    3. Step 03

      Upload, then check YouTube Studio

      Run the Python uploader through your launcher or optional Stream Deck button. Complete Google authorization when prompted, then verify the video and supported assets in Studio and finish any remaining tasks there.

    The fix: one Python environment for the project

    Multiple Python installations were competing for the uploader’s packages. A project-local environment with its own dependencies solved that conflict. Google sign-in issues needed separate fixes. This was a lot of back-and-forth with Claude Code—not a one-prompt miracle.

    The boundary: YouTube Studio still matters

    My particular method could not automatically upload Shorts thumbnails. The API does not cover every Studio task, and generating an asset does not prove it attached successfully. Check the actual result in Studio.

    The non-negotiable: keep credentials private

    My uploader uses a Google Cloud project, YouTube Data API v3, and OAuth permission to access my channel. Keep the generated credentials file and saved tokens local and out of public repositories, prompts, screenshots, and logs.

    Google’s official API upload guide ↗

    Companion starter prompt

    Build around your own workflow.

    This newly written prompt is based on the process in my video. It is not my exact publisher skill, original code, or a promise of a working uploader. Start with a plan and test each stage.

    Help me design a YouTube publisher workflow for my finished video.

First ask for the final video path, my operating system, and the tools already installed. Do not assume you can transcribe video or create images without checking the available tools.

Preparation:
- Use the finished video as the source of truth and generate a fresh transcript.
- If my vidIQ connection is available, research relevant keywords and search opportunities. Otherwise tell me what research is missing; do not invent keyword scores.
- Prepare title options, a description, relevant tags, a thumbnail asset or brief, and an SRT caption file using the available tools.
- Show the complete package for review. Do not upload or publish anything until I explicitly approve.

Uploader plan:
- Use Python in a project-local virtual environment with its own dependencies.
- Plan a YouTube Data API v3 uploader with OAuth for my channel. Explain the permissions before I authorize it.
- Keep the OAuth credentials file and saved tokens local, outside source control. Never print them or include them in prompts, logs, or downloadable assets.
- Default the first test upload to private. Confirm the destination channel and requested visibility before any upload.
- Check which metadata, thumbnail, and caption operations are actually supported. Do not assume a Shorts thumbnail can be attached automatically.
- Add a review-only/dry-run mode, clear error messages, and a confirmation gate to prevent duplicate or unapproved uploads.
- If I use Windows, offer a .bat launcher that uses the project's Python environment. Stream Deck integration is optional.

Start with a plan and the prerequisites. Build and test one stage at a time; do not promise a working uploader from one prompt.

    Before the upload

    Keep the review step.

    Take the preparation, approval, credential-safety, and Studio checks with you. There’s also space to record your own time comparison.

    Download checklist (.md)

    No email required. A companion checklist—not an executable uploader or credentials file.

    FAQ

    YouTube automation, with limits.

    Get the upload checklist

    Next up: the YouTube API.

    I’m turning the parts that slow me down into a series. Subscribe to follow the API setup and the next improvements to this upload workflow.

    Subscribe on YouTubeMore playbooks

    More from Chad

    Keep exploring

    Live

    650

    650 subscribers350 to 1,000

    Help a Chad out.

    That number is real, and it moves one person at a time. If this page saved you time, one subscribe genuinely makes my day.

    Detailed stats