NotebookLM, Rewired: How `proyecto26/notebooklm-ai-plugin` Turns Google’s Research App into an Agent Skill

A TypeScript CLI and Claude Code plugin that uses browser-auth plus reverse-engineered RPC calls to let AI agents create NotebookLM artifacts, run deep research, and manage sources without a public API.

8 to 10 min read • View on GitHub • More from proyecto26

A human hand places a small skill card into a mechanical relay while a browser-shaped portal opens beside it. From the portal, a podcast reel, a slide deck, and a mind map emerge as separate physical objects, showing that NotebookLM has become a callable capability instead of a site someone has to visit.
The project’s core move is simple and strange: it turns NotebookLM from a destination into a skill an agent can invoke.
Key Takeaways

NotebookLM as a Skill, Not a Destination

Most NotebookLM tutorials start with the app. This repo starts with a different premise: NotebookLM can be a capability inside an AI loop, not a tab you open and babysit. That shift matters because it changes the unit of work from clicks to delegated tasks.

Bring the full Google NotebookLM experience to Claude Code.

jdnichollsc, Maintainer/Top Contributor · proyecto26/notebooklm-ai-plugin GitHub README

That line from the README is the entire thesis in one sentence. The plugin is not trying to outdo NotebookLM. It is trying to make NotebookLM reachable from the same place an agent already plans, writes, and executes.

The Three-Layer Trick Behind the Plugin

The repo works because a skill layer tells Claude when to act, a CLI routes the command, and the backend machinery handles auth plus private RPC calls.

At a high level, the architecture is clean. `SKILL.md` gives the model instructions. `main.ts` turns intent into commands. The lower layer handles NotebookLM itself, using browser authentication and private RPC calls instead of an official API.

// Simplified flow
const session = await loginWithCDP();
await saveCookies(session.cookies);
const rpc = new RPCClient(session);
const artifact = await generateArtifact({ type: 'mind_map', sourceId });

That division is the repo’s real design choice. It treats the model, the CLI, and the backend as separate layers, which makes the whole thing easier to reason about and easier for an agent to use repeatedly.

Why the Auth Flow Matters More Than It Looks

The authentication flow is not a convenience feature. It is the enabling constraint. By using Chrome DevTools Protocol to authenticate a real Google session and persist cookies locally, the plugin avoids the need for a special partner key or a separate NotebookLM account model.

That matters for one reason: accessibility. An individual developer can use the same Google session they already have, then hand off the rest to the agent. The system is less elegant than a clean OAuth API, but far more practical for a single-user tool.

Inside the Shadow API

Layered transparent sheets show a request being transformed into nested arrays and token fragments, then resolved into a clean downloadable artifact at the edge of the stack. The image explains how an opaque internal response becomes usable without pretending the API is public or simple.
The project’s deepest trick is translation: messy internal responses go in, clean artifact URLs come out.

This is where the project stops looking like a wrapper and starts looking like reverse engineering. The repo parses NotebookLM’s internal `batchexecute` responses, strips the anti-XSSI prefix, extracts CSRF and session tokens, and walks through nested JSON structures that are intentionally not friendly to outsiders.

// Shape, not exact implementation
const body = await response.text();
const cleaned = body.replace(/^\)\]\}'\n/, '');
const parsed = JSON.parse(cleaned);
const url = findUrlInNested(parsed);

The most interesting part is not that this works. It is that the code is built to survive Google’s peculiar response shapes. The repo does not assume a polite API. It hunts for the useful field inside the mess.

Artifacts, Not Just Outputs

NotebookLM does not only make one thing. It can produce multiple artifact types, and the repo treats that as the product layer. `artifact-generator.ts` maps user intent to the exact backend shape each output needs, including the special path for mind maps.

Artifact typeWhat the repo is doingWhy it matters
Audio overviewBuilds a payload that requests a podcast-style outputTurns research into something you can listen to
VideoUses a backend-specific payload shapeShows that the plugin understands Google’s internal expectations
BriefingSelects a compact summary artifactMakes NotebookLM useful for quick review
Mind mapUses a distinct RPC path and structureProves the tool handles nonstandard artifact logic
Source handlingAdds and manages inputs before generationKeeps the workflow anchored in evidence

That table points to the important distinction: the repo is not just calling NotebookLM. It is negotiating with NotebookLM’s artifact system. The work is in matching intent to the backend’s idea of a valid request.

Why This Feels Native to Claude Code

The skill model changes the user experience. A human does not have to remember a command reference and operate every step manually. Claude Code can decide when the skill should run, pass the right parameters, and keep the workflow moving as part of a broader task.

That makes the plugin feel less like a utility script and more like an extension of the agent’s memory. The user asks for research. The model knows when NotebookLM is the right instrument. The repo turns that judgment into action.

How It Compares to notebooklm-py and Other Alternatives

The competition is not really about features. It is about posture. Some tools offer generic programmatic access. This one offers agent-native integration, which is a narrower claim and a stronger one for Claude users.

ProjectInterfaceMain strengthMain tradeoff
`proyecto26/notebooklm-ai-plugin`Claude Code skill plus CLINative agent workflowTied closely to Claude and NotebookLM internals
`notebooklm-py`Python CLI and APIBroad programmabilityLess opinionated about agent orchestration
`notebooklm-sdk`SDKUseful protocol referenceCloser to a library than a workflow layer
`notebooklm-oss`Local servicePrivacy and local controlDifferent product goal entirely

This is why the plugin stands out. It is not trying to be the most portable NotebookLM tool. It is trying to be the most natural one inside Claude Code, and that is a different kind of value.

What This Repo Suggests About the Future of AI Tools

The larger pattern is bigger than NotebookLM. Any web app with a hidden RPC surface, session-based auth, and consistent output structure can become a machine-readable capability. Open-source developers will keep finding these seams, because agents reward tools that can be invoked, not just visited.

That is the real story here. The repo is not just a clever bridge to a Google product. It is a preview of a software world where the most useful tools are the ones an agent can quietly call in the background.