Automate YouTube Shorts Creation with AI Video Generators in 2026

pip install requests google-api-python-client google-auth-httplib2 google-auth-oauthlib openai

# script_generator.py
import openai

client = openai.OpenAI()  # reads OPENAI_API_KEY from env

def generate_short_script(topic: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "You write YouTube Shorts scripts. "
                    "Output ONLY the spoken words — no stage directions, no titles. "
                    "Maximum 130 words. Hook in the first 3 seconds."
                )
            },
            {"role": "user", "content": f"Topic: {topic}"}
        ],
        max_tokens=200
    )
    return response.choices[0].message.content.strip()

# video_renderer.py
import requests, time, os

RUNWAY_API_KEY = os.environ["RUNWAY_API_KEY"]
RUNWAY_BASE    = "https://api.runwayml.com/v1"

def render_short(script: str, output_path: str) -> str:
    headers = {
        "Authorization": f"Bearer {RUNWAY_API_KEY}",
        "Content-Type": "application/json",
        "X-Runway-Version": "2024-11-06"
    }

    # Submit the generation job
    payload = {
        "model": "gen3a_turbo",
        "promptText": script,
        "ratio": "768:1280",  # 9:16 — critical for Shorts compatibility
        "duration": 10        # seconds per clip; chain clips for longer videos
    }
    job = requests.post(f"{RUNWAY_BASE}/image_to_video", json=payload, headers=headers)
    job.raise_for_status()
    task_id = job.json()["id"]

    # Poll until complete (usually 60–90 seconds)
    while True:
        status = requests.get(f"{RUNWAY_BASE}/tasks/{task_id}", headers=headers).json()
        if status["status"] == "SUCCEEDED":
            video_url = status["output"][0]
            break
        elif status["status"] == "FAILED":
            raise RuntimeError(f"Runway render failed: {status.get('failure')}")
        time.sleep(5)

    # Download the rendered .mp4
    video_data = requests.get(video_url).content
    with open(output_path, "wb") as f:
        f.write(video_data)

    return output_path

# caption_burner.py
import subprocess, openai, json, tempfile, os

client = openai.OpenAI()

def add_captions(video_path: str, script: str, output_path: str) -> str:
    # Generate an SRT file from the script via Whisper
    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as tmp_audio:
        audio_path = tmp_audio.name

    # Extract audio from the rendered video first
    subprocess.run(
        ["ffmpeg", "-i", video_path, "-q:a", "0", "-map", "a", audio_path, "-y"],
        check=True, capture_output=True
    )

    with open(audio_path, "rb") as audio_file:
        transcript = client.audio.transcriptions.create(
            model="whisper-1",
            file=audio_file,
            response_format="srt"
        )

    srt_path = video_path.replace(".mp4", ".srt")
    with open(srt_path, "w") as f:
        f.write(transcript)

    # Burn captions — center bottom, large font for mobile readability
    subprocess.run([
        "ffmpeg", "-i", video_path,
        "-vf", f"subtitles={srt_path}:force_style='FontSize=24,Alignment=2'",
        "-c:a", "copy", output_path, "-y"
    ], check=True, capture_output=True)

    os.unlink(audio_path)
    return output_path

# youtube_uploader.py
import os
from googleapiclient.discovery import build
from googleapiclient.http import MediaFileUpload
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
import pickle

SCOPES = ["https://www.googleapis.com/auth/youtube.upload"]

def get_youtube_client():
    creds = None
    if os.path.exists("token.pickle"):
        with open("token.pickle", "rb") as token:
            creds = pickle.load(token)

    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file("client_secrets.json", SCOPES)
            creds = flow.run_local_server(port=0)
        with open("token.pickle", "wb") as token:
            pickle.dump(creds, token)

    return build("youtube", "v3", credentials=creds)

def upload_short(video_path: str, title: str, description: str) -> str:
    youtube = get_youtube_client()

    body = {
        "snippet": {
            "title": title,
            "description": description,
            "tags": ["shorts"],
            "categoryId": "22"      # People & Blogs — works for most niches
        },
        "status": {
            "privacyStatus": "public",
            "selfDeclaredMadeForKids": False
        }
    }

    media = MediaFileUpload(video_path, mimetype="video/mp4", resumable=True)
    request = youtube.videos().insert(part="snippet,status", body=body, media_body=media)

    response = None
    while response is None:
        _, response = request.next_chunk()

    video_id = response["id"]
    print(f"Uploaded: https://youtube.com/shorts/{video_id}")
    return video_id

# pipeline.py
import os
from script_generator import generate_short_script
from video_renderer import render_short
from caption_burner import add_captions
from youtube_uploader import upload_short

TOPICS = [
    "One Python trick that saves an hour every week",
    "Why your API calls are slower than they should be",
    "The git command most devs don't know about"
]

def run_pipeline(topic: str):
    print(f"[1/4] Generating script for: {topic}")
    script = generate_short_script(topic)

    print("[2/4] Rendering video...")
    raw_video = render_short(script, output_path="raw_short.mp4")

    print("[3/4] Adding captions...")
    captioned_video = add_captions(raw_video, script, output_path="final_short.mp4")

    print("[4/4] Uploading to YouTube...")
    video_id = upload_short(
        video_path=captioned_video,
        title=topic[:100],  # YouTube title limit is 100 chars
        description=f"#{topic.split()[0].lower()} #shorts\n\n{script}"
    )
    return video_id

if __name__ == "__main__":
    import sys
    topic = sys.argv[1] if len(sys.argv) > 1 else TOPICS[0]
    run_pipeline(topic)

python pipeline.py "One Python trick that saves an hour every week"

# Edit crontab
crontab -e

# Run at 9am daily, pick a random topic from your list
0 9 * * * cd /path/to/project && python pipeline.py "$(shuf -n1 topics.txt)" >> logs/pipeline.log 2>&1