14 steps to pull transcripts from any YouTube channel, distill them in NotebookLM, and hand structured analysis to Claude Code — near-zero token cost.
This guide is reviewed for clarity, service accuracy, and AI-search readability. The next quarterly content review is tracked internally before unsupported metrics or client proof are added.
The AI Research Pipeline That Replaces a $400–500/mo Stack
Most AI research workflows have the same failure mode. You paste a transcript into Claude, get solid output, then paste another one. By the fifth video you've burned more tokens than a month of a paid tool — and the output is getting worse, not better, as the context fills up.
This happens because Claude doesn't hold memory between turns. Every message resends your entire conversation history from scratch. Dump 50 raw transcripts into context and you're paying that cost on every single exchange.
NotebookLM solves this. It reads everything, synthesizes across sources, and hands you a distilled briefing Claude can actually reason over — without the raw transcript weight. The result is production-ready research analysis at near-zero token cost.
Here is the full 14-step system.
Tool List + Free Tiers
| Tool | Role in the pipeline | Free tier |
|---|---|---|
| yt-dlp | Pulls transcripts from any public YouTube video or channel | Free, open-source |
| NotebookLM (Google) | Loads transcripts as sources, generates briefings and study guides | Free: 100 notebooks, 50 sources each |
| Claude Code | Analyzes NotebookLM output, generates deliverables | Free tier via claude.ai; Pro $20/mo |
| webvtt-py (Python) | Converts raw VTT subtitle files to clean plain text | Free, open-source |
You need Python 3.8+ and a Google account for NotebookLM. Everything else runs locally.
The 14-Step Pipeline
Step 1 — Install yt-dlp
bash# macOS brew install yt-dlp # Any OS via pip pip install yt-dlp # Also install the VTT parser pip install webvtt-py
Verify the install:
bashyt-dlp --version
Step 2 — Test on a single video
Pull one transcript to confirm the setup works before running a batch:
bashyt-dlp --write-auto-sub --sub-format vtt --skip-download "https://www.youtube.com/watch?v=VIDEO_ID" -o "transcripts/%(title)s.%(ext)s"
This downloads only the auto-generated subtitle file in VTT format — no video file. Check your transcripts/ folder for the .vtt output.
Step 3 — Batch-extract transcripts from a channel
bash# Pull transcripts from a creator's full video library yt-dlp --write-auto-sub --sub-format vtt --skip-download "https://www.youtube.com/@CHANNEL_HANDLE/videos" -o "transcripts/%(upload_date)s_%(title)s.%(ext)s" --ignore-errors # Limit to the most recent 50 videos yt-dlp --write-auto-sub --sub-format vtt --skip-download "https://www.youtube.com/@CHANNEL_HANDLE/videos" -o "transcripts/%(upload_date)s_%(title)s.%(ext)s" --ignore-errors --playlist-end 50
--ignore-errors keeps the batch running when individual videos have no captions. Replace CHANNEL_HANDLE with the creator's handle (e.g., @gregisenberg).
Step 4 — Convert VTT files to clean plain text
VTT files contain timestamps and formatting codes that add noise. This script strips them all:
python# convert_vtt.py import webvtt from pathlib import Path input_dir = Path("transcripts") output_dir = Path("transcripts_clean") output_dir.mkdir(exist_ok=True) for vtt_file in input_dir.glob("*.vtt"): try: text = " ".join(caption.text for caption in webvtt.read(str(vtt_file))) out_path = output_dir / vtt_file.with_suffix(".txt").name out_path.write_text(text, encoding="utf-8") print(f"Converted: {vtt_file.name}") except Exception as e: print(f"Skipped {vtt_file.name}: {e}")
Run it:
bashpython3 convert_vtt.py
Your transcripts_clean/ folder now has one plain .txt file per video.
Step 5 — Create a NotebookLM notebook
- Go to notebooklm.google.com
- Click New notebook
- Name it after your research topic — e.g., "AI Productivity — 50 Videos"
Step 6 — Add transcripts as sources
For up to ~10 videos: skip the yt-dlp extraction. Paste YouTube URLs directly into NotebookLM via Sources → Add source → YouTube. NotebookLM pulls the transcript automatically.
For bulk batches (10+ videos) from Step 4:
- Click Sources → Add source → Upload files
- Upload your
.txtfiles fromtranscripts_clean/ - NotebookLM accepts up to 50 sources per notebook
If you have more than 50 videos, split across two notebooks and run Steps 7–14 on each, then merge the briefings manually.
Step 7 — Generate a Briefing Doc
Once sources are loaded:
- Click Notebook guide at the bottom of the Sources panel
- Select Briefing doc
- NotebookLM scans all sources and returns a structured document with key themes, claims, and citations
This takes 30–90 seconds depending on source count.
Step 8 — Generate a Study Guide and FAQ
Still in Notebook guide, also generate:
- Study guide — key concepts and summaries
- FAQ — the most debated or nuanced points across sources
These three documents (Briefing + Study Guide + FAQ) are your distilled research output. They represent everything meaningful from 50 videos in ~3,000–5,000 words.
Step 9 — Export NotebookLM output
Option A — Copy to clipboard: Open each document, select all (Cmd+A / Ctrl+A), copy, paste into a text file.
Option B — Save to Google Docs: Click the three-dot menu on any note → Copy to Google Docs → download as .txt.
Combine all three into one file:
bashcat briefing_doc.txt study_guide.txt faq.txt > notebooklm_output.md
Step 10 — Open Claude Code and load the context
bash# Navigate to your working directory cd ~/research/your-project-name # Copy the NotebookLM export here cp /path/to/notebooklm_output.md . # Open Claude Code claude
In your first message to Claude Code, load the file before giving any instructions:
promptRead notebooklm_output.md carefully, then wait for my instructions.
Step 11 — Run the Pattern Extraction prompt
After Claude confirms it has read the file, paste this:
promptAnalyze the NotebookLM briefing in context and extract the following. Return as structured markdown. **Repeated Frameworks** (mentioned in 3+ sources): - Name, one-line definition, how many sources referenced it **Tactical Specifics** (exact language from sources): - Top 10 most actionable tactics with direct quotes where available **Creator Consensus** (strong agreement across sources): - 3-5 points every source agrees on **Contradictions** (where sources disagree): - Any opposing views or conflicting advice **Underserved Angles** (gaps in the source material): - 2-3 topic angles that appear underexplored Stay grounded in the source material. Do not extrapolate beyond what the briefing states.
Step 12 — Run the Synthesis prompt
promptUsing the pattern analysis above, write the following: Topic: [YOUR TOPIC — e.g., "how AI is changing solo founder research workflows"] Target reader: [YOUR AUDIENCE — e.g., "solo founders learning AI automation"] Unique angle: [WHAT MAKES THIS DIFFERENT — e.g., "practical, not theoretical; cost-first perspective"] Format: [carousel / LinkedIn post / email newsletter / blog post] Length: [e.g., "10 carousel slides" or "800-word post"] Rules: - Every claim must trace back to the source material in context - Flag any opinion or extrapolation with "My take:" - Use the exact frameworks and language patterns found in the sources - Do not invent statistics, quotes, or references not present in the briefing
Step 13 — Validate against sources (hallucination guardrail)
After Claude returns a draft, verify any claim that feels surprising:
promptWhich source in the NotebookLM briefing supports this claim: "[paste the specific claim here]" If no source supports it, remove it from the draft.
This one prompt is your quality gate. Run it on every statistic or bold assertion before publishing.
Step 14 — Update your source library and repeat
Add new transcript files to transcripts_clean/ as you pull more videos. When the topic shifts, create a new NotebookLM notebook. The pipeline scales linearly with no new tools.
Keep a log of what each notebook covers:
prompt# _sources_log.txt notebook: "AI Productivity — 50 Videos" channels: @channel1 (20 videos), @channel2 (30 videos) date_built: 2026-07-03 notebooklm_notebook: [paste notebook URL] output_file: notebooklm_output.md
Why This Uses Near-Zero Tokens
Claude Code resends your entire conversation history on every single turn. Your messages, its responses, every file it read — all of it, every time. This is how transformer models work.
What happens when you skip NotebookLM:
- Average YouTube transcript: ~8,000 words (~10,000 tokens)
- 50 videos × 10,000 tokens = 500,000 tokens loaded into context
- That 500,000-token payload resends with every message
- 20 messages into a research session at API rates = $30–50 for one thread
What happens with this pipeline:
- NotebookLM distills 50 videos into a ~3,000-word briefing
- ~4,000 tokens loaded into Claude Code context
- Same 20-message session = under $0.10 at API rates
- On Claude Code Pro ($20/mo flat): effectively free
NotebookLM does the heavy reading across all sources. Claude Code does the thinking on the distilled output. The split is what makes the economics work.
Stack Comparison
| Tool / Stack | Purpose | Monthly Cost |
|---|---|---|
| Perplexity Pro | AI search + citations | $20/mo |
| ChatGPT Plus | Research + drafting | $20/mo |
| Notion AI | Notes + synthesis | $16/mo |
| Transcript API services | Bulk transcript access | $50–100/mo |
| Dedicated research assistant tools | Automated insight extraction | $100–200/mo |
| yt-dlp + NotebookLM + Claude Code | Full pipeline | $0–20/mo |
The $0 version (free tiers of NotebookLM and Claude Code) covers most solo founder research needs. Claude Code Pro at $20/mo adds longer sessions and higher throughput.
Common Failure Points
1. Videos without auto-captions
yt-dlp skips videos silently when no subtitles exist. Before running a batch, check:
bashyt-dlp --list-subs "https://www.youtube.com/watch?v=VIDEO_ID"
Look for en or en-US in the output. No entry means no transcript is available for that video.
2. NotebookLM's 50-source limit
Each notebook holds 50 sources. For 100+ videos, split across two notebooks and run the full pipeline on each. Merge the two NotebookLM output files before Step 10.
3. Context rot in long Claude Code sessions
When a session runs long, response quality degrades as the context window fills with conversation history. Start a fresh Claude Code session for each new deliverable. Load only notebooklm_output.md — never raw transcripts.
4. Claude extrapolating beyond sources
NotebookLM significantly reduces hallucination by grounding output in source citations. Claude Code can still extrapolate when you ask open-ended questions. Use the guardrail in Step 13 to trace every key claim back to the briefing before publishing.
5. VTT parsing errors
Some auto-generated VTT files have encoding issues that break webvtt.read(). Fallback:
pythonimport re with open(vtt_file, "r", encoding="utf-8", errors="ignore") as f: raw = f.read() # Strip timestamp lines and header text = re.sub(r"d{2}:d{2}:d{2}.d{3}.* ", "", raw) text = re.sub(r"WEBVTT.* ", "", text) text = re.sub(r" {2,}", " ", text).strip()
This handles most malformed VTT files without extra dependencies.
At Hypd, this pipeline is how we research at scale before writing any piece of content — no paid research APIs, no context blowout, no hallucinated stats. The setup takes about 20 minutes the first time. After that, a new 50-video research batch runs in under an hour.
FAQ
Q: Do I need a paid Claude plan to use this?
No. Claude Code is available on the free claude.ai tier with usage limits, and on Claude Pro at $20/mo with higher throughput. Because this pipeline loads only a small NotebookLM briefing into context (not raw transcripts), the per-session token usage is low enough that most researchers stay within free tier limits for daily use.
Q: Can this pipeline work for any niche, not just AI topics?
Yes. yt-dlp works on any public YouTube channel regardless of topic. Swap the channel handle and research question in each step. The pipeline works equally well for marketing, e-commerce, fitness, finance, or any subject where active creators post on YouTube. The only requirement is that the videos have auto-generated captions enabled.
Q: NotebookLM is slow or timing out when I load large files. What helps?
Split transcript TXT files larger than 50,000 words before uploading — NotebookLM processes each source sequentially, and large files slow the briefing generation step. If a 50-source notebook becomes unresponsive, reduce to 20–25 sources per notebook and create a second notebook for the rest. Briefing generation across two smaller notebooks is faster than one overloaded notebook.