Skip to content
Back to search

notebooklm

Automate Google NotebookLM at scale. Citation-backed Q&A, full Studio generation (audio, video, infographic, report, presentation, data table), multi-account rotation with auto-reauth, and batch_to_vault for offline RTFM-ingestable answer caching.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/roomi-fields/notebooklm-mcp with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/roomi-fields/notebooklm-mcp'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/roomi-fields--notebooklm-mcp/badge.svg)](/listings/roomi-fields--notebooklm-mcp)

HTML

<a href="/listings/roomi-fields--notebooklm-mcp"><img src="/api/listings/roomi-fields--notebooklm-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Option 0 — Claude Code marketplace (one-liner, recommended for Claude Code users)

The fastest way to get NotebookLM into Claude Code. Distributed via the [`roomi-fields/claude-plugins`](https://github.com/roomi-fields/claude-plugins) marketplace alongside [RTFM](https://github.com/roomi-fields/rtfm) (the retrieval companion — see [RTFM integration guide](./deployment/docs/14-RTFM-INTEGRATION.md)):

/plugin marketplace add roomi-fields/claude-plugins
/plugin install notebooklm@roomi-fields

That registers the MCP server **and the `notebooklm` agent skill**, runs `npx -y @roomi-fields/notebooklm-mcp@<pinned-version>` automatically (Node ≥ 22 required), and lets you upgrade with two commands when a new release ships: `/plugin marketplace update roomi-fields` then `/reload-plugins`. Then run `npx -y -p @roomi-fields/notebooklm-mcp notebooklm-mcp-setup-auth` once in a terminal to log into Google (a visible Chrome opens). To install RTFM at the same time: `/plugin install rtfm@roomi-fields`.

Option 1 — HTTP REST API (n8n, Zapier, Make, curl, any HTTP client)

git clone https://github.com/roomi-fields/notebooklm-mcp.git
cd notebooklm-mcp
npm install && npm run build
npm run setup-auth   # One-time Google login
npm run start:http   # Start REST API on port 3000
# Citation-backed Q&A, single curl, JSON response
curl -X POST http://localhost:3000/ask \
  -H 'Content-Type: application/json' \
  -d '{"question": "Summarize chapter 3", "notebook_id": "your-id", "source_format": "json"}'

The full surface is **33 documented endpoints** — see the [REST API reference](https://notebooklm.roomi-fields.com/notebooklm-rest-api). For overnight batches of 1 000+ questions, see the [batch pattern](https://notebooklm.roomi-fields.com/batch-1000-questions).

Option 2 — MCP Mode (Claude Code, Cursor, Codex)

# Build (same package, MCP transport)
git clone https://github.com/roomi-fields/notebooklm-mcp.git
cd notebooklm-mcp
npm install && npm run build

# Claude Code
claude mcp add notebooklm node /path/to/notebooklm-mcp/dist/index.js

# Cursor — add to ~/.cursor/mcp.json
{
  "mcpServers": {
    "notebooklm": {
      "command": "node",
      "args": ["/path/to/notebooklm-mcp/dist/index.js"]
    }
  }
}

**Log in once — in a terminal, not through the assistant.** Run the interactive Google login as a command; a visible Chrome window opens, you sign in, and the saved session is then reused by the MCP server:

npm run setup-auth          # from a clone (Option 2 above)
notebooklm-mcp setup-auth   # from a global install (npm i -g @roomi-fields/notebooklm-mcp)

Do the login in a terminal rather than by asking the assistant _"log me in"_: some stdio MCP clients (e.g. Claude Desktop) cap tool-call duration and cut off the up-to-10-minute interactive login before you can finish signing in (see [issue #27](https://github.com/roomi-fields/notebooklm-mcp/issues/27)).

Option 2b — MCP over HTTP (containers, remote clients)

Clients that cannot spawn a local process — an AI in **another Docker container**, a hosted agent, a workflow runner — reach the **same MCP tools** over streamable HTTP. Start the HTTP server (Option 1) and point the client at `/mcp`:

{
  "mcpServers": {
    "notebooklm": {
      "type": "http",
      "url": "http://localhost:3000/mcp"
    }
  }
}

Stateless, and behind the same auth as the REST API: set `NOTEBOOKLM_API_KEY` and the client sends `Authorization: Bearer <key>`; leave it unset on a trusted container network and it works without one ([issue #42](https://github.com/roomi-fields/notebooklm-mcp/issues/42)).

Option 3 — Docker (NAS, server, headless)

# Build and run
docker build -t notebooklm-mcp .
docker run -d --name notebooklm-mcp -p 3000:3000 -p 6080:6080 -v notebooklm-data:/data notebooklm-mcp

# Authenticate via noVNC
# 1. Open http://localhost:6080/vnc.html

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/plugin.json · Manifest · 20 lines
  1. {
  2. "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
  3. "name": "notebooklm",
  4. "version": "4.11.1",
  5. "description": "Automate Google NotebookLM at scale. Citation-backed Q&A, full Studio generation (audio, video, infographic, report, presentation, data table), multi-account rotation with auto-reauth, and batch_to_vault for offline RTFM-ingestable answer caching.",
  6. "author": {
  7. "name": "roomi-fields",
  8. "url": "https://github.com/roomi-fields"
  9. },
  10. "homepage": "https://notebooklm.roomi-fields.com/",
  11. "repository": "https://github.com/roomi-fields/notebooklm-mcp",
  12. "license": "MIT",
  13. "keywords": ["notebooklm", "gemini", "citations", "research", "studio", "qa", "rag", "rtfm"],
  14. "mcpServers": {
  15. "notebooklm": {
  16. "command": "npx",
  17. "args": ["-y", "@roomi-fields/notebooklm-mcp@4.11.1"]
  18. }
  19. }
  20. }
README.md · README · 472 lines
  1. <div align="center">
  2. # NotebookLM REST API + MCP server
  3. **Automate Google Gemini Notebook — formerly, and still widely known as, NotebookLM — at scale. 62-endpoint HTTP REST API for n8n / Zapier / Make / curl, an MCP server for Claude Code / Cursor / Codex, a UTCP interface for clients that call the API natively, and Rust and Ruby clients. Citation-backed Q&A, full Studio generation (audio · video · infographic · report · presentation · data table), multi-account rotation with auto-reauth across personal and Google Workspace accounts.**
  4. > v4.11.1 — **Node 22 is now the floor, and the last four open advisories are gone with it.** The declared floor of Node 18 had quietly become fiction: three production dependencies already required Node 20 or newer, and the test matrix kept passing on 18 without exercising them. Raising it also let the third-party file globber go — its dependency chain carried four advisories with no fix upstream — replaced by Node's built-in search, now actually under test. Builds on **4.0.0**, where the HTTP API stopped being open to the network and to any web page ([GHSA-p69m-c5rf-g2c3](https://github.com/roomi-fields/notebooklm-mcp/security/advisories/GHSA-p69m-c5rf-g2c3)): it binds loopback, refuses unlisted origins, and takes a bearer token — **remote access and Docker require `NOTEBOOKLM_API_KEY`**, see [Securing the HTTP API](./deployment/docs/15-SECURITY.md). Built on a **dual transport** — the internal `batchexecute` RPC API (10-100× faster than scraping, immune to UI rebrands) with the Playwright browser as an automatic fallback. See the [changelog](./CHANGELOG.md).
  5. > **Note (July 2026):** Google rebranded **NotebookLM** to **Gemini Notebook**. It is the same product, existing links redirect, and this project drives the same underlying service — the browser path was updated for the new DOM in v2.3.0 and the RPC path in v3.0.0. Package and repository keep the `notebooklm` name.
  6. <!-- Badges -->
  7. [![CI](https://github.com/roomi-fields/notebooklm-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/roomi-fields/notebooklm-mcp/actions/workflows/ci.yml) [![npm version](https://badge.fury.io/js/%40roomi-fields%2Fnotebooklm-mcp.svg)](https://www.npmjs.com/package/@roomi-fields/notebooklm-mcp) [![npm downloads](https://img.shields.io/npm/dm/@roomi-fields/notebooklm-mcp.svg)](https://www.npmjs.com/package/@roomi-fields/notebooklm-mcp) [![crates.io](https://img.shields.io/crates/v/notebooklm.svg)](https://crates.io/crates/notebooklm) [![docs.rs](https://img.shields.io/docsrs/notebooklm)](https://docs.rs/notebooklm) [![Gem Version](https://img.shields.io/gem/v/notebooklm.svg)](https://rubygems.org/gems/notebooklm) [![codecov](https://codecov.io/gh/roomi-fields/notebooklm-mcp/branch/main/graph/badge.svg)](https://codecov.io/gh/roomi-fields/notebooklm-mcp) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue.svg)](https://www.typescriptlang.org/) [![Node.js](https://img.shields.io/badge/Node.js->=22-green.svg)](https://nodejs.org/)
  8. [![MCP](https://img.shields.io/badge/MCP-compatible-green.svg)](https://modelcontextprotocol.io/) [![UTCP](https://img.shields.io/badge/UTCP-compatible-blue.svg)](https://www.utcp.io/) [![Claude Code](https://img.shields.io/badge/Claude_Code-MCP-8A2BE2)](https://claude.ai/claude-code) [![n8n](https://img.shields.io/badge/n8n-HTTP_API-orange)](./deployment/docs/04-N8N-INTEGRATION.md) [![GitHub](https://img.shields.io/github/stars/roomi-fields/notebooklm-mcp?style=social)](https://github.com/roomi-fields/notebooklm-mcp) [![MCP Toplist](https://mcptoplist.com/badge/io.github.roomi-fields%2Fnotebooklm-mcp.svg)](https://mcptoplist.com/server/io.github.roomi-fields%2Fnotebooklm-mcp) [![LightNow capabilities](https://lightnow.ai/badge/io.github.roomi-fields/notebooklm-mcp)](https://lightnow.ai/servers/io.github.roomi-fields/notebooklm-mcp)
  9. <!-- End Badges -->
  10. </div>
  11. ---
  12. > **Unofficial project — good to know before you start**
  13. >
  14. > This is not affiliated with Google. It talks to the same `batchexecute`
  15. > endpoints the NotebookLM web app uses, with a browser fallback when they move.
  16. > They are undocumented, so they can change without notice — when that happens we
  17. > ship a fix, as we have for every change so far.
  18. >
  19. > Two practical notes: use a **dedicated Google account** for automation, and
  20. > expect NotebookLM's own quotas to apply at high volume. See
  21. > [Disclaimer](#disclaimer) for the full text.
  22. ---
  23. ## What You Can Build
  24. 🔗 **No-code automation pipelines** — The 62-endpoint REST API means NotebookLM becomes a step in n8n, Zapier, Make, or a plain `curl` in cron. No agent, no MCP client, no Node in your stack — just HTTP. This is the half most NotebookLM libraries don't have.
  25. 🤖 **Agent tooling** — The same engine over MCP for Claude Code, Cursor and Codex, with a bundled skill that primes the agent on citation formats, the daily-quota-aware batch pattern, and transport selection.
  26. 📚 **Research at volume** — Multi-account rotation with automatic re-authentication, built for overnight runs of 1 000+ questions across several notebooks without babysitting.
  27. 🎙️ **Full Studio generation** — Audio overviews, video, infographics, reports, presentations, data tables, plus flashcards, quizzes and mind maps — generated and downloaded programmatically.
  28. ## Use Cases & Recipes
  29. NotebookLM is a **grounded** engine: Gemini reads your sources and answers _from them_, with citations. The winning pattern is to let it do the expensive reading while your own stack handles orchestration and the last mile.
  30. **Spend fewer tokens — offload the reading**
  31. - **🪙 Zero-token synthesis layer** — Drop 30 documents in a notebook, let Gemini do the heavy analysis, and spend your agent's context only on the final polish. The reasoning happens server-side; your agent just orchestrates (`add_notebook` → `source_add` → `notebook_ask`).
  32. - **💾 Answer cache you can re-read offline** — `vault_batch` writes every answer to disk as structured JSON against a published [schema](https://schemas.roomi-fields.com/nblm-answer-v1.json), so a batch run becomes a corpus you can grep, diff, re-index, or feed to a retrieval layer — without re-querying and re-spending quota.
  33. **Wire it into things that aren't agents**
  34. - **⚙️ NotebookLM as an n8n / Zapier / Make step** — Because it speaks plain HTTP, a citation-backed answer becomes one node in a workflow: a form submission triggers a question, the cited answer lands in a sheet, a Slack message, or a database. No agent runtime involved.
  35. - **📄 Document intake pipeline** — Watch a folder or an inbox, push new PDFs and URLs in as sources, and ask a standing set of questions against them on every arrival.
  36. **Grounded answers with a paper trail**
  37. - **🔍 Citations with the actual source text** — Answers come back with source names _and the quoted excerpts_ they rest on, extracted from the citation panel — so a claim can be checked, not just attributed.
  38. - **🎓 Literature review at thesis scale** — Batch 100+ research questions across multiple notebooks, rotate accounts as daily quotas run out, and resume where it stopped. Built for, and tested on, exactly this.
  39. **Get artifacts back out**
  40. - **🔁 One source set, every format** — Fan a single notebook out to a podcast, a video, a slide deck, a report, a quiz and a mind map, then download them all locally.
  41. ---
  42. ## In the Wild
  43. Real deployments, not hypotheticals.
  44. - **📚 A doctoral literature review at batch scale** — The project was built for, and is
  45. continuously tested on, overnight runs of **1 000+ research questions** spread across
  46. several notebooks: multi-account rotation picks up when a daily quota runs out, every
  47. answer is written to disk with its citations, and an interrupted run resumes instead of
  48. starting over. The batch pattern in [`vault_batch`](#features) exists because a thesis
  49. needed it.
  50. - **🔌 Replacing a RAG engine with the REST API** — [`musnymubarak/Calim_Doc`](https://github.com/musnymubarak/Calim_Doc)
  51. swapped a Gemini-based retrieval engine for this project's HTTP API, running it as a
  52. Docker service (`notebooklm:3000`) behind a full client and worker layer. A good
  53. illustration of the REST half: no agent runtime, no MCP client — NotebookLM simply
  54. became a backend service their Python app calls.
  55. Built something with it? Open an issue — this section is for other people's work.
  56. ## Features
  57. ### Q&A with Citations
  58. - **Ask questions** to NotebookLM and get accurate, citation-backed answers
  59. - **Source citation extraction** with 5 formats: none, inline, footnotes, json, expanded (97% excerpt success rate)
  60. - **Session management** for multi-turn conversations with auto-reauth on session expiry
  61. ### Content Generation
  62. Generate multiple content types from your notebook sources:
  63. | Content Type | Formats | Options |
  64. | ------------------ | ------------------------ | ---------------------------------------------- |
  65. | **Audio Overview** | Podcast-style discussion | Language (80+), custom instructions |
  66. | **Video** | Brief, Explainer | 6 visual styles, language, custom instructions |
  67. | **Infographic** | Horizontal, Vertical | Language, custom instructions |
  68. | **Report** | Summary, Detailed | Language, custom instructions |
  69. | **Presentation** | Overview, Detailed | Language, custom instructions |
  70. | **Data Table** | Simple, Detailed | Language, custom instructions |
  71. | **Flashcards** | Study cards | Language, custom instructions |
  72. | **Quiz** | Assessment questions | Language, custom instructions |
  73. | **Mind Map** | Interactive node graph | Saved to the notebook |
  74. **Video Visual Styles**: classroom, documentary, animated, corporate, cinematic, minimalist
  75. **Language of generated content**: pass `language` to any generator — a BCP-47 code (`es`, `ja`, `pt_BR`, `zh_Hans`) or a name in English or in the language itself (`"Spanish"`, `"Español"`). 81 languages are accepted, and an unrecognised one is refused rather than quietly swapped for another. Set a default with `NOTEBOOKLM_CONTENT_LANGUAGE`; it is deliberately independent of `NOTEBOOKLM_UI_LOCALE`, which only picks the interface language the browser fallback reads.
  76. Flashcards and quizzes are generated via `generate_study_aid`; mind maps via `generate_mind_map`. v3 also adds `share_notebook`, `manage_labels`, and `research_sources` (web/Drive source discovery) — see the [changelog](./CHANGELOG.md).
  77. ### Content Download
  78. - **Download Audio** — WAV audio files
  79. - **Download Video** — MP4 video files
  80. - **Download Infographic** — PNG image files
  81. - Text-based content (report, presentation, data_table) is returned in the API response
  82. - **Delete generated content** (`content_delete`) — until now a notebook accumulated every draft anyone ever asked for, with no way to remove one short of the web UI
  83. ### Source Management
  84. - **Add sources**: Files (PDF, TXT, DOCX, audio, images), URLs, Text, YouTube videos, Google Drive
  85. - **List sources**: Every source with its ID and title (`source_list`)
  86. - **Rename a source** (`rename_source`): fix a title in place, by id or by name
  87. - **Check freshness** (`check_source_freshness`): which URL / Drive sources have drifted from what they point at — the whole notebook in one call. An unanswered source is reported as unknown, never as current
  88. - **Read a source's guide** (`get_source_guide`): NotebookLM's own summary and key topics for one source
  89. - **Read a source in full** (`source_read`): the exact text NotebookLM indexed — what it actually reasons over, which the web UI only shows in fragments. Quote a source verbatim, check what a PDF really yielded, or hand the raw material to another tool. Name the source instead of its ID if you prefer; an ambiguous name is refused rather than guessed. Long sources arrive **one page at a time**, with an explicit instruction for fetching the next — or `paginate: false` for the whole document at once.
  90. ### Notebook Summary and Chat History
  91. - **What is in this notebook?** (`get_notebook_summary`) — NotebookLM's own summary of its sources plus the questions it suggests asking, without spending a question to find out
  92. - **What was already asked?** (`get_chat_history`) — read back the recorded questions and answers, newest first. An agent resuming work stops paying to ask what it already asked. NotebookLM exposes only the most recent conversation per notebook
  93. - **Clear the history** (`delete_chat_history`) — the web UI's "Delete history". There is no per-turn delete: the whole conversation goes
  94. ### Artifact Export and Revision
  95. - **Export to Drive** (`export_artifact`) — send a finished artifact to Google Docs or Google Sheets
  96. - **Revise one slide** (`revise_slide`) — change a single slide from a prompt instead of regenerating the whole deck
  97. ### Notebook Library
  98. - **Multi-notebook management** with validation and smart selection
  99. - **Auto-discovery**: Automatically generate metadata via NotebookLM queries
  100. - **Search notebooks** by keyword in name, description, or topics
  101. - **Scrape notebooks**: List all notebooks from NotebookLM with IDs and names
  102. - **Bulk delete**: Delete multiple notebooks at once
  103. ### Accounts & Localization
  104. - **Personal _and_ Google Workspace accounts** — recognizes both NotebookLM hosts (`notebooklm.google.com` and the `notebook.google.com` Workspace alias), so Workspace sessions authenticate cleanly instead of looping on "session expired"
  105. - **UI-language-aware** — drives NotebookLM whether its interface is in English, French, German, or Japanese (`en` · `fr` · `de` · `ja`); [add a language](./docs/ADDING_A_LANGUAGE.md) in a single JSON file
  106. ### UTCP Interface
  107. [UTCP](https://www.utcp.io/) — the Universal Tool Calling Protocol — is the
  108. inverse of MCP: **there is no protocol server and no wrapper process**. A
  109. client reads a tool manual once, then calls this REST API directly, so nothing
  110. sits between the agent and the endpoint.
  111. ```bash
  112. # The manual. 56 tools, named the same as the MCP tools.
  113. curl -H "X-API-Key: $NOTEBOOKLM_API_KEY" http://localhost:3000/utcp
  114. ```
  115. - **`GET /utcp`** — the manual for a running server, with every call address
  116. rebased on the address the request arrived at, so one document serves a
  117. loopback install and a reverse-proxied one alike.
  118. - **Also published statically** at
  119. [notebooklm.roomi-fields.com/utcp.json](https://notebooklm.roomi-fields.com/utcp.json),
  120. for a client configured before the server is up.
  121. - **62 named tools** — the manual reuses the MCP tool names, so
  122. `search_passages` is `search_passages` on both sides rather than something
  123. synthesised from a URL path. Every operation in the
  124. [OpenAPI 3.1 spec](./deployment/docs/openapi.yaml) carries a matching
  125. `operationId`, which also means a client pointed straight at the
  126. specification converts it correctly on its own.
  127. - **Authentication is declared the way UTCP clients implement it** — as an
  128. `api_key` in the `X-API-Key` header, which this server accepts alongside the
  129. bearer form. The key itself is never in the manual, only the literal
  130. `${NOTEBOOKLM_API_KEY}`, which is how a client asks for a value from its own
  131. environment. (A client that converts the specification instead will not pick
  132. up authentication at all, since the converter does not map bearer schemes —
  133. one reason to prefer the manual.)
  134. Generated from the specification on every release and held in step by a build
  135. guard, so the manual cannot describe a version that is not the one you are
  136. running. Details: [REST API reference → `GET /utcp`](./deployment/docs/03-API.md).
  137. ### Rust client
  138. A typed async client lives in this repository at
  139. [`crates/notebooklm-client`](./crates/notebooklm-client) and is published as
  140. [**`notebooklm`**](https://crates.io/crates/notebooklm) on crates.io
  141. ([docs](https://docs.rs/notebooklm)), one version per release. It covers **all
  142. 62 operations** — generated from the specification, with a synchronous twin
  143. behind one feature flag.
  144. ```rust
  145. let client = notebooklm::Client::local()?;
  146. let answer = client.ask_question(&AskRequest::new(&id, "What is ikigai?")).await?;
  147. println!("{}", answer.answer);
  148. ```
  149. It deliberately **does not own a browser**: the Google session is bound to the
  150. machine it was made on, expires server-side while local cookies still look
  151. valid, and needs a driver kept patched against detection. The crate talks to
  152. this server, which already does all three. The reasoning in full:
  153. [driving it from Rust](https://notebooklm.roomi-fields.com/blog/notebooklm-rust).
  154. ### Ruby client
  155. The same surface as a gem, in this repository at
  156. [`gems/notebooklm`](./gems/notebooklm) and published as
  157. [**`notebooklm`**](https://rubygems.org/gems/notebooklm) on RubyGems, also one
  158. version per release. All 62 operations, generated from the same specification,
  159. every response shape documented field by field — and no runtime dependencies.
  160. ```ruby
  161. client = NotebookLM.local
  162. answer = client.ask(notebook.id, 'What is ikigai?')
  163. answer.citations.each { |c| puts "[#{c.number}] #{c.source_text}" }
  164. ```
  165. Why a gem at all, and why it owns no browser either:
  166. [driving it from Ruby](https://notebooklm.roomi-fields.com/blog/notebooklm-ruby).
  167. ### Integration Options
  168. - **MCP Protocol** — Claude Code, Cursor, Codex, any MCP client
  169. - **[UTCP](https://www.utcp.io/)** — a tool manual at `/utcp`, for clients that call the REST API natively with no protocol server in between ([see above](#utcp-interface))
  170. - **Agent Skill** — ships a bundled [`notebooklm` skill](./skills/notebooklm/SKILL.md) (also standalone: [`roomi-fields/notebooklm-skill`](https://github.com/roomi-fields/notebooklm-skill)) that teaches the agent citation formats, the batch-to-cache pattern, and when to use which transport
  171. - **HTTP REST API** — n8n, Zapier, Make.com, custom integrations
  172. - **Docker** — Isolated deployment with Docker or Docker Compose
  173. - **[RTFM](https://github.com/roomi-fields/rtfm) retrieval layer** — `/batch-to-vault` writes citation-backed answers as markdown + JSON sidecars (`nblm-answer-v1` schema), indexable by [RTFM](https://github.com/roomi-fields/rtfm) (FTS5 + semantic) for unlimited offline queries. Ideal for academic / SOTA workflows. [Guide](./deployment/docs/14-RTFM-INTEGRATION.md).
  174. ---
  175. ## Quick Start
  176. ### Option 0 — Claude Code marketplace (one-liner, recommended for Claude Code users)
  177. The fastest way to get NotebookLM into Claude Code. Distributed via the [`roomi-fields/claude-plugins`](https://github.com/roomi-fields/claude-plugins) marketplace alongside [RTFM](https://github.com/roomi-fields/rtfm) (the retrieval companion — see [RTFM integration guide](./deployment/docs/14-RTFM-INTEGRATION.md)):
  178. ```text
  179. /plugin marketplace add roomi-fields/claude-plugins
  180. /plugin install notebooklm@roomi-fields
  181. ```
  182. That registers the MCP server **and the `notebooklm` agent skill**, runs `npx -y @roomi-fields/notebooklm-mcp@<pinned-version>` automatically (Node ≥ 22 required), and lets you upgrade with two commands when a new release ships: `/plugin marketplace update roomi-fields` then `/reload-plugins`. Then run `npx -y -p @roomi-fields/notebooklm-mcp notebooklm-mcp-setup-auth` once in a terminal to log into Google (a visible Chrome opens). To install RTFM at the same time: `/plugin install rtfm@roomi-fields`.
  183. ### Option 1 — HTTP REST API (n8n, Zapier, Make, curl, any HTTP client)
  184. ```bash
  185. git clone https://github.com/roomi-fields/notebooklm-mcp.git
  186. cd notebooklm-mcp
  187. npm install && npm run build
  188. npm run setup-auth # One-time Google login
  189. npm run start:http # Start REST API on port 3000
  190. ```
  191. ```bash
  192. # Citation-backed Q&A, single curl, JSON response
  193. curl -X POST http://localhost:3000/ask \
  194. -H 'Content-Type: application/json' \
  195. -d '{"question": "Summarize chapter 3", "notebook_id": "your-id", "source_format": "json"}'
  196. ```
  197. The full surface is **33 documented endpoints** — see the [REST API reference](https://notebooklm.roomi-fields.com/notebooklm-rest-api). For overnight batches of 1 000+ questions, see the [batch pattern](https://notebooklm.roomi-fields.com/batch-1000-questions).
  198. ### Option 2 — MCP Mode (Claude Code, Cursor, Codex)
  199. ```bash
  200. # Build (same package, MCP transport)
  201. git clone https://github.com/roomi-fields/notebooklm-mcp.git
  202. cd notebooklm-mcp
  203. npm install && npm run build
  204. # Claude Code
  205. claude mcp add notebooklm node /path/to/notebooklm-mcp/dist/index.js
  206. # Cursor — add to ~/.cursor/mcp.json
  207. {
  208. "mcpServers": {
  209. "notebooklm": {
  210. "command": "node",
  211. "args": ["/path/to/notebooklm-mcp/dist/index.js"]
  212. }
  213. }
  214. }
  215. ```
  216. **Log in once — in a terminal, not through the assistant.** Run the interactive
  217. Google login as a command; a visible Chrome window opens, you sign in, and the
  218. saved session is then reused by the MCP server:
  219. ```bash
  220. npm run setup-auth # from a clone (Option 2 above)
  221. notebooklm-mcp setup-auth # from a global install (npm i -g @roomi-fields/notebooklm-mcp)
  222. ```
  223. Do the login in a terminal rather than by asking the assistant _"log me in"_:
  224. some stdio MCP clients (e.g. Claude Desktop) cap tool-call duration and cut off
  225. the up-to-10-minute interactive login before you can finish signing in (see
  226. [issue #27](https://github.com/roomi-fields/notebooklm-mcp/issues/27)).
  227. ### Option 2b — MCP over HTTP (containers, remote clients)
  228. Clients that cannot spawn a local process — an AI in **another Docker container**, a hosted
  229. agent, a workflow runner — reach the **same MCP tools** over streamable HTTP. Start the HTTP
  230. server (Option 1) and point the client at `/mcp`:
  231. ```json
  232. {
  233. "mcpServers": {
  234. "notebooklm": {
  235. "type": "http",
  236. "url": "http://localhost:3000/mcp"
  237. }
  238. }
  239. }
  240. ```
  241. Stateless, and behind the same auth as the REST API: set `NOTEBOOKLM_API_KEY` and the client
  242. sends `Authorization: Bearer <key>`; leave it unset on a trusted container network and it
  243. works without one ([issue #42](https://github.com/roomi-fields/notebooklm-mcp/issues/42)).
  244. ### Option 3 — Docker (NAS, server, headless)
  245. ```bash
  246. # Build and run
  247. docker build -t notebooklm-mcp .
  248. docker run -d --name notebooklm-mcp -p 3000:3000 -p 6080:6080 -v notebooklm-data:/data notebooklm-mcp
  249. # Authenticate via noVNC
  250. # 1. Open http://localhost:6080/vnc.html
  251. # 2. Run: curl -X POST http://localhost:3000/setup-auth -d '{"show_browser":true}'
  252. # 3. Login to Google in the VNC window
  253. ```
  254. See [Docker Guide](./deployment/docs/08-DOCKER.md) for NAS deployment (Synology, QNAP).
  255. ---
  256. ## Documentation
  257. Full docs site: **<https://notebooklm.roomi-fields.com/>** · [OpenAPI 3.1 spec](./deployment/docs/openapi.yaml) · [UTCP manual](https://notebooklm.roomi-fields.com/utcp.json)
  258. | Guide | Description |
  259. | -------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
  260. | [Installation](./deployment/docs/01-INSTALL.md) | Step-by-step setup for HTTP and MCP modes |
  261. | [Configuration](./deployment/docs/02-CONFIGURATION.md) | Environment variables and security |
  262. | [REST API reference](./deployment/docs/03-API.md) | Complete HTTP endpoint documentation (62 endpoints) |
  263. | [Run 1 000 questions overnight](./deployment/docs/12-BATCH-1000.md) | Production batch pattern with auto-reauth and rotation |
  264. | [**RTFM integration — cache as searchable vault**](./deployment/docs/14-RTFM-INTEGRATION.md) | Pipeline pattern: NotebookLM as one-shot ingestion, RTFM as retrieval layer. `/batch-to-vault` endpoint, `nblm-answer-v1` schema. |
  265. | [n8n integration](./deployment/docs/04-N8N-INTEGRATION.md) | Workflow automation setup |
  266. | [Troubleshooting](./deployment/docs/05-TROUBLESHOOTING.md) | Common issues and solutions |
  267. | [Notebook library](./deployment/docs/06-NOTEBOOK-LIBRARY.md) | Multi-notebook management |
  268. | [Auto-discovery](./deployment/docs/07-AUTO-DISCOVERY.md) | Autonomous metadata generation |
  269. | [Content management](./deployment/docs/10-CONTENT-MANAGEMENT.md) | Audio, video, infographic, report, presentation |
  270. | [Multi-account rotation](./deployment/docs/11-MULTI-ACCOUNT.md) | Multiple accounts with TOTP auto-reauth |
  271. | [Docker](./deployment/docs/08-DOCKER.md) | Docker and Docker Compose deployment |
  272. | [Multi-interface](./deployment/docs/09-MULTI-INTERFACE.md) | Run Claude Desktop + HTTP simultaneously |
  273. | [**Compare with PleasePrompto v2.0.0**](./deployment/docs/13-COMPARE.md) | Feature matrix vs the upstream MCP-only server |
  274. | [Chrome profile limitation](./docs/CHROME_PROFILE_LIMITATION.md) | Profile locking (solved in v1.3.6+) |
  275. | [Adding a language](./docs/ADDING_A_LANGUAGE.md) | i18n system for multilingual UI support |
  276. ---
  277. ## Roadmap
  278. See [ROADMAP.md](./ROADMAP.md) for planned features and version history.
  279. **Latest releases:**
  280. <!-- releases:start — generated from CHANGELOG.md by scripts/sync-facts.mjs; do not edit by hand -->
  281. - **v4.11.1** (2026-11-17) — Copying, checked on a live account · Audio and image sources
  282. - **v4.11.0** (2026-11-17) — Copy a notebook, its sources, or its Studio content
  283. - **v4.10.0** (2026-11-13) — MCP over streamable HTTP
  284. - **v4.9.0** (2026-11-11) — Stop a running answer or research
  285. - **v4.8.0** (2026-11-09) — The live compute-meter quota, read with one call
  286. - **v4.7.0** (2026-11-07) — The published specification was invalid, and nothing checked · The Rust client covers the whole API, and is generated · and more
  287. - **v4.6.0** (2026-11-06) — Retry a failed generation without losing its id · A UTCP interface, and 56 named operations · and more
  288. - **v4.5.0** (2026-10-30) — Search the sources without paying for an answer
  289. - **v4.4.0** (2026-10-24) — Two security fixes, both reported by Umar Ahmed (ghostnshells)
  290. - **v4.3.0** (2026-10-22) — Eight tools for calls the server already knew how to make · Two things the backlog had wrong
  291. <!-- releases:end -->
  292. _Every earlier release, with the whole story of each, is in the full [CHANGELOG](./CHANGELOG.md)._
  293. **Not yet implemented:**
  294. - Discover sources (Web/Drive search with Fast/Deep modes)
  295. - Edit notes (create, delete, and convert are implemented)
  296. ---
  297. ## Disclaimer
  298. This tool automates browser interactions with NotebookLM. Use a dedicated Google account for automation. CLI tools like Claude Code can make mistakes — always review changes before deploying.
  299. See full [Disclaimer](#disclaimer-details) below.
  300. ---
  301. ## Contributing
  302. Found a bug? Have an idea? [Open an issue](https://github.com/roomi-fields/notebooklm-mcp/issues) or submit a PR!
  303. See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
  304. ## License
  305. MIT — Use freely in your projects. See [LICENSE](./LICENSE).
  306. ## Author
  307. **Romain Peyrichou** — [@roomi-fields](https://github.com/roomi-fields)
  308. ## Acknowledgments
  309. Thanks to everyone who has contributed code, ideas, and bug reports:
  310. - **Khizar Jamshaid Iqbal** — [@KhizarJamshaidIqbal](https://github.com/KhizarJamshaidIqbal), 2025 UI selector fixes, doctor script, PII scrub
  311. - **Kazik Pietka** — [@kpietkaa](https://github.com/kpietkaa), `notebook.google.com` rebrand support
  312. - **Rui Ruiberriz** — [@Excauboi](https://github.com/Excauboi), `hl=<uiLocale>` on app URLs + click-through scrape fallback
  313. - **[@he0xwhale](https://github.com/he0xwhale)** — `note_list` / `note_get` MCP tools
  314. - **[@eminsnow](https://github.com/eminsnow)** — canonical tool names (`_` over `.`)
  315. - **Julien Cantoni** — [@JulienCANTONI](https://github.com/JulienCANTONI)
  316. - **Nils Friedrichs** — [@nils-friedrichs](https://github.com/nils-friedrichs), LightNow capability badge
  317. - **Teodor Tenev** — [@teodor-t-tenev](https://github.com/teodor-t-tenev), stdio mode exits when its client is gone instead of spinning a core
  318. - **[@shinjiyu](https://github.com/shinjiyu)** — reported the open HTTP API privately, with the fix (GHSA-p69m-c5rf-g2c3)
  319. - **Umar Ahmed** — [@ghostnshells](https://github.com/ghostnshells), reported two advisories: the origin guard that trusted a missing header, and forced browser navigation
  320. ---
  321. <details>
  322. <summary><a name="disclaimer-details"></a>Full Disclaimer</summary>
  323. **About browser automation:**
  324. While I've built in humanization features (realistic typing speeds, natural delays, mouse movements), I can't guarantee Google won't detect or flag automated usage. Use a dedicated Google account for automation.
  325. **About CLI tools and AI agents:**
  326. CLI tools like Claude Code, Codex, and similar AI-powered assistants are powerful but can make mistakes:
  327. - Always review changes before committing or deploying
  328. - Test in safe environments first
  329. - Keep backups of important work
  330. - AI agents are assistants, not infallible oracles
  331. I built this tool for myself and share it hoping it helps others, but I can't take responsibility for any issues that might occur. Use at your own discretion.
  332. </details>
  333. ---
  334. <div align="center">
  335. Built with frustration about hallucinated APIs, powered by Google's NotebookLM
  336. ⭐ [Star on GitHub](https://github.com/roomi-fields/notebooklm-mcp) if this saves you debugging time!
  337. </div>

Version history

  • v4.11.111/17/2026

  • v4.10.011/13/2026

  • v4.9.011/12/2026

  • v4.8.011/11/2026

  • v4.7.011/7/2026

  • v4.5.010/31/2026

  • v4.4.010/25/2026

  • v4.3.010/23/2026

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.