Back to blog

NotebookLM · Transcripts · Channels

How to Get a Whole YouTube Channel or Playlist into NotebookLM

NotebookLM takes YouTube links one video at a time. We exported 20 lecture videos as Markdown and packed them into one file under NotebookLM's per-source limit. The counts, Google's published limits, and what we could not test.

· 8 min read · YTAPI

The least tedious route we found is to export the transcripts as Markdown, join them into a few large files, and upload those files instead of one link per video. NotebookLM's help page says one source can hold up to 500,000 words, so 20 lectures of about 1.5 hours each, 180,243 words, fit in a single file. Without a combined file, a channel of hundreds of videos is hundreds of sources, and even the highest plan on Google's page stops at 600.

We make YTAPI, a transcript API, and used it for the export. We did not drive NotebookLM's interface for this post. We cannot, so we did not upload the files and have no screenshots, answer quality or processing times to show. Everything about NotebookLM below comes from Google's help pages, read on November 15, 2026. What we ran ourselves is the export and the counting.

What NotebookLM says about its limits

NotebookLM's help pages now call the product "Gemini Notebook". We use the old name because it is the one most people search for.

From Add or discover new sources for your notebook (read 2026-11-15):

  • Per source: "up to 500,000 words or up to 200MB for uploaded files."
  • Source types include copy and pasted text, Google Docs, PDF, Markdown (md), text (txt), Word (docx), CSV, web URLs and "YouTube URLs of public videos".
  • YouTube sources: "Only public YouTube videos with captions, either user-uploaded or auto-generated, are supported", and "only the text transcript of the video is imported as a source". Videos uploaded less than 72 hours before may not be available, videos without speech are not supported, and there is no length limit "unless the caption file contains over 500,000 words".
  • Why an import can fail, in Google's words: an invalid link, a video that is "potentially unsafe", a missing captions file, or "the video language is not currently supported". The page does not list the supported video languages. It lists languages only for audio import, and we do not assume the two lists match.

From Learn about Gemini Notebook's plans (read 2026-11-15), the usage limits, which the page marks "Subject to Change":

PlanSources per notebook (not counting notes)Notebooks per user
No AI plan (free)50100
Google AI Plus100200
Google AI Pro300500
Google AI Ultra (20 TB)500500
Google AI Ultra (30 TB)600500

Notes are counted separately, at 500 or 600 per notebook. We left out limits we only found on third-party pages.

Two consequences follow from those numbers. A channel of 800 videos does not fit as 800 separate YouTube sources on any plan. And a 50-source free notebook fills up after 50 videos, whatever their length.

The problem the combined file addresses

NotebookLM takes a YouTube video as a source by link, one video per source. For a handful of videos that is fine. For a course or a channel that is one source per video, and each one uses a slot of the source cap. A combined Markdown file turns many videos into one source, so the slot count stops being the limit and the word count becomes the limit.

We have not checked how NotebookLM shows citations from a combined file. Our expectation, which we did not test, is that a citation points into the file, and the title and link we put above each lecture are what tell you which video a passage came from.

What we ran

On November 15, 2026 we took the public playlist Advanced Algorithms (COMPSCI 224) from Harvard University's channel. It has 25 videos. We took the first 20 lectures, 28 hours 23 minutes in total, each between 1:21:34 and 1:28:46.

Requests to the YTAPI API21: 1 playlist page and 20 transcripts
Transcripts returned20 of 20 (HTTP 200)
Time per transcript1.4 to 5.1 seconds, run one after another
Words in total180,243
Words per lecture7,519 to 10,380, 9,012 on average
Text size917 KB
Files after packing1 (all 20 lectures)

We counted words by splitting on whitespace. NotebookLM may count differently, so we left a margin: the script packs files up to 450,000 words, not 500,000.

One caveat on the numbers. Our first attempt stopped partway with a connection timeout from the machine we ran it on, before we added retries. The 21 requests above are the successful run. The whole session, with that failed attempt and the playlist lookups we used to choose a playlist, used somewhat more credits than 21, but not more than 50, counting every request we sent.

The script

This is the script we ran. It lists the playlist, exports each video as Markdown, writes the title and link at the top of each, and packs the videos into files that stay under a word limit.

"""Export the first N videos of a playlist as Markdown; pack into files under a word cap."""
import json, sys, time, urllib.error, urllib.request
from pathlib import Path

API = "https://api.ytapi.dev"
KEY = Path(sys.argv[1]).read_text().strip()      # a file that holds your API key
PL, COUNT, CAP, OUT = sys.argv[2], int(sys.argv[3]), int(sys.argv[4]), Path(sys.argv[5])
H = {"Authorization": f"Bearer {KEY}", "Content-Type": "application/json",
     "User-Agent": "playlist-export/1.0"}   # Python's default User-Agent got HTTP 403 from the API

def call(path, body=None):
    for attempt in range(4):
        req = urllib.request.Request(API + path, data=json.dumps(body).encode() if body else None, headers=H)
        try:
            with urllib.request.urlopen(req, timeout=40) as r:
                return r.read().decode()
        except urllib.error.HTTPError:
            raise
        except Exception:
            time.sleep(2)
    raise SystemExit("network failed")

pl = json.loads(call(f"/v1/playlists/{PL}"))
docs = []
for v in pl["videos"][:COUNT]:
    try:
        md = call("/v1/transcripts", {"video_id": v["video_id"], "format": "markdown", "languages": ["en", "*"]})
    except urllib.error.HTTPError as e:
        print("skip", v["video_id"], e.code)           # no captions: free
        continue
    md = md.split("\n", 1)[1].lstrip()                 # drop "# Transcript: <id>"
    head = f"# {v['title']}\n\nSource: https://www.youtube.com/watch?v={v['video_id']} | Length: {v['length_text']}\n\n"
    docs.append(head + md)

words = lambda s: len(s.split())
parts, cur = [[]], 0
for t in docs:
    if cur + words(t) > CAP and parts[-1]:
        parts.append([]); cur = 0
    parts[-1].append(t); cur += words(t)

(OUT / "combined").mkdir(parents=True, exist_ok=True)
for i, p in enumerate(parts, 1):
    txt = "\n\n---\n\n".join(p)
    (OUT / "combined" / f"playlist-part-{i:02d}.md").write_text(txt)
    print(f"part {i}: {len(p)} videos, {words(txt)} words")

Run it with the playlist ID, the number of videos, the word cap and an output folder:

python3 playlist_to_notebooklm.py key.txt PL2SOU6wwxB0uP4rJgf5ayhHWgw7akUWSf 20 450000 out

It printed part 1: 20 videos, 180243 words. The API's Markdown starts with # Transcript: <video id> and then has a ### [0:12] heading at each timestamp. The script swaps the first line for the lecture title, link and length. The file begins like this:

# Advanced Algorithms (COMPSCI 224), Lecture 1

Source: https://www.youtube.com/watch?v=0JUN9aDxVmI | Length: 1:28:19

### [0:00]
JELANI NELSON: So this is
...

The 20 lectures are separated by lines of ---, and the file has 3,824 timestamp headings.

A playlist call returns up to 100 videos per page, at 1 credit per page. For a channel, list its videos with /v1/channels/{id}/videos and its cursor, and use the batch endpoint for more than a few dozen videos, as in transcripts for a whole channel or playlist.

How many files a bigger set needs

This is arithmetic from our run, not a measurement. Our lectures average 9,012 words. A 450,000-word file holds 49 of them. At that rate 800 lectures of that length would need 17 files. Shorter videos have fewer words each, so the same limit holds more of them. Multiply your own average, which you get from the first export.

Seventeen files is well inside the 50-source free cap. Those 17 files would hold about 7.2 million words in total. We did not test whether NotebookLM handles a notebook that large, and Google's help page does not state a total-size limit for a notebook, only the per-source limits. Check how your notebook behaves with the first few files before you add the rest.

The two other routes

You do not need an API script to get the same file.

  • The dashboard export. In the YTAPI dashboard you paste a playlist or channel URL, choose Markdown, and download a zip. What the zip contains is described in downloading all transcripts from a playlist or channel; we did not rerun that export for this post. Free accounts can export up to 25 videos at a time through the dashboard and the Chrome extension until they buy a credit pack. The API has no 25-video cap.
  • Free tools. If you only need a few playlists and do not mind the setup, free ways to get a playlist's transcripts covers yt-dlp and others.

What it costs, and what can go wrong

The API charges 1 credit per transcript and 1 per page of a playlist or channel list. Videos without captions return 404 and cost nothing. A new account has 200 free credits, and packs start at $9 for 2,000. NotebookLM's own free tier is the 50-source plan in the table above.

Limits we know about:

  • Captions only. A video without captions has no transcript in the export, and NotebookLM's own YouTube import has the same limit, per its help page. Auto-generated captions can also take a while to appear on a new upload.
  • Private, members-only and age-restricted videos fail.
  • Caption errors reach NotebookLM unchanged. Names and jargon are the usual misses, in our export as in YouTube's captions.
  • We did not test NotebookLM. Whether it accepts the file, how long it takes to process and how well it answers across 180,000 words are all untested here. The help page says Markdown files and a 500,000-word source are supported.
  • The file is a snapshot. A new video on the channel is not in it. Export again and add the new part.
  • Respect the channel's rights. The transcripts belong to the people who made the videos. Use them for your own study and notes, and ask before you republish them.

FAQ

Can NotebookLM import a whole YouTube channel by itself?

Google's help page lists "YouTube URLs of public videos" as a source type and describes importing a video's transcript. It does not describe importing a channel or a playlist as one step, and we did not test the interface. Treat each video as one source unless you see otherwise in the app.

What is the file limit per source?

500,000 words, or 200 MB for uploaded files, per Google's help page (read 2026-11-15). Our 20 lectures were 180,243 words and 917 KB.

Do YouTube sources use captions?

Yes. Google says only videos with captions, user-uploaded or auto-generated, are supported, and only the transcript text is imported.

How many sources can a notebook hold?

50 on the free plan, 100 on Plus, 300 on Pro, and 500 or 600 on the two Ultra plans, per Google's plans page (read 2026-11-15). The page says the limits are subject to change.

Does NotebookLM work in other languages?

The help page says a YouTube import fails if "the video language is not currently supported", and gives no list for videos. Check a short video in your language first.

Is there a version for Claude or ChatGPT?

Yes: How to put a whole YouTube channel into a Claude Project or ChatGPT Project covers the same export with token limits instead of word limits. For comparing the bulk downloaders, see seven ways compared.

Sources

Read on November 15, 2026, and checked again on November 19, 2026: