DEV Community: Nidhi

Feed a whole YouTube playlist into Claude or ChatGPT as one file (+ MCP setup)

Nidhi — Mon, 12 Oct 2026 03:08:31 +0000

Paste a YouTube link into Claude and ask for a summary, and one of three things happens: it tells you it can't open the link, it searches the web and summarizes what other people wrote about the video, or it quietly guesses from the title. None of those is the video.

What every assistant can do is read text. So the reliable workflow is:

Get the captions as text.
For a playlist, put all of them in one file in order, with a heading per video.
Upload that file, or connect a transcript tool over MCP so the assistant fetches it on its own.

This post covers both, with the free DIY route first.

How much fits? (do this maths before uploading)

Speech runs at roughly 130–160 words a minute, so one hour of video is about 8,000–10,000 words, or roughly 11,000–13,000 tokens for English. Rough guide:

Playlist	Approx. words	Approx. tokens
10 × 15-min videos	20k	27k
20 × 1-hour lectures	180k	240k
100 × 1-hour lectures	900k	1.2M

Context limits differ by model and plan and change often, so check yours. Two practical rules:

Under your model's context limit: upload the single file and ask questions across the whole playlist.
Over it: upload to a Claude Project or a ChatGPT Project / custom GPT as knowledge files. Those retrieve the relevant parts instead of reading everything at once, so split the playlist into a few files (e.g. one per module) with clear headings.

Step 1 (free): playlist → one file with yt-dlp

pip install yt-dlp
mkdir subs && cd subs
yt-dlp --skip-download --write-subs --write-auto-subs \
  --sub-langs "en.*" --sub-format vtt \
  -o "%(playlist_index)03d - %(title)s.%(ext)s" \
  "https://www.youtube.com/playlist?list=YOUR_PLAYLIST_ID"
cd ..

This downloads only subtitle files (no video), creator captions first, auto-captions otherwise, numbered in playlist order. Run it from a home connection; YouTube often blocks cloud and VPN IPs with a "confirm you're not a bot" error.

Then merge them. Raw .vtt auto-captions repeat each line two or three times, so dedupe while you merge:

import re
from pathlib import Path

TAG = re.compile(r"<[^>]+>")
out = ["# Playlist transcripts\n"]
for f in sorted(Path("subs").glob("*.vtt")):
    lines, last = [], None
    for raw in f.read_text(encoding="utf-8", errors="ignore").splitlines():
        s = TAG.sub("", raw).strip()
        if not s or s == "WEBVTT" or "-->" in s or s.startswith(("Kind:", "Language:")):
            continue
        if s != last:
            lines.append(s)
        last = s
    name = re.sub(r"\.[\w-]+\.vtt$", "", f.name)  # drop ".en.vtt"
    body = " ".join(lines)
    out.append(f"\n## {name}\n\n{body}\n")
Path("playlist.md").write_text("".join(out), encoding="utf-8")
print(len("".join(out).split()), "words")

Step 2: prompt it like a long document, not a video

Headings per video are what make this work. The model can cite "## 007 - Backpropagation" instead of vaguely saying "in one of the videos".

Prompts that use the whole playlist:

"This file has one section per video. For each section, give one line: the main claim and the best example used."
"Where do videos 3 and 11 disagree? Quote both."
"Build a study plan: what to rewatch, in what order, for someone who already knows X."
"Turn the whole series into a checklist I can follow, with the video number next to each step."

Ask it to quote when it matters. Quotes from a transcript are checkable; paraphrases can drift.

Step 3 (optional): let the assistant fetch transcripts itself with MCP

MCP (Model Context Protocol) lets Claude, ChatGPT, Cursor and other clients call external tools. With a YouTube transcript MCP server connected, you can say "get the transcripts for this playlist and compare videos 2 and 5", and the assistant fetches the text itself.

You can self-host an open-source transcript MCP server (several exist on GitHub, most built on youtube-transcript-api). They work well locally, but the same IP blocking applies when you deploy them to a cloud server.

Or use a hosted one. I built YT Transcriber, which has a remote MCP server (disclosure: I'm the maker, a student). The setup is the same pattern for any remote MCP server:

Get a key. Sign in, then Settings → API keys → Create, and copy it once. Then Settings → AI & Automations gives you the MCP server URL with the key included. Treat that URL like a password.
Claude: Customize → Connectors → Add custom connector. Name it, paste the MCP URL, and choose no extra sign-in, since the URL carries the key.
ChatGPT: Settings → Apps → Create MCP app. Paste the MCP URL, authentication: none.
Cursor: Settings → MCP → New MCP server, preferably with the key in a header instead of the URL:

{
  "mcpServers": {
    "yt-transcriber": {
      "url": "https://13-234-185-132.sslip.io/mcp",
      "headers": { "Authorization": "Bearer ytk_YOUR_KEY" }
    }
  }
}

The server exposes five tools: submit_transcripts (video, playlist or channel URLs), list_jobs, get_transcript, export_transcript (txt, md, json, toon, srt, pdf) and check_quota. In the web app, a finished playlist can also be downloaded as one file for this exact workflow, auto-split under 450,000 words between videos.

Honest limits: it reads existing captions (no speech-to-text), so caption-less videos fail. The free tier is 3 videos a day after sign-in, and you can try one video on the homepage without signing in. Whole playlists are $9/month.

Summary

Don't trust a model that says it "watched" a YouTube link. Give it the transcript.
One file per playlist, a heading per video, in playlist order.
Check the size against your model's context; use Projects or knowledge files when it's bigger.
MCP turns "go get the transcript" into something the assistant can do on its own.

How to get around NotebookLM's 50-source limit with YouTube playlists

Nidhi — Mon, 12 Oct 2026 03:08:30 +0000

NotebookLM (Google renamed it Gemini Notebook in July 2026, same product) is one of the best free ways to study from long video courses. You add a YouTube link, it reads the video's captions, and you can ask questions, make flashcards or generate an audio overview.

The problem shows up with real courses. Google's help pages list these limits for the free plan:

50 sources per notebook
500,000 words per source (or 200 MB per uploaded file)

Each YouTube link is one source. A semester course with 120 lectures needs three notebooks, and then you can't ask one question across the whole course.

The fix is in the second number. 50 sources is small, but 500,000 words per source is big. One hour of lecture speech is roughly 8,000–10,000 words of captions, so one source can hold around 45–55 hours of transcript. Turn the playlist into one text file and the course becomes one source, leaving 49 free slots for slides, papers and notes.

Below is the free, do-it-yourself way, then a shortcut if you don't want to touch a terminal.

What you need

Python 3
yt-dlp (pip install yt-dlp)
A playlist whose videos have captions (manual or auto-generated). This method reads captions; it does not transcribe audio, so a video without captions gives you nothing.

Step 1: Download only the captions for the whole playlist

mkdir subs && cd subs
yt-dlp --skip-download --write-subs --write-auto-subs \
  --sub-langs "en.*" --sub-format vtt \
  -o "%(playlist_index)03d - %(title)s.%(ext)s" \
  "https://www.youtube.com/playlist?list=YOUR_PLAYLIST_ID"
cd ..

What the flags do:

--skip-download fetches no video or audio, only subtitle files.
--write-subs --write-auto-subs takes the creator's captions if they exist, otherwise YouTube's auto-captions.
--sub-langs "en.*" picks English tracks. Change en to your language code. If you get the wrong language, run yt-dlp --list-subs URL on one video to see the exact track names.
%(playlist_index)03d puts a 001, 002, ... prefix on each file so the lectures stay in order.

If you get "Sign in to confirm you're not a bot" errors, you're probably on a cloud server or VPN. YouTube blocks many datacenter IPs. Run it from your normal home connection, and add --sleep-requests 1 for big playlists so you don't hammer YouTube.

Step 2: Combine the subtitle files into one clean Markdown file

Raw .vtt files are full of timing lines, formatting tags and, for auto-captions, every line repeated two or three times as the captions "roll". This script strips all of that, keeps the lectures in order under a ## heading each, and starts a new part file only if you go past 450,000 words (a safety margin under the 500k cap). It never cuts a lecture in half.

Save it as combine_subs.py:

#!/usr/bin/env python3
"""Combine every .vtt subtitle file in a folder into one Markdown file per
~450,000 words (under Gemini Notebook / NotebookLM's 500,000-words-per-source cap).
Usage: python3 combine_subs.py ./subs "My Course"
"""
import re, sys
from pathlib import Path

WORD_CAP = 450_000
TAG = re.compile(r"<[^>]+>")            # <00:00:01.234><c> word timing tags
CUE_TIME = re.compile(r"-->")           # 00:00:01.000 --> 00:00:03.000 lines

def vtt_to_text(path: Path) -> str:
    lines, last = [], None
    for raw in path.read_text(encoding="utf-8", errors="ignore").splitlines():
        line = TAG.sub("", raw).strip()
        if (not line or line == "WEBVTT" or CUE_TIME.search(line)
                or line.startswith(("Kind:", "Language:", "NOTE")) or line.isdigit()):
            continue
        if line == last:                # auto-captions repeat each line as they roll
            continue
        lines.append(line)
        last = line
    return " ".join(lines)

def main(folder: str, title: str) -> None:
    files = sorted(Path(folder).glob("*.vtt"))
    if not files:
        sys.exit(f"No .vtt files in {folder}")
    parts, cur, words = [], [f"# {title}\n"], 0
    for f in files:
        name = re.sub(r"\.[\w-]+\.vtt$", "", f.name)   # drop ".en.vtt"
        body = vtt_to_text(f)
        n = len(body.split())
        if words and words + n > WORD_CAP:              # start a new part between videos
            parts.append(cur)
            cur, words = [f"# {title} (continued)\n"], 0
        cur.append(f"\n## {name}\n\n{body}\n")
        words += n
    parts.append(cur)
    for i, p in enumerate(parts, 1):
        out = Path(f"{title} - part {i}.md" if len(parts) > 1 else f"{title}.md")
        out.write_text("".join(p), encoding="utf-8")
        print(f"wrote {out} ({sum(len(x.split()) for x in p):,} words)")

if __name__ == "__main__":
    main(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "Playlist")

Run it:

python3 combine_subs.py ./subs "Intro to Algorithms"
# example output: wrote Intro to Algorithms.md (182,000 words)

Big courses come out as ... - part 1.md, ... - part 2.md, each under the cap.

Step 3: Upload it to NotebookLM as one source

Open your notebook, click Add sources, and upload the .md file. If the upload dialog won't take .md on your account, rename it to .txt; it's plain text either way.
Because every lecture sits under its own ## 001 - Title heading, citations point you to the right lecture.
Use the 49 free slots for the course slides, papers and your own notes.

Prompts that work well on a whole-course source

"Make a one-page outline of the course, one line per lecture, using the lecture headings."
"Which lectures explain dynamic programming? Quote the key sentence from each."
"Write 20 exam-style questions that need ideas from at least two different lectures."

Limits to know (so you're not surprised)

Captions only. If a lecturer writes a formula on the board without saying it, it isn't in the transcript. Add the slides as a separate source.
Auto-captions make mistakes with names and technical terms. Spot-check anything you'll quote.
Timestamps are dropped by this script to save words. If you need to jump back to the exact moment, keep the original .vtt files, or export SRT instead.
Private, members-only and caption-less videos won't work with any caption-based method.

The shortcut (if you'd rather not run scripts)

I built a web tool, YT Transcriber, that does Steps 1 and 2 in the browser: paste a playlist or channel URL and download it as one file for NotebookLM, ChatGPT or Claude, auto-split under 450,000 words between videos. You can try one video on the homepage with no sign-in. With a Google sign-in it's 3 videos a day free, and $9/month for whole playlists. Disclosure: I'm the maker, a student. It reads captions like the script above, so the same limits apply.

The free script works fine too. The point of this post is the trick: one big file beats 50 small links.