YouTube Video to Knowledge Extractor

Transform any YouTube video into structured knowledge — transcripts, visual keyframes, AI-powered summaries, flashcards, mind maps, and more.

When to Use This Skill

Trigger whenever:

• User shares a YouTube URL (youtube.com/watch, youtu.be, shorts)
• User asks to "summarize a video", "extract notes", "what does this video say"
• User wants transcripts, captions, or subtitles from YouTube
• User asks for flashcards, mind maps, or blog posts from video content
• User mentions "NoteGPT", "video notes", "video to text"
• User asks to analyze visual content (slides, diagrams) from a video
• User wants to extract knowledge from a playlist or channel

Architecture Overview

YouTube URL
    │
    ├── [1] Metadata Extraction (yt-dlp) — title, channel, chapters, tags
    │
    ├── [2] Transcript Extraction (3-tier fallback):
    │       ├── youtube-transcript-api (fastest, no download)
    │       ├── yt-dlp subtitle download (VTT parse)
    │       └── Whisper local transcription (audio download + ASR)
    │
    ├── [3] Visual Extraction (optional):
    │       ├── Scene-change keyframes (OpenCV histogram diff)
    │       ├── Interval-based frames (fixed time steps)
    │       └── FFmpeg scene detection
    │
    ├── [4] Knowledge Synthesis (Claude):
    │       ├── Comprehensive Notes
    │       ├── Executive Summary
    │       ├── Flashcards
    │       ├── Mind Map (Mermaid)
    │       ├── Blog Article
    │       ├── Technical Analysis
    │       └── Visual Analysis (with keyframe images)
    │
    └── [5] Skill Routing (PARALLEL — always do this):
            ├── Identify related skills from video topic
            ├── Update existing skills with new knowledge
            └── Cross-reference between skills

CRITICAL: Parallel Skill Integration (Always Do This)

After extracting and summarizing a YouTube video, you MUST do two things in parallel:

1. Present the summary to the user
2. Route the knowledge to related skills — find and update existing skills

How Skill Routing Works

Step A — Identify related skills (during synthesis): While reading the transcript, identify the video's domain topics. Match against existing skills:

• Trading concepts (BOS, CHoCH, liquidity, etc.) → market-structure-bos-choch, ict-smart-money, smc-beginner-pro-guide, etc.
• Strategy types → backtesting-sim, price-action, session-scalping, etc.
• Risk/portfolio → risk-and-portfolio, risk-and-portfolio, drawdown-playbook, etc.
• Technical analysis → technical-analysis, chart-pattern-scanner, fibonacci-strategy-engine, etc.
• Any other domain → match by keyword from skill descriptions

Step B — Update skills in parallel: Use the Agent tool to spawn parallel subagents that:

1. Read each related skill's SKILL.md
2. Add the new knowledge (rules, methods, concepts, Python code) as a new section
3. Add source attribution: > Source: "Video Title" by Channel (Date)
4. Add cross-references to other updated skills
5. Update the skill's description if new trigger terms are needed

Step C — Report to user: After both the summary and skill updates complete, tell the user:

Updated X related skills:
- skill-name-1: added [concept] section
- skill-name-2: added cross-reference to [concept]

Skill Update Rules

• Add new knowledge as a clearly marked section with source attribution
• Include Python implementations when the video teaches a quantifiable/automatable method
• Add new trigger terms to the skill description if the video introduces new terminology
• Cross-link updated skills to each other
• Never remove existing content — only add or enhance
• If no related skill exists, note this to the user (they may want to create one)

Quick Start — Step by Step

Step 0: Install Dependencies

pip install yt-dlp youtube-transcript-api webvtt-py --break-system-packages -q

These are lightweight. OpenCV and FFmpeg are pre-installed in the environment.

Step 1: Extract Content

Read and execute the extraction script:

python3 /path/to/scripts/youtube_extractor.py "YOUTUBE_URL" \
  --work-dir /home/claude/yt_work \
  --output /home/claude/yt_work/video_knowledge.md

Common options:

Step 2: Read the Extracted Content

After extraction, you'll have:

• *_knowledge.md — Human-readable knowledge document
• *_raw.json — Structured data for programmatic use
• keyframes/ directory (if --frames was used)

Read the markdown to understand the content, then proceed to analysis.

Step 3: Analyze with Claude (this is YOU)

You ARE Claude. After extracting the transcript, you have the full content in context. Now analyze it directly based on what the user wants:

If user wants notes/summary: Read the transcript and produce structured notes yourself. If user wants flashcards: Generate Q&A pairs from the content. If user wants a mind map: Create a Mermaid diagram showing concept relationships. If user wants visual analysis + `--frames` was used: Use the view tool to look at the extracted keyframe images, then describe what's shown at each timestamp.

The scripts/knowledge_synthesizer.py script exists for API-based synthesis (useful in artifacts or automated pipelines), but in most cases you should just analyze the transcript content directly.

Detailed Workflows

Workflow A: Quick Transcript + Summary (Most Common)

This is the 80% case — user shares a URL and wants to know what the video says.

# In your Python execution:
import sys
sys.path.insert(0, '/path/to/scripts')
from youtube_extractor import extract_video_id, get_video_metadata, extract_transcript_api

video_id = extract_video_id(url)
metadata = get_video_metadata(url)
transcript = extract_transcript_api(video_id)

# Now you have metadata['title'], transcript['text'], transcript['segments']
# Analyze directly in your response

Or use the CLI:

python3 scripts/youtube_extractor.py "URL" --work-dir /home/claude/yt_work
cat /home/claude/yt_work/*_knowledge.md

Workflow B: Visual Content Analysis

For tutorial videos, presentations, or demos where slides/screens matter:

python3 scripts/youtube_extractor.py "URL" \
  --frames --frame-method scene --max-frames 15 \
  --work-dir /home/claude/yt_work

Then use the view tool to examine each keyframe image, correlating what's shown with the transcript timestamps.

Workflow C: No Subtitles Available

Some videos have no captions at all. Enable Whisper fallback:

python3 scripts/youtube_extractor.py "URL" \
  --whisper --whisper-model base \
  --work-dir /home/claude/yt_work

Warning: Whisper downloads a model (~140MB for base) and transcribes the full audio. This is slow (real-time ratio ~0.3x on CPU). Only use when subtitles are unavailable.

Workflow D: Non-English Videos

Specify preferred languages:

python3 scripts/youtube_extractor.py "URL" \
  --languages ar en fr \
  --work-dir /home/claude/yt_work

The transcript API tries each language in order. Arabic (ar) is supported for auto-generated captions on most videos.

Workflow E: Batch / Playlist Processing

For multiple videos, loop over URLs:

urls = ["URL1", "URL2", "URL3"]
for i, url in enumerate(urls):
    result = extract_youtube_knowledge(
        url=url,
        work_dir=f'/home/claude/yt_work/video_{i}',
    )
    # Process each result

Output Types for Knowledge Synthesis

When using scripts/knowledge_synthesizer.py or when the user asks for a specific format:

Important Considerations

Network Access

• youtube-transcript-api needs access to YouTube's servers
• yt-dlp needs access to YouTube for downloads
• In restricted environments, the transcript API is the lightest option (no video download)

Rate Limits & Errors

• YouTube may rate-limit transcript requests — add small delays for batch processing
• Some videos block embedding/subtitles — the 3-tier fallback handles most cases
• Age-restricted or private videos require authentication (not supported in this skill)

File Sizes

• Transcripts: typically 10-50 KB text
• Keyframes: ~50-200 KB each (JPEG, 360p resolution)
• Audio (for Whisper): ~1 MB/minute at 128kbps
• Video (for frames): ~2-5 MB/minute at 360p

Cleanup

Always clean up working directories after extraction:

rm -rf /home/claude/yt_work

Error Handling Checklist

Script Locations

After installing this skill, scripts are at:

youtube-video-to-knowledge/
├── SKILL.md                          ← You are here
├── scripts/
│   ├── youtube_extractor.py          ← Main extraction pipeline
│   └── knowledge_synthesizer.py      ← Claude API synthesis (for artifacts)
├── references/
│   └── prompt_templates.md           ← Customizable prompt templates
└── assets/
    └── (empty — for user templates)

Tips for Best Results

1. Always extract metadata first — chapters and description give you a roadmap of the content.
2. Prefer transcript API over yt-dlp — it's faster and doesn't download anything.
3. Use `--frames` for tutorial/presentation videos — slides contain info not in speech.
4. For long videos (>1 hour), consider extracting chapters and summarizing per-chapter.
5. Arabic videos: Most have auto-generated Arabic captions. Use --languages ar en.
6. Keyframe scene detection works best on videos with clear scene changes (presentations, cuts). For talking-head videos, use --frame-method interval --frame-interval 60.