Anything to NotebookLM: a Claude Code skill that turns 15+ source types into podcasts, slides and mind maps

The gap this fills: NotebookLM has no good front door for messy sources

NotebookLM accepts documents. It does not accept a WeChat article URL, a Xiaoyuzhou episode link, a Twitter thread, or a scanned PDF sitting in a folder. Someone has to fetch that material, convert it to text NotebookLM can index, upload it, and then ask for the output format they wanted. That person is usually you, doing it by hand, once per item.

This project is that middle layer, packaged as a Claude Code Skill. The README frames the whole thing as a natural-language contract: you say "turn this WeChat article into a podcast" or "analyze this book", and the skill decides what kind of source it is looking at, calls the right fetch path, uploads the result to NotebookLM, and downloads the generated artifact. The audience is narrow and specific: people who already live in Claude Code, already use NotebookLM, and keep hitting sources that neither tool handles on its own. If you only ever feed NotebookLM a clean PDF you exported yourself, this adds nothing.

How the pipeline is wired: skill, MCP tools, and a six-level paywall cascade

The architecture in the README is a fan-out from a single decision point. Claude Code reads the user's sentence, classifies the input (a mp.weixin.qq.com URL, a xiaoyuzhoufm.com episode, an x.com status, a youtube.com watch link, a local .epub path, or a search phrase), and dispatches to one of four backends: a WeChat MCP server that drives a browser, the paywall bypass module, a podcast transcription path that calls the Get笔记 API, and markitdown for local file conversion. Everything converges on NotebookLM, which does the actual generation.

The paywall module is the most documented piece and the one worth scrutinising. It is a cascade of six strategies, tried in order: proxy services (r.jina.ai and defuddle.md), then site-specific crawler user agents (Googlebot for roughly 50 sites, Bingbot for about 4), then a generic bypass combining UA spoofing, X-Forwarded-For, Referer spoofing, AMP pages and an EU IP, then archive.today with CAPTCHA detection, then Google Cache, then a local tool called agent-fetch. The README credits Bypass Paywalls Clean for the techniques and lists the covered outlets by country, from NYT and WSJ through FT, Spiegel, Le Monde and SCMP.

That ordering is a real design decision, not a detail. It means the cheapest and least invasive attempt happens first, and the fallbacks get progressively more fragile. It also means a single article can silently travel through a third-party proxy before anyone decides whether that is acceptable. The README does not discuss what happens to the fetched text on those proxies.

Installing the skill and running your first conversion

The README states the prerequisites are Python 3.9+ and Git, and that everything else is installed by a script. The skill is expected to live inside the Claude Code skills directory, so the clone target matters: cloning it somewhere else means Claude Code will not discover it.

cd ~/.claude/skills/
git clone https://github.com/joeseesun/qiaomu-anything-to-notebooklm
cd qiaomu-anything-to-notebooklm
./install.sh

After install.sh finishes, the README says to configure MCP as prompted and restart Claude Code. Then NotebookLM authentication, which the README describes as a one-time step:

notebooklm login
notebooklm list

The second command is the verification: it should print your existing notebooks. If it errors, the login did not take and nothing downstream will work. There is also an environment check script that the README marks as optional:

./check_env.py

Podcast transcription through Xiaoyuzhou, Ximalaya or Bilibili needs a separate credential pair from the Get笔记 API, exported as environment variables:

export GETNOTE_API_KEY="your_api_key"
export GETNOTE_CLIENT_ID="your_client_id"

With that in place, a first real run is a single sentence in Claude Code, for example asking it to turn a paywalled article URL into a podcast. The README's worked example reports the output landing at /tmp/article_podcast.mp3, and the podcast-to-PPT example reports /tmp/podcast_slides.pdf at 25 pages. Treat those paths as the convention the skill follows, not as a guarantee about page counts.

Where it breaks: bypass fragility, third-party dependencies and silent failure

The paywall cascade is a moving target by construction. It depends on publishers continuing to serve full text to Googlebot, on archive.today having a snapshot, on Google Cache still existing for that URL, and on AMP versions remaining weaker than the canonical page. Any of those assumptions can change for one site without affecting the others, which is exactly the failure mode that is hardest to notice. The README does not document per-site status, does not describe a way to force a specific level, and does not say what the skill returns when all six levels fail. That last omission matters: a partial fetch that looks like success is worse than a clean error, because the generated podcast will be based on a truncated article and nothing will flag it.

There is a second dependency problem. The requirements.txt pins fastmcp, playwright, beautifulsoup4, lxml and markitdown[all], but the NotebookLM client itself is commented out with a note that it will be installed from PyPI if available or from git. In other words, the single most important dependency is the one the manifest does not pin. The README also does not document rollback, version pinning for the skill itself, or what an upgrade does to an existing install.

Finally, the paywall feature is a legal and ethical question the README answers only technically. It lists the covered publishers and the techniques. It does not discuss terms of service, and the MIT licence on this repository says nothing about the rights attached to the articles you pull through it.

Compared with running the NotebookLM client directly

The obvious alternative is to skip the skill and use a NotebookLM client or MCP server on its own. The difference is where the work sits. A client library gives you programmatic access to notebooks: create, list, add sources, trigger generation. You still write the code that fetches a WeChat article, converts an EPUB, or transcribes a Xiaoyuzhou episode, and you still decide what to do when a fetch returns a paywall stub instead of an article.

This project's value is precisely that it has already made those decisions, including the opinionated six-level cascade and the source-type classifier. The trade-off is control. With a bare client you know exactly which HTTP requests leave your machine. With this skill you get a chain of fallbacks you did not write and cannot easily inspect from the outside, plus a WeChat path that drives a real browser via MCP. If your sources are all clean local files, the client alone is less machinery for the same result. If most of your sources are URLs behind logins or paywalls, the skill is doing work you would otherwise have to build and maintain yourself.

Maintenance, licence and what MIT does not cover

The repository is not archived, and the last push was on 2026-04-28. The two releases are v1.0.0 and v1.0.1, both dated 2026-01-25, the second being a rename to Anything to NotebookLM. So the release history is short and the version number has not moved past a patch since January, while the last commit is roughly three months later. That pattern is consistent with active tinkering between releases rather than a maintained release cadence, and anyone depending on it should plan to track main rather than wait for tags.

The MIT licence covers this repository's code. It does not cover the content you retrieve with it, and it does not cover the NotebookLM service, which has its own terms. The README's paywall section is a description of technique, not a grant of rights to the underlying articles. If you plan to use this inside a company, the question to settle is not the licence of the skill; it is whether routing article text through r.jina.ai, defuddle.md and archive.today is permitted by your data-handling rules, and whether the publishers you target permit automated retrieval at all.

Editorial conclusion

Adopt it if you already run Claude Code, already have a NotebookLM account, and your main bottleneck is getting awkward sources (WeChat, paywalled news, EPUB, podcast audio) into a notebook as clean text. Do not adopt it if you need a supported, stable ingestion API, if you cannot accept that paywall bypass may break per site at any time, or if your compliance rules forbid routing article text through r.jina.ai and archive.today. Before committing, run ./check_env.py after ./install.sh, confirm notebooklm login and notebooklm list return your notebooks, and test the one source type you actually care about end to end, because the README documents the happy path for each source but not what happens when a specific site's bypass level fails.

Frequently asked questions

Official sources

1. Issues
2. joeseesun/qiaomu-anything-to-notebooklm on GitHub
3. License: MIT
4. README
5. Releases