How to Start a YouTube Channel for Developers with OBS and Descript in 2026

import obspython as obs
import sys
import json
import os
from pathlib import Path

# Configuration constants for OBS scene setup
SCENE_CONFIG_PATH = Path.home() / ".config" / "obs-studio" / "dev-channel-scenes.json"
SUPPORTED_OBS_VERSION = "30.1.0"
DEFAULT_WEBCAM_SOURCE = "TechCam HD 1080p"  # Replace with your webcam name
DEFAULT_SCREEN_SOURCE = "Display Capture 1"  # Replace with your display capture name

def script_description():
    return """Automated OBS Scene Setup for Developer YouTube Channels
    Creates three pre-configured scenes:
    1. Coding Workflow: Screen capture + webcam overlay + microphone audio
    2. Intro/Outro: Static image + background music + channel branding
    3. Code Review: Split screen (code editor + terminal) + system audio
    """

def validate_obs_version():
    """Check if running OBS version matches supported version to avoid API breaks"""
    current_version = obs.obs_get_version_string()
    if current_version != SUPPORTED_OBS_VERSION:
        sys.stderr.write(f"Unsupported OBS version: {current_version}. Expected {SUPPORTED_OBS_VERSION}\n")
        return False
    return True

def create_coding_scene():
    """Create the primary coding workflow scene with screen capture and webcam overlay"""
    scene_name = "Dev Coding Workflow"
    if obs.obs_scene_exists(scene_name):
        sys.stderr.write(f"Scene {scene_name} already exists, skipping creation\n")
        return None

    scene = obs.obs_scene_create(scene_name)
    if not scene:
        raise RuntimeError(f"Failed to create scene: {scene_name}")

    # Add screen capture source (assumes pre-configured display capture)
    screen_source = obs.obs_get_source_by_name(DEFAULT_SCREEN_SOURCE)
    if not screen_source:
        sys.stderr.write(f"Screen source {DEFAULT_SCREEN_SOURCE} not found. Configure display capture first.\n")
        obs.obs_scene_release(scene)
        return None

    screen_scene_item = obs.obs_scene_add(scene, screen_source)
    # Position screen capture to fill entire frame (1920x1080)
    bounds = obs.vec2()
    bounds.x = 1920
    bounds.y = 1080
    obs.obs_sceneitem_set_bounds_type(screen_scene_item, obs.OBS_BOUNDS_SCALE_INNER)
    obs.obs_sceneitem_set_bounds(screen_scene_item, bounds)
    obs.obs_sceneitem_set_pos(screen_scene_item, obs.vec2(0, 0))

    # Add webcam overlay in bottom-right corner (320x240)
    webcam_source = obs.obs_get_source_by_name(DEFAULT_WEBCAM_SOURCE)
    if webcam_source:
        webcam_item = obs.obs_scene_add(scene, webcam_source)
        webcam_pos = obs.vec2(1920 - 320 - 20, 1080 - 240 - 20)  # 20px margin
        obs.obs_sceneitem_set_pos(webcam_item, webcam_pos)
        webcam_bounds = obs.vec2(320, 240)
        obs.obs_sceneitem_set_bounds(webcam_item, webcam_bounds)
        obs.obs_sceneitem_set_bounds_type(webcam_item, obs.OBS_BOUNDS_SCALE_KEEP_ASPECT)
        obs.obs_source_release(webcam_source)
    else:
        sys.stderr.write(f"Webcam source {DEFAULT_WEBCAM_SOURCE} not found. Webcam overlay skipped.\n")

    obs.obs_source_release(screen_source)
    return scene

def save_scene_config(scene):
    """Persist scene configuration to JSON for backup/restore"""
    try:
        config = {
            "scene_name": obs.obs_scene_get_name(scene),
            "resolution": "1920x1080",
            "fps": 60,
            "audio_sources": ["Mic/Aux", "Desktop Audio"],
            "created_at": obs.obs_datetime_string()
        }
        with open(SCENE_CONFIG_PATH, "w") as f:
            json.dump(config, f, indent=2)
        print(f"Scene config saved to {SCENE_CONFIG_PATH}")
    except IOError as e:
        sys.stderr.write(f"Failed to save scene config: {e}\n")

def script_load(settings):
    if not validate_obs_version():
        return
    try:
        coding_scene = create_coding_scene()
        if coding_scene:
            save_scene_config(coding_scene)
            obs.obs_scene_release(coding_scene)
        print("OBS Dev Channel Scene Setup complete")
    except RuntimeError as e:
        sys.stderr.write(f"Scene setup failed: {e}\n")
        sys.exit(1)

def script_unload():
    print("OBS Dev Channel Scene script unloaded")

import requests
import json
import os
import time
import sys
from pathlib import Path
from typing import Dict, Optional

# Descript API configuration (API key stored in environment variable for security)
DESCRIPT_API_BASE = "https://api.descript.com/v4"
DESCRIPT_API_KEY = os.environ.get("DESCRIPT_API_KEY")
VIDEO_UPLOAD_POLL_INTERVAL = 10  # Seconds between polling transcription status
MAX_POLL_ATTEMPTS = 30  # Max attempts before timing out

def validate_api_key():
    """Check if Descript API key is set and valid"""
    if not DESCRIPT_API_KEY:
        sys.stderr.write("DESCRIPT_API_KEY environment variable not set. Exiting.\n")
        sys.exit(1)
    # Test API key with a simple user info request
    headers = {"Authorization": f"Bearer {DESCRIPT_API_KEY}"}
    response = requests.get(f"{DESCRIPT_API_BASE}/user", headers=headers)
    if response.status_code != 200:
        sys.stderr.write(f"Invalid Descript API key. Status: {response.status_code}\n")
        sys.exit(1)
    print(f"Authenticated as {response.json().get('email')}")

def upload_video_to_descript(video_path: Path, project_name: str) -> Optional[str]:
    """Upload a local video file to Descript and return the project ID"""
    if not video_path.exists():
        sys.stderr.write(f"Video file {video_path} not found.\n")
        return None

    headers = {"Authorization": f"Bearer {DESCRIPT_API_KEY}"}
    # Step 1: Initiate upload session
    init_payload = {
        "name": project_name,
        "file_size": video_path.stat().st_size,
        "file_type": "video/mp4"
    }
    init_response = requests.post(
        f"{DESCRIPT_API_BASE}/projects",
        headers=headers,
        json=init_payload
    )
    if init_response.status_code != 201:
        sys.stderr.write(f"Failed to create Descript project: {init_response.text}\n")
        return None

    project_id = init_response.json().get("id")
    upload_url = init_response.json().get("upload_url")
    if not upload_url:
        sys.stderr.write("No upload URL returned from Descript API.\n")
        return None

    # Step 2: Upload video file in chunks (handle large files)
    with open(video_path, "rb") as f:
        upload_response = requests.put(
            upload_url,
            data=f,
            headers={"Content-Type": "video/mp4"}
        )
    if upload_response.status_code not in (200, 201):
        sys.stderr.write(f"Video upload failed: {upload_response.text}\n")
        return None

    print(f"Video uploaded to Descript project: {project_id}")
    return project_id

def wait_for_transcription(project_id: str) -> Optional[Dict]:
    """Poll Descript API until transcription is complete, return transcript data"""
    headers = {"Authorization": f"Bearer {DESCRIPT_API_KEY}"}
    for attempt in range(MAX_POLL_ATTEMPTS):
        response = requests.get(
            f"{DESCRIPT_API_BASE}/projects/{project_id}/transcription",
            headers=headers
        )
        if response.status_code != 200:
            sys.stderr.write(f"Transcription status check failed: {response.text}\n")
            return None

        status = response.json().get("status")
        if status == "completed":
            print(f"Transcription complete for project {project_id}")
            return response.json()
        elif status == "failed":
            sys.stderr.write(f"Transcription failed for project {project_id}\n")
            return None

        print(f"Transcription status: {status}. Polling again in {VIDEO_UPLOAD_POLL_INTERVAL}s (attempt {attempt+1}/{MAX_POLL_ATTEMPTS})")
        time.sleep(VIDEO_UPLOAD_POLL_INTERVAL)

    sys.stderr.write(f"Transcription timed out after {MAX_POLL_ATTEMPTS} attempts\n")
    return None

def fix_code_transcriptions(project_id: str, transcript_data: Dict) -> bool:
    """Automatically correct common misheard code terms in Descript transcripts"""
    # Common code mishearings for developers (e.g., "pie" -> "py", "git" -> "get")
    CODE_TERM_CORRECTIONS = {
        "pie": "py",
        "get": "git",
        "hash": "#",
        "print f": "printf",
        "eye f": "if",
        "else if": "elif",
        "four loop": "for loop",
        "while loop": "while loop"  # Sanity check
    }

    headers = {"Authorization": f"Bearer {DESCRIPT_API_KEY}"}
    transcript_text = transcript_data.get("text", "")
    corrected_text = transcript_text

    for wrong, right in CODE_TERM_CORRECTIONS.items():
        corrected_text = corrected_text.replace(wrong, right)

    if corrected_text == transcript_text:
        print("No code term corrections needed")
        return True

    # Update transcript via Descript API
    update_payload = {"text": corrected_text}
    update_response = requests.patch(
        f"{DESCRIPT_API_BASE}/projects/{project_id}/transcription",
        headers=headers,
        json=update_payload
    )
    if update_response.status_code != 200:
        sys.stderr.write(f"Failed to update transcript: {update_response.text}\n")
        return False

    print(f"Corrected {len(CODE_TERM_CORRECTIONS)} common code mishearings")
    return True

def export_video(project_id: str, export_path: Path) -> bool:
    """Export edited video from Descript to local MP4 file"""
    headers = {"Authorization": f"Bearer {DESCRIPT_API_KEY}"}
    export_payload = {
        "format": "mp4",
        "resolution": "1080p",
        "fps": 60,
        "audio_bitrate": 192
    }
    export_response = requests.post(
        f"{DESCRIPT_API_BASE}/projects/{project_id}/exports",
        headers=headers,
        json=export_payload
    )
    if export_response.status_code != 201:
        sys.stderr.write(f"Export failed to start: {export_response.text}\n")
        return False

    export_id = export_response.json().get("id")
    # Poll export status
    for attempt in range(MAX_POLL_ATTEMPTS):
        export_status = requests.get(
            f"{DESCRIPT_API_BASE}/exports/{export_id}",
            headers=headers
        )
        if export_status.json().get("status") == "completed":
            download_url = export_status.json().get("download_url")
            # Download exported video
            video_response = requests.get(download_url)
            with open(export_path, "wb") as f:
                f.write(video_response.content)
            print(f"Exported video saved to {export_path}")
            return True
        time.sleep(VIDEO_UPLOAD_POLL_INTERVAL)

    sys.stderr.write("Video export timed out\n")
    return False

if __name__ == "__main__":
    validate_api_key()
    video_path = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("obs_recording_2026-03-15.mp4")
    project_name = f"Dev Tutorial {time.strftime('%Y-%m-%d')}"

    project_id = upload_video_to_descript(video_path, project_name)
    if not project_id:
        sys.exit(1)

    transcript_data = wait_for_transcription(project_id)
    if not transcript_data:
        sys.exit(1)

    fix_code_transcriptions(project_id, transcript_data)
    export_video(project_id, Path("edited_tutorial.mp4"))

import ollama
import sys
import json
import re
from typing import List, Dict
from pathlib import Path

# Configuration for metadata generation
OLLAMA_MODEL = "llama3.2:3b"  # Lightweight model for local inference
MAX_TITLE_LENGTH = 60
MIN_DESC_LENGTH = 145
MAX_DESC_LENGTH = 155
MAX_TAGS_LENGTH = 500
STOP_WORDS = {"the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with", "by"}

def validate_ollama_model():
    """Check if the specified Ollama model is available locally"""
    try:
        models = ollama.list()
        available_models = [m["name"] for m in models["models"]]
        if OLLAMA_MODEL not in available_models:
            sys.stderr.write(f"Model {OLLAMA_MODEL} not found. Pull it with: ollama pull {OLLAMA_MODEL}\n")
            sys.exit(1)
        print(f"Using Ollama model: {OLLAMA_MODEL}")
    except Exception as e:
        sys.stderr.write(f"Ollama not running or unreachable: {e}\n")
        sys.exit(1)

def extract_code_keywords(transcript_path: Path) -> List[str]:
    """Extract technical keywords from video transcript to inform metadata"""
    if not transcript_path.exists():
        sys.stderr.write(f"Transcript file {transcript_path} not found.\n")
        return []

    with open(transcript_path, "r") as f:
        text = f.read().lower()

    # Match common programming terms, libraries, tools
    code_pattern = re.compile(
        r"\b(python|javascript|typescript|rust|go|kubernetes|docker|obs|descript|git|github|"
        r"api|sdk|cli|frontend|backend|devops|aws|azure|gcp|react|vue|angular|node|"
        r"sql|nosql|redis|postgres|mongodb|kafka|grpc|rest|graphql)\b"
    )
    keywords = list(set(code_pattern.findall(text)))
    # Remove stop words and duplicates
    keywords = [k for k in keywords if k not in STOP_WORDS]
    print(f"Extracted {len(keywords)} technical keywords from transcript")
    return keywords

def generate_youtube_metadata(keywords: List[str], video_topic: str) -> Dict:
    """Generate SEO-optimized YouTube metadata using local LLM"""
    prompt = f"""Generate YouTube metadata for a developer tutorial video about {video_topic}.
    Use the following technical keywords: {', '.join(keywords[:10])}
    Follow these constraints strictly:
    1. Title: Under {MAX_TITLE_LENGTH} characters, include 1-2 keywords, compelling for developers
    2. Description: Between {MIN_DESC_LENGTH} and {MAX_DESC_LENGTH} characters, include value proposition, 2-3 keywords, call to action
    3. Tags: Up to {MAX_TAGS_LENGTH} characters, comma-separated, 15-20 relevant technical tags
    Return JSON with keys: title, description, tags (string of comma-separated tags)
    """

    try:
        response = ollama.generate(
            model=OLLAMA_MODEL,
            prompt=prompt,
            format="json",
            options={"temperature": 0.3}  # Low temperature for factual output
        )
        metadata = json.loads(response["response"])
    except json.JSONDecodeError:
        sys.stderr.write("LLM returned invalid JSON. Using fallback metadata.\n")
        # Fallback metadata if LLM fails
        metadata = {
            "title": f"{video_topic} Tutorial for Developers",
            "description": f"Learn {video_topic} with step-by-step code examples. Perfect for senior developers looking to master {keywords[0] if keywords else 'modern tools'}.",
            "tags": ",".join(keywords[:15]) if keywords else "developer,tutorial,coding"
        }
    except Exception as e:
        sys.stderr.write(f"LLM generation failed: {e}\n")
        sys.exit(1)

    # Validate metadata constraints
    if len(metadata["title"]) > MAX_TITLE_LENGTH:
        metadata["title"] = metadata["title"][:MAX_TITLE_LENGTH-3] + "..."
        print(f"Truncated title to {MAX_TITLE_LENGTH} characters")

    if len(metadata["description"]) < MIN_DESC_LENGTH:
        metadata["description"] += f" Subscribe for more {video_topic} tutorials."
    if len(metadata["description"]) > MAX_DESC_LENGTH:
        metadata["description"] = metadata["description"][:MAX_DESC_LENGTH-3] + "..."

    if len(metadata["tags"]) > MAX_TAGS_LENGTH:
        metadata["tags"] = metadata["tags"][:MAX_TAGS_LENGTH]
        print(f"Truncated tags to {MAX_TAGS_LENGTH} characters")

    return metadata

def save_metadata(metadata: Dict, output_path: Path):
    """Save generated metadata to JSON file for YouTube upload tools"""
    try:
        with open(output_path, "w") as f:
            json.dump(metadata, f, indent=2)
        print(f"Metadata saved to {output_path}")
        # Print preview for manual verification
        print("\n=== Metadata Preview ===")
        print(f"Title: {metadata['title']} ({len(metadata['title'])} chars)")
        print(f"Description: {metadata['description']} ({len(metadata['description'])} chars)")
        print(f"Tags: {metadata['tags'][:50]}...")
    except IOError as e:
        sys.stderr.write(f"Failed to save metadata: {e}\n")

if __name__ == "__main__":
    validate_ollama_model()
    if len(sys.argv) < 3:
        sys.stderr.write("Usage: python generate_metadata.py  \n")
        sys.exit(1)

    transcript_path = Path(sys.argv[1])
    video_topic = sys.argv[2]
    keywords = extract_code_keywords(transcript_path)
    metadata = generate_youtube_metadata(keywords, video_topic)
    save_metadata(metadata, Path("youtube_metadata.json"))

# OBS Python script to auto-enable RNNoise and Compressor on mic source
import obspython as obs

def add_audio_filters(mic_source_name="Mic/Aux"):
    source = obs.obs_get_source_by_name(mic_source_name)
    if not source:
        return
    # Add RNNoise noise suppression
    noise_suppress = obs.obs_source_create_private("noise_suppress_filter", "RNNoise Suppress", None)
    obs.obs_source_filter_add(source, noise_suppress)
    # Add Compressor filter
    compressor = obs.obs_source_create_private("compressor_filter", "Mic Compressor", None)
    obs.obs_source_filter_add(source, compressor)
    obs.obs_source_release(source)

# Descript API call to add a Python code block to a project
import requests

def add_code_block(project_id, code, language="python", start_time=10.0):
    headers = {"Authorization": f"Bearer {DESCRIPT_API_KEY}"}
    payload = {
        "type": "code_block",
        "content": code,
        "language": language,
        "start_time": start_time,
        "duration": 5.0,
        "style": "dracula"  # Syntax highlight theme
    }
    response = requests.post(
        f"https://api.descript.com/v4/projects/{project_id}/elements",
        headers=headers,
        json=payload
    )
    return response.json().get("id")

# GitHub Actions workflow snippet for YouTube upload
- name: Upload to YouTube
  run: |
    python upload_youtube.py \
      --video-path edited_tutorial.mp4 \
      --metadata-path youtube_metadata.json
  env:
    YOUTUBE_CLIENT_SECRET: ${{ secrets.YOUTUBE_CLIENT_SECRET }}
    SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

dev-youtube-pipeline/
├── obs-scripts/
│   ├── scene-setup.py          # OBS scene automation script
│   ├── audio-filters.py        # OBS audio filter automation
│   └── README.md               # OBS script setup instructions
├── descript-scripts/
│   ├── upload-transcribe.py    # Descript API upload/transcription script
│   ├── add-code-block.py       # Descript code block API script
│   └── requirements.txt        # Python dependencies
├── metadata-generator/
│   ├── generate_metadata.py    # Local LLM metadata generator
│   └── ollama-models/          # Custom Ollama model configs
├── github-actions/
│   └── upload-youtube.yml      # GitHub Actions workflow for YouTube upload
├── case-study/
│   └── backend-team-config/   # Config files from the case study
└── README.md                   # Full setup guide