Claude Code + Notebook LM: Onderzoeksstack Zonder Tokenkosten

Drie weken geleden verbrandde ik $4,20 aan Claude API-tokens en produceerde een onderzoeksrapport vol verzonnen statistieken.

Ik was een pipeline aan het bouwen om bij te houden welke AI-vaardigheden trending waren op YouTube — wat ontwikkelaars daadwerkelijk onderwijzen versus wat de arbeidsmarkt vraagt. Het plan leek solide: gebruik Claude Code om YouTube te doorzoeken, videodata op te halen, de inhoud te analyseren en een wekelijks trendrapport te genereren. Na zes uur had ik een prachtig opgemaakt document met citaten naar video's die dingen zeiden die ze nooit daadwerkelijk hadden gezegd.

Dat is de stille faalwijze waar niemand je voor waarschuwt. Claude Code is uitzonderlijk goed in het orkestreren van taken en het samenvatten van gestructureerde data — maar als je het vraagt om YouTube-video-inhoud te analyseren door alleen titels en beschrijvingen te lezen, vult het de gaten op. Zelfverzekerd. Onjuist.

Ik probeerde drie oplossingen. De gratis tier van de YouTube Data API heeft een meedogenloos quotum voor serieus onderzoeksvolume. Betaalde transcriptiediensten waren duur genoeg dat ik het prijzentabblad meteen sloot. Ik probeerde zelfs Claude te vragen om video-inhoud te "afleiden" uit metadatasignalen zoals duur, kanaalautoriteit en titelprecisie. Dat leverde creatieve fictie op.

Wat het daadwerkelijk oploste was iets wat ik als speelgoed had behandeld: Google's Notebook LM. Specifiek de onofficiële Python API waarmee Claude Code programmatisch met Notebook LM kan communiceren. Die combinatie heeft volledig veranderd hoe ik onderzoek aanpak. De tokenkosten daalden naar bijna nul. De onderzoekskwaliteit schoot omhoog. En de hele setup duurde minder dan een uur.

Hier is het complete systeem — elk script, elke stap, en de ene valkuil die me twee dagen kostte om te ontdekken.

Waarom YouTube de Meest Onderbenutte Onderzoeksbron in AI Is

Als je nu iets bouwt in de AI-ruimte, is YouTube mogelijk waardevoller dan elke betaalde onderzoeksdienst die je gebruikt. Tutorial-makers publiceren voortdurend nieuwe content. Kijkcijfers zijn een direct signaal van marktinteresse. Commentaarsecties zijn rauwe, ongefilterde feedback over wat mensen verwarrend vinden en wat ze daarna willen.

Het probleem is toegang tot die data op schaal zonder je hele week aan het bekijken van video's te besteden.

Handmatige beoordeling is uiteraard uitgesloten. Zelfs op 2x snelheid vertegenwoordigen vijftig relevante video's zes tot acht uur werk — en je zou nog steeds aantekeningen maken in een gefragmenteerd systeem, terwijl je patronen over tientallen makers probeert samen te vatten. De officiële YouTube API geeft je metadata maar geen transcripten, en de dagelijkse quotumlimieten zijn specifiek gekalibreerd om serieuze onderzoeksworkflows te frustreren.

Ik gebruik Claude Code voor onderzoek sinds begin 2025. Het gereedschap is echt goed in webzoeken, bestandsorganisatie, het uitvoeren van scripts en het begrijpen van gestructureerde data. Maar voor YouTube-video-inhoud — de daadwerkelijk gesproken woorden in die video's — heeft het een leemte die oplossingen niet netjes vullen.

Precies die leemte is waar Notebook LM thuishoort.

Notebook LM is Google's RAG (Retrieval-Augmented Generation) systeem. Geef het bronnen — PDF's, URL's, YouTube-videolinks — en het bouwt een toegewijd kennisbestand van de daadwerkelijke inhoud. Voor YouTube-video's haalt het automatisch de ondertitels op en indexeert die. Vraag het welke vaardigheden de top 40 AI-tutorials aanbevelen, en het antwoordt op basis van wat die makers daadwerkelijk hebben gezegd, met specifieke citaten.

Het echte inzicht is niet Notebook LM alleen. Het gaat om wat er gebeurt als je Claude Code's orkestratiemogelijkheden koppelt aan Notebook LM's verwerkingsinfrastructuur. Claude handelt de beslissingen af — welke video's te analyseren, welke vragen te stellen, hoe de output te formatteren. Notebook LM doet het zware werk volledig op Google's servers, gratis.

Je Claude API-tokens blijven vrijwel volledig onaangetast. Het dure deel — vijftig videotranscripten lezen en patronen erin vinden — draait extern zonder marginale kosten voor jou.

Maar voordat ik je de setup laat zien, is er een kritieke beperking die alles bepaalt over hoe dit systeem gebouwd moet worden. Ik heb die draad bewust gelaten — we komen er op terug in de eerlijke sectie, en het bespaart je de fout die ik op dag twee maakte.

Hoe de Drielaagse Stack Daadwerkelijk Werkt

Het begrijpen van de architectuur voordat je code aanraakt maakt de implementatie vanzelfsprekend. Drie componenten. Elk handelt af waar het oprecht het beste in is.

Claude Code: De Orkestratielaag

De taak van Claude Code in deze stack is pure orkestratie. Het ontvangt je onderzoeksvraag, beslist welke video's de moeite waard zijn om te analyseren, voert scripts uit, bewaakt de status en formatteert de uiteindelijke output. Het leest nooit videotranscripten direct — die verantwoordelijkheid wordt onmiddellijk gedelegeerd.

Dit is de verschuiving in denken die het hele systeem laat werken. De instinctieve reactie van de meeste mensen is alles in het LLM-contextvenster te laden. Voor transcriptanalyse over tientallen video's is dat het dure verkeerde antwoord. Claude Code is het beste ingezet als de intelligente besluitvormer die werk routeert — niet als de processor die elke berekening zelf uitvoert.

YT-DLP: De Dataverzamelingslaag

YT-DLP is een open-source commandoregelgereedschap dat YouTube-metadata efficiënt en betrouwbaar scrapt. Titel, kanaal, kijkcijfers, duur, uploaddatum, beschrijving en de video-URL — alles wat je nodig hebt om intelligent te filteren voordat je iets uploadt naar Notebook LM.

Die filterstap is belangrijker dan je zou denken. Notebook LM beperkt je tot 50 bronnen per project. Als je die slots verspilt aan video's van lage kwaliteit of verouderde video's, lijdt je analyse eronder. YT-DLP laat je harde filters instellen: minimum kijkcijfers, datumbereik, maximale duur. Een aangepaste Claude Code-vaardigheid gebouwd bovenop YT-DLP handelt dit automatisch af.

Notebook LM: De Analyselaag

Notebook LM verwerkt de daadwerkelijke inhoud. Geef het YouTube-URL's als bronnen, en het haalt de ondertitels op, indexeert ze en bouwt een kennisbestand gebaseerd op wat die video's daadwerkelijk bevatten. Geen hallucinaties over inhoud die het niet heeft gelezen. Geen verzonnen trends.

Het deliverable-systeem is waar Notebook LM zijn plaats in deze stack verdient. Naast eenvoudige vraag-en-antwoord kan het gestructureerde briefingdocumenten, FAQ-compilaties, studiegidsen, flashcard-sets en audio-overzichten genereren — een podcastachtige AI-gegenereerde discussie van al je bronnen. Voor trendonderzoek is het briefingdocument het nuttigst. Voor leerworkflows is het audio-overzicht oprecht interessant.

Tang Ling bouwde de onofficiële Python-bibliotheek notebooklm-pi die programmatische toegang mogelijk maakt. Geen webbrowser vereist. Maak notebooks aan, voeg bronnen toe, activeer het genereren van deliverables, download outputs — allemaal vanuit Python-code die Claude Code automatisch kan uitvoeren.

Dat is het volledige beeld. Laten we het nu bouwen.

Stap 1: YT-DLP Installeren en de Setup Valideren

YT-DLP installeert via pip en werkt onmiddellijk zonder authenticatie voor openbare video's:

pip install yt-dlp

Valideer de installatie door metadata-extractie uit te voeren op een openbare video:

yt-dlp --dump-json --no-download "https://www.youtube.com/watch?v=dQw4w9WgXcQ" | python3 -m json.tool | head -40

Je zou gestructureerde JSON moeten zien met titel, kanaalnaam, kijkcijfers, duur, uploaddatum en andere metadata. Als dat foutloos werkt, is de dataverzamelingslaag klaar.

Stap 2: De Notebook LM API Installeren en Authenticeren

pip install notebooklm-pi

Na installatie, authenticeer via de CLI:

notebooklm-pi login

Dit opent een browservenster voor Google OAuth. Log in met hetzelfde Google-account dat je gebruikt met Notebook LM. Inloggegevens worden lokaal opgeslagen en de bibliotheek handelt tokenvernieuwing automatisch af.

Test de verbinding voordat je workflowcode schrijft:

from notebooklm_pi import NotebookLM

client = NotebookLM()
notebooks = client.list_notebooks()
print(f"Verbonden. {len(notebooks)} bestaande notebooks gevonden.")

Een succesvolle verbinding — zelfs bij nul notebooks — bevestigt dat authenticatie werkte. Als je een auth-fout krijgt, log dan uit en authenticeer opnieuw:

notebooklm-pi logout
notebooklm-pi login

Stap 3: Het YouTube Scrapingscript Bouwen

Maak youtube_research.py aan in je projectmap. Dit script neemt een zoekquery en geeft een gefilterde, gerangschikte lijst van video-URL's terug die klaar zijn voor analyse:

import subprocess
import json
import sys
from typing import List, Dict


def search_youtube_videos(
    query: str,
    max_results: int = 60,
    min_views: int = 5000,
    max_duration_seconds: int = 7200,
    published_after: str = "20250101"
) -> List[Dict]:
    """
    Search YouTube and return filtered video metadata.

    Args:
        query: Search query string
        max_results: Number of results to fetch before filtering
        min_views: Minimum view count to include (filters low-quality content)
        max_duration_seconds: Max video length (7200 = 2 hours)
        published_after: YYYYMMDD format — filters to recent content

    Returns:
        List of dicts with url, title, views, duration, channel, uploaded
    """

    cmd = [
        "yt-dlp",
        f"ytsearch{max_results}:{query}",
        "--dump-json",
        "--no-download",
        "--match-filter", f"view_count >= {min_views}",
        "--date-after", published_after,
    ]

    result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)

    if result.returncode != 0:
        print(f"YT-DLP error: {result.stderr}", file=sys.stderr)
        return []

    videos = []
    for line in result.stdout.strip().split('\n'):
        if not line:
            continue
        try:
            data = json.loads(line)
            duration = data.get('duration', 0) or 0

            if duration > max_duration_seconds:
                continue

            videos.append({
                'url': data['webpage_url'],
                'title': data.get('title', 'Unknown'),
                'channel': data.get('uploader', 'Unknown'),
                'views': data.get('view_count', 0),
                'duration_mins': round(duration / 60, 1),
                'uploaded': data.get('upload_date', 'Unknown'),
            })
        except (json.JSONDecodeError, KeyError):
            continue

    # Sort by view count descending, cap at 50 (Notebook LM source limit)
    videos.sort(key=lambda x: x['views'], reverse=True)
    return videos[:50]


if __name__ == "__main__":
    query = sys.argv[1] if len(sys.argv) > 1 else "Claude Code AI development 2025"
    results = search_youtube_videos(query)

    print(f"\nFound {len(results)} qualifying videos:\n")
    for i, v in enumerate(results, 1):
        print(f"{i}. {v['title']}")
        print(f"   Channel: {v['channel']} | Views: {v['views']:,} | {v['duration_mins']} mins")
        print(f"   URL: {v['url']}\n")

Test het met je daadwerkelijke onderzoeksonderwerp:

python3 youtube_research.py "AI agent frameworks tutorial 2025"

Bekijk de output zorgvuldig. Dit is je controlepunt — het moment waarop je beslist welke video's daadwerkelijk in de analyse horen voordat je ze vastlegt in Notebook LM. Als je irrelevante resultaten ziet, maak je query specifieker of verhoog het minimum aantal kijkcijfers.

Stap 4: Het Notebook LM Analysescript Bouwen

Maak analyze_with_notebooklm.py aan. Dit script maakt een nieuw Notebook LM-project aan, voegt je gefilterde video's toe als bronnen, wacht op indexering en genereert vervolgens analyse:

from notebooklm_pi import NotebookLM
import time
import sys


def analyze_videos(
    video_urls: list,
    notebook_title: str,
    research_question: str,
    output_file: str = "research_output.md"
) -> str:
    """
    Creates a Notebook LM project, adds YouTube sources, generates analysis.

    Args:
        video_urls: List of YouTube video URLs
        notebook_title: Name for the Notebook LM project
        research_question: The specific analytical question to answer
        output_file: Where to save the output

    Returns:
        Path to the saved output file
    """

    client = NotebookLM()

    print(f"Creating notebook: {notebook_title}")
    notebook = client.create_notebook(title=notebook_title)

    print(f"\nAdding {len(video_urls)} video sources...")
    failed = []
    for i, url in enumerate(video_urls, 1):
        try:
            client.add_source(notebook.id, url=url)
            print(f"  [{i}/{len(video_urls)}] Added: {url}")
            time.sleep(1.5)  # Rate limiting — be gentle with the API
        except Exception as e:
            print(f"  [{i}/{len(video_urls)}] Failed: {url} — {e}")
            failed.append(url)

    if failed:
        print(f"\nWarning: {len(failed)} sources failed to add.")

    # Notebook LM needs time to fetch and index video captions
    # 3 minutes handles most batches of 30-50 videos reliably
    print(f"\nIndexing sources (3 minutes)...")
    for i in range(18):
        time.sleep(10)
        print(f"  {(i + 1) * 10}s elapsed...")

    print("\nGenerating briefing document...")
    briefing = client.generate_briefing(notebook.id)

    print("Running targeted analysis...")
    targeted = client.query(notebook.id, research_question)

    output = f"""# Research Report: {notebook_title}

Generated: {time.strftime('%Y-%m-%d %H:%M')}
Sources analyzed: {len(video_urls) - len(failed)} videos

---

## Briefing Document

{briefing}

---

## Targeted Analysis

**Question:** {research_question}

{targeted}
"""

    with open(output_file, "w") as f:
        f.write(output)

    print(f"\nSaved to: {output_file}")
    return output_file


if __name__ == "__main__":
    # Replace with URLs from youtube_research.py
    urls = [
        "https://www.youtube.com/watch?v=EXAMPLE_1",
        "https://www.youtube.com/watch?v=EXAMPLE_2",
        # Add all your filtered URLs here
    ]

    analyze_videos(
        video_urls=urls,
        notebook_title="AI Skills Research — March 2026",
        research_question=(
            "What are the top 10 most-mentioned skills, tools, and frameworks "
            "across all video sources? Include specific tool names, programming languages, "
            "and any emerging trends multiple creators agree on."
        ),
        output_file="research/ai-skills-march-2026.md"
    )

De wachttijd van 3 minuten voor indexering is bewust en niet-onderhandelbaar. Notebook LM heeft die tijd nodig om ondertitels van YouTube op te halen en ze te verwerken in zijn kennisbestand. Sla het wachten over en je queries retourneren lege of onnauwkeurige resultaten — geloof me maar op mijn woord.

Stap 5: Alles Koppelen aan Claude Code

De laatste stap is Claude Code een vaardigheidsbestand geven dat deze scripts verbindt in één conversatieworkflow. Maak .claude/skills/youtube-research.md aan met instructies die Claude vertellen om:

1. Een onderzoeksonderwerp en optionele filters van de gebruiker te accepteren
2. youtube_research.py uit te voeren en de gerangschikte videolijst te tonen
3. Te pauzeren voor optionele gebruikersbeoordeling (je kunt goedkeuren, specifieke video's uitsluiten of filters aanpassen)
4. De analyse uit te voeren met de goedgekeurde URL's
5. De output op te slaan in een gestructureerde research/-map

Zodra de vaardigheid aanwezig is, verloopt de hele workflow conversationeel:

Jij: Onderzoek trending AI agent frameworks op YouTube, afgelopen 6 maanden

Claude Code: [voert youtube_research.py uit]
43 kwalificerende video's gevonden. Topresultaten:
1. "Building Production AI Agents" — 287K views — 45 mins
2. "LangGraph vs CrewAI vs AutoGen" — 194K views — 38 mins
...

Keur deze lijst goed of pas filters aan?

Jij: Ziet er goed uit, voer de analyse uit

Claude Code: [voert analyze_with_notebooklm.py uit]
Notebook aanmaken... 43 bronnen toevoegen... Indexeren (3 min)...
Analyse genereren... Opgeslagen in research/ai-agents-march-2026.md

Van trigger tot opgeslagen output: ongeveer 25-35 minuten totaal, waarvan 3 minuten wachttijd voor indexering.

Pro-tip: De API van Notebook LM stelt functionaliteit bloot die de webinterface verbergt. Vraag Claude Code ook om het genereren van audio-overzichten te activeren na de analyse — je krijgt dan een AI-gegenereerde podcast die alle 40+ video's samenvat. Niet perfect, maar oprecht nuttig voor het verwerken van onderzoek tijdens woon-werkverkeer.

De Eerlijke Versie: Wat Ik Fout Deed en Waar Je Op Moet Letten

Dit is het deel dat de meeste tutorials overslaan.

Mijn eerste onderzoekssessie met dit systeem had nul filtering. Ik vertelde YT-DLP de topresultaten te pakken voor mijn zoekquery zonder minimum kijkcijfers en zonder datumfilter. Notebook LM bereikte zijn limiet van 50 bronnen met een mix van virale clickbait, beginnerstutorials uit 2022 en video's die op zijn best zijdelings relevant waren. Het briefingdocument dat het genereerde was technisch accuraat ten opzichte van die bronnen — en vrijwel compleet nutteloos voor mijn daadwerkelijke onderzoeksvraag.

De analyse bleef verwijzingen oppikken naar tools waar de AI-gemeenschap achttien maanden geleden al voorbij was gegaan. Veel enthousiasme voor dingen die nu als antipatronen worden beschouwd. Het datumfilter en het minimum kijkcijfers zijn geen optionele optimalisaties. Ze zijn het verschil tussen signaal ontvangen en ruis ontvangen.

Tweede probleem: de onofficiële API. Dit is degene die ik had beloofd op terug te komen.

notebooklm-pi is geen officieel Google-product. Tang Ling bouwde het door de interne API-aanroepen van Notebook LM te reverse-engineeren. Google heeft het niet gesanctioneerd, heeft zich niet gecommitteerd aan het stabiel houden van die endpoints, en kan de bibliotheek kapotmaken met elke Notebook LM-update. Ik heb deze workflow drie weken lang zonder storing uitgevoerd — maar drie weken is geen trackrecord. Als je dit bouwt in iets kritisch (een klantgerichte geautomatiseerde rapport, een gepland nieuwsbrief, iets waarbij falen echte zakelijke consequenties heeft), bouw dan een fallback en monitor de GitHub-repo van de bibliotheek regelmatig.

Voor persoonlijk onderzoek en interne projecten? Het risicoprofiel is acceptabel. Voor productiesystemen? Voeg een menselijk controlepunt toe.

Nog één eerlijk punt: de limiet van 50 bronnen is een echte beperking die je onderzoeksontwerp bepaalt. Je kunt Notebook LM niet "alle AI YouTube-content uit 2025" voeden. Je moet specifiek zijn over je vraag voordat je begint. Ik heb gemerkt dat deze beperking eigenlijk gezond is — het dwingt tot onderzoeksprecisie. Een strakke, goed gefilterde vraag produceert dramatisch betere output dan een vage brede vraag.

Waar dit allemaal naartoe gaat

Dit patroon — een lichtgewicht AI-orchestrator die dure verwerking routeert naar gratis externe infrastructuur — gaat bepalen hoe slimme ontwikkelaars de komende jaren AI-workflows bouwen. De neiging om alles in het contextvenster van één LLM te stoppen is duur en vaak onnodig.

De betere neiging is vragen: welke delen van deze workflow vereisen daadwerkelijk dure AI-intelligentie, en welke delen kunnen worden gedelegeerd aan doelgerichte infrastructuur? In deze stack handelt Claude Code de strategische beslissingen af. Notebook LM handelt de zware berekeningen af. De splitsing is helder en de kostenbesparingen zijn reëel.

Dat is geen oplossing. Dat is architectuur.

Hoe de Cijfers Er Daadwerkelijk Uitzien

Voor deze workflow:

• Tokenkosten per onderzoekssessie: $4-6 aan Claude API-gebruik
• Tijd om te voltooien: 5-6 uur inclusief handmatige videobeoordeling en notitiasynthese
• Video's geanalyseerd: 8-12 (degene die ik redelijkerwijs handmatig kon beoordelen)
• Outputkwaliteit: Richtinggevende inzichten die ik zou afzwakken met "gebaseerd op wat ik observeerde"

Na het implementeren van deze stack:

• Tokenkosten per onderzoekssessie: $0,10-0,30 (alleen Claude Code-orkestratie)
• Tijd om te voltooien: 25-40 minuten inclusief de indexeringswachttijd
• Video's geanalyseerd: 40-50 per sessie
• Outputkwaliteit: Gefundeerde beweringen met specifieke citaten over welke video wat zei

De kwaliteitsverbetering is het deel dat ik niet volledig had voorzien. Wanneer een onderzoeksrapport zegt "drie van de vijf meest bekeken tutorials over dit onderwerp bevalen expliciet framework X aan boven Y, met vermelding van reden Z" — dat is een bewering waar ik achter kan staan. De oude rapporten waren indrukken. Dit zijn bevindingen.

Het onverwachte voordeel: de audio-overzichtsfunctie van Notebook LM veranderde vijftig tutorialvideo's in een twintig minuten durende AI-gegenereerde podcast. Ik luisterde naar de eerste op een wandeling. Het vereenvoudigt hier en daar te veel, maar voor een hoog-niveau oriëntatie op een nieuw onderzoeksonderwerp? Het werkt beter dan ik verwachtte.

Voor mijn specifieke gebruik — wekelijkse AI-vaardighedentrendtracking — draait de workflow nu op een maandagschema. Tegen de tijd dat ik klaar ben met mijn eerste koffie, wacht er een nieuw trendrapport in mijn /research-map. De consistentie alleen al heeft veranderd hoe ik contentstrategie aanpak.

Één Onderzoekssessie Deze Week

Dit is wat ik wil dat je hiermee doet: kies één onderzoeksvraag die je steeds uitstelde omdat het te tijdrovend voelde. Marktonderzoek naar een techonderwerp, concurrentieanalyse van wat tutorial-makers in jouw niche onderwijzen, trendtracking voor een vaardigheidsrubriek waarover je wilt schrijven.

Bouw deze week één iteratie van deze workflow handmatig. Niet het volledige geautomatiseerde systeem. Één sessie, handmatig gestart, met behulp van de scripts uit dit bericht. Kijk hoe de output zich verhoudt tot wat je zelf in hetzelfde tijdvenster zou produceren.

Ik draaide mijn eerste sessie op een dinsdagmiddag met veertig minuten tussen vergaderingen. De output verraste me genoeg dat ik de volgende twee uur annuleerde en die besteedde aan het bouwen van het vaardigheidsbestand om het herhaalbaar te maken. Het bewijs was zo duidelijk.

Wat begon als een frustrerende tokenrekening en een gehallucineerd rapport eindigde als iets dat dichter bij een echte onderzoeksassistent ligt — een die op zijn eigen schema draait, bijna niets kost en elke bewering grondvest in daadwerkelijke video-inhoud.

De intelligentie van Claude Code plus de grondverankering van Notebook LM verandert het kwaliteitsplafond van wat mogelijk is met dit soort onderzoek. Geen van beide tools alleen brengt je daar. Samen vormen ze een oprecht ander soort systeem.

Bouw de eerste versie. Voer het uit tegen één echte vraag. Vertel me dan wat je vindt — ik ben oprecht nieuwsgierig welke onderwerpen mensen als eerste verkennen.

🤝 Laten We Samenwerken

Op zoek naar het bouwen van AI-systemen, het automatiseren van workflows of het opschalen van je technische infrastructuur? Ik help je graag.

• 🔗 Fiverr (maatwerk & integraties): fiverr.com/s/EgxYmWD
• 🌐 Portfolio: mejba.me
• 🏢 Ramlit Limited (enterprise-oplossingen): ramlit.com
• 🎨 ColorPark (design & branding): colorpark.io
• 🛡 xCyberSecurity (beveiligingsdiensten): xcybersecurity.io