Skip to content
Back to search

notebooklm

SkillWorks with Claude CodeGitHub

Use this skill to query your Google NotebookLM notebooks directly from Claude Code for source-grounded, citation-backed answers from Gemini. Browser automation, library management, persistent auth. Drastically reduced hallucinations through document-only responses.

Safety scan

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

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/pleaseprompto-notebooklm-skill/badge.svg)](/listings/pleaseprompto-notebooklm-skill)

HTML

<a href="/listings/pleaseprompto-notebooklm-skill"><img src="/api/listings/pleaseprompto-notebooklm-skill/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.

The simplest installation ever:

# 1. Create skills directory (if it doesn't exist)
mkdir -p ~/.claude/skills

# 2. Clone this repository
cd ~/.claude/skills
git clone https://github.com/PleasePrompto/notebooklm-skill notebooklm

# 3. That's it! Open Claude Code and say:
"What are my skills?"

When you first use the skill, it automatically: - Creates an isolated Python environment (`.venv`) - Installs all dependencies including **Google Chrome** - Sets up browser automation with Chrome (not Chromium) for maximum reliability - Everything stays contained in the skill folder

**Note:** The setup uses real Chrome instead of Chromium for cross-platform reliability, consistent browser fingerprinting, and better anti-detection with Google services

---

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.

SKILL.md · Manifest · 269 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: notebooklm
  3. description: Use this skill to query your Google NotebookLM notebooks directly from Claude Code for source-grounded, citation-backed answers from Gemini. Browser automation, library management, persistent auth. Drastically reduced hallucinations through document-only responses.
  4. ---
  5. # NotebookLM Research Assistant Skill
  6. Interact with Google NotebookLM to query documentation with Gemini's source-grounded answers. Each question opens a fresh browser session, retrieves the answer exclusively from your uploaded documents, and closes.
  7. ## When to Use This Skill
  8. Trigger when user:
  9. - Mentions NotebookLM explicitly
  10. - Shares NotebookLM URL (`https://notebooklm.google.com/notebook/...`)
  11. - Asks to query their notebooks/documentation
  12. - Wants to add documentation to NotebookLM library
  13. - Uses phrases like "ask my NotebookLM", "check my docs", "query my notebook"
  14. ## ⚠️ CRITICAL: Add Command - Smart Discovery
  15. When user wants to add a notebook without providing details:
  16. **SMART ADD (Recommended)**: Query the notebook first to discover its content:
  17. ```bash
  18. # Step 1: Query the notebook about its content
  19. python scripts/run.py ask_question.py --question "What is the content of this notebook? What topics are covered? Provide a complete overview briefly and concisely" --notebook-url "[URL]"
  20. # Step 2: Use the discovered information to add it
  21. python scripts/run.py notebook_manager.py add --url "[URL]" --name "[Based on content]" --description "[Based on content]" --topics "[Based on content]"
  22. ```
  23. **MANUAL ADD**: If user provides all details:
  24. - `--url` - The NotebookLM URL
  25. - `--name` - A descriptive name
  26. - `--description` - What the notebook contains (REQUIRED!)
  27. - `--topics` - Comma-separated topics (REQUIRED!)
  28. NEVER guess or use generic descriptions! If details missing, use Smart Add to discover them.
  29. ## Critical: Always Use run.py Wrapper
  30. **NEVER call scripts directly. ALWAYS use `python scripts/run.py [script]`:**
  31. ```bash
  32. # ✅ CORRECT - Always use run.py:
  33. python scripts/run.py auth_manager.py status
  34. python scripts/run.py notebook_manager.py list
  35. python scripts/run.py ask_question.py --question "..."
  36. # ❌ WRONG - Never call directly:
  37. python scripts/auth_manager.py status # Fails without venv!
  38. ```
  39. The `run.py` wrapper automatically:
  40. 1. Creates `.venv` if needed
  41. 2. Installs all dependencies
  42. 3. Activates environment
  43. 4. Executes script properly
  44. ## Core Workflow
  45. ### Step 1: Check Authentication Status
  46. ```bash
  47. python scripts/run.py auth_manager.py status
  48. ```
  49. If not authenticated, proceed to setup.
  50. ### Step 2: Authenticate (One-Time Setup)
  51. ```bash
  52. # Browser MUST be visible for manual Google login
  53. python scripts/run.py auth_manager.py setup
  54. ```
  55. **Important:**
  56. - Browser is VISIBLE for authentication
  57. - Browser window opens automatically
  58. - User must manually log in to Google
  59. - Tell user: "A browser window will open for Google login"
  60. ### Step 3: Manage Notebook Library
  61. ```bash
  62. # List all notebooks
  63. python scripts/run.py notebook_manager.py list
  64. # BEFORE ADDING: Ask user for metadata if unknown!
  65. # "What does this notebook contain?"
  66. # "What topics should I tag it with?"
  67. # Add notebook to library (ALL parameters are REQUIRED!)
  68. python scripts/run.py notebook_manager.py add \
  69. --url "https://notebooklm.google.com/notebook/..." \
  70. --name "Descriptive Name" \
  71. --description "What this notebook contains" \ # REQUIRED - ASK USER IF UNKNOWN!
  72. --topics "topic1,topic2,topic3" # REQUIRED - ASK USER IF UNKNOWN!
  73. # Search notebooks by topic
  74. python scripts/run.py notebook_manager.py search --query "keyword"
  75. # Set active notebook
  76. python scripts/run.py notebook_manager.py activate --id notebook-id
  77. # Remove notebook
  78. python scripts/run.py notebook_manager.py remove --id notebook-id
  79. ```
  80. ### Quick Workflow
  81. 1. Check library: `python scripts/run.py notebook_manager.py list`
  82. 2. Ask question: `python scripts/run.py ask_question.py --question "..." --notebook-id ID`
  83. ### Step 4: Ask Questions
  84. ```bash
  85. # Basic query (uses active notebook if set)
  86. python scripts/run.py ask_question.py --question "Your question here"
  87. # Query specific notebook
  88. python scripts/run.py ask_question.py --question "..." --notebook-id notebook-id
  89. # Query with notebook URL directly
  90. python scripts/run.py ask_question.py --question "..." --notebook-url "https://..."
  91. # Show browser for debugging
  92. python scripts/run.py ask_question.py --question "..." --show-browser
  93. ```
  94. ## Follow-Up Mechanism (CRITICAL)
  95. Every NotebookLM answer ends with: **"EXTREMELY IMPORTANT: Is that ALL you need to know?"**
  96. **Required Claude Behavior:**
  97. 1. **STOP** - Do not immediately respond to user
  98. 2. **ANALYZE** - Compare answer to user's original request
  99. 3. **IDENTIFY GAPS** - Determine if more information needed
  100. 4. **ASK FOLLOW-UP** - If gaps exist, immediately ask:
  101. ```bash
  102. python scripts/run.py ask_question.py --question "Follow-up with context..."
  103. ```
  104. 5. **REPEAT** - Continue until information is complete
  105. 6. **SYNTHESIZE** - Combine all answers before responding to user
  106. ## Script Reference
  107. ### Authentication Management (`auth_manager.py`)
  108. ```bash
  109. python scripts/run.py auth_manager.py setup # Initial setup (browser visible)
  110. python scripts/run.py auth_manager.py status # Check authentication
  111. python scripts/run.py auth_manager.py reauth # Re-authenticate (browser visible)
  112. python scripts/run.py auth_manager.py clear # Clear authentication
  113. ```
  114. ### Notebook Management (`notebook_manager.py`)
  115. ```bash
  116. python scripts/run.py notebook_manager.py add --url URL --name NAME --description DESC --topics TOPICS
  117. python scripts/run.py notebook_manager.py list
  118. python scripts/run.py notebook_manager.py search --query QUERY
  119. python scripts/run.py notebook_manager.py activate --id ID
  120. python scripts/run.py notebook_manager.py remove --id ID
  121. python scripts/run.py notebook_manager.py stats
  122. ```
  123. ### Question Interface (`ask_question.py`)
  124. ```bash
  125. python scripts/run.py ask_question.py --question "..." [--notebook-id ID] [--notebook-url URL] [--show-browser]
  126. ```
  127. ### Data Cleanup (`cleanup_manager.py`)
  128. ```bash
  129. python scripts/run.py cleanup_manager.py # Preview cleanup
  130. python scripts/run.py cleanup_manager.py --confirm # Execute cleanup
  131. python scripts/run.py cleanup_manager.py --preserve-library # Keep notebooks
  132. ```
  133. ## Environment Management
  134. The virtual environment is automatically managed:
  135. - First run creates `.venv` automatically
  136. - Dependencies install automatically
  137. - Chromium browser installs automatically
  138. - Everything isolated in skill directory
  139. Manual setup (only if automatic fails):
  140. ```bash
  141. python -m venv .venv
  142. source .venv/bin/activate # Linux/Mac
  143. pip install -r requirements.txt
  144. python -m patchright install chromium
  145. ```
  146. ## Data Storage
  147. All data stored in `~/.claude/skills/notebooklm/data/`:
  148. - `library.json` - Notebook metadata
  149. - `auth_info.json` - Authentication status
  150. - `browser_state/` - Browser cookies and session
  151. **Security:** Protected by `.gitignore`, never commit to git.
  152. ## Configuration
  153. Optional `.env` file in skill directory:
  154. ```env
  155. HEADLESS=false # Browser visibility
  156. SHOW_BROWSER=false # Default browser display
  157. STEALTH_ENABLED=true # Human-like behavior
  158. TYPING_WPM_MIN=160 # Typing speed
  159. TYPING_WPM_MAX=240
  160. DEFAULT_NOTEBOOK_ID= # Default notebook
  161. ```
  162. ## Decision Flow
  163. ```
  164. User mentions NotebookLM
  165. ↓
  166. Check auth → python scripts/run.py auth_manager.py status
  167. ↓
  168. If not authenticated → python scripts/run.py auth_manager.py setup
  169. ↓
  170. Check/Add notebook → python scripts/run.py notebook_manager.py list/add (with --description)
  171. ↓
  172. Activate notebook → python scripts/run.py notebook_manager.py activate --id ID
  173. ↓
  174. Ask question → python scripts/run.py ask_question.py --question "..."
  175. ↓
  176. See "Is that ALL you need?" → Ask follow-ups until complete
  177. ↓
  178. Synthesize and respond to user
  179. ```
  180. ## Troubleshooting
  181. | Problem | Solution |
  182. |---------|----------|
  183. | ModuleNotFoundError | Use `run.py` wrapper |
  184. | Authentication fails | Browser must be visible for setup! --show-browser |
  185. | Rate limit (50/day) | Wait or switch Google account |
  186. | Browser crashes | `python scripts/run.py cleanup_manager.py --preserve-library` |
  187. | Notebook not found | Check with `notebook_manager.py list` |
  188. ## Best Practices
  189. 1. **Always use run.py** - Handles environment automatically
  190. 2. **Check auth first** - Before any operations
  191. 3. **Follow-up questions** - Don't stop at first answer
  192. 4. **Browser visible for auth** - Required for manual login
  193. 5. **Include context** - Each question is independent
  194. 6. **Synthesize answers** - Combine multiple responses
  195. ## Limitations
  196. - No session persistence (each question = new browser)
  197. - Rate limits on free Google accounts (50 queries/day)
  198. - Manual upload required (user must add docs to NotebookLM)
  199. - Browser overhead (few seconds per question)
  200. ## Resources (Skill Structure)
  201. **Important directories and files:**
  202. - `scripts/` - All automation scripts (ask_question.py, notebook_manager.py, etc.)
  203. - `data/` - Local storage for authentication and notebook library
  204. - `references/` - Extended documentation:
  205. - `api_reference.md` - Detailed API documentation for all scripts
  206. - `troubleshooting.md` - Common issues and solutions
  207. - `usage_patterns.md` - Best practices and workflow examples
  208. - `.venv/` - Isolated Python environment (auto-created on first run)
  209. - `.gitignore` - Protects sensitive data from being committed
README.md · README · 415 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. > [!WARNING]
  2. > **This project is no longer maintained.** As of September 2026 the repository is archived: no updates, bug fixes or support. It may stop working when the upstream services change. Feel free to fork.
  3. <div align="center">
  4. # NotebookLM Claude Code Skill
  5. **Let [Claude Code](https://github.com/anthropics/claude-code) chat directly with NotebookLM for source-grounded answers based exclusively on your uploaded documents**
  6. [![Python](https://img.shields.io/badge/Python-3.8+-blue.svg)](https://www.python.org/)
  7. [![Claude Code Skill](https://img.shields.io/badge/Claude%20Code-Skill-purple.svg)](https://www.anthropic.com/news/skills)
  8. [![Based on](https://img.shields.io/badge/Based%20on-NotebookLM%20MCP-green.svg)](https://github.com/PleasePrompto/notebooklm-mcp)
  9. [![GitHub](https://img.shields.io/github/stars/PleasePrompto/notebooklm-skill?style=social)](https://github.com/PleasePrompto/notebooklm-skill)
  10. > Use this skill to query your Google NotebookLM notebooks directly from Claude Code for source-grounded, citation-backed answers from Gemini. Browser automation, library management, persistent auth. Drastically reduced hallucinations - answers only from your uploaded documents.
  11. [Installation](#installation) • [Quick Start](#quick-start) • [Why NotebookLM](#why-notebooklm-not-local-rag) • [How It Works](#how-it-works) • [MCP Alternative](https://github.com/PleasePrompto/notebooklm-mcp)
  12. </div>
  13. ---
  14. ## ⚠️ Important: Local Claude Code Only
  15. **This skill works ONLY with local [Claude Code](https://github.com/anthropics/claude-code) installations, NOT in the web UI.**
  16. The web UI runs skills in a sandbox without network access, which this skill requires for browser automation. You must use [Claude Code](https://github.com/anthropics/claude-code) locally on your machine.
  17. ---
  18. ## The Problem
  19. When you tell [Claude Code](https://github.com/anthropics/claude-code) to "search through my local documentation", here's what happens:
  20. - **Massive token consumption**: Searching through documentation means reading multiple files repeatedly
  21. - **Inaccurate retrieval**: Searches for keywords, misses context and connections between docs
  22. - **Hallucinations**: When it can't find something, it invents plausible-sounding APIs
  23. - **Manual copy-paste**: Switching between NotebookLM browser and your editor constantly
  24. ## The Solution
  25. This Claude Code Skill lets [Claude Code](https://github.com/anthropics/claude-code) chat directly with [**NotebookLM**](https://notebooklm.google/) — Google's **source-grounded knowledge base** powered by Gemini 2.5 that provides intelligent, synthesized answers exclusively from your uploaded documents.
  26. ```
  27. Your Task → Claude asks NotebookLM → Gemini synthesizes answer → Claude writes correct code
  28. ```
  29. **No more copy-paste dance**: Claude asks questions directly and gets answers straight back in the CLI. It builds deep understanding through automatic follow-ups, getting specific implementation details, edge cases, and best practices.
  30. ---
  31. ## Why NotebookLM, Not Local RAG?
  32. | Approach | Token Cost | Setup Time | Hallucinations | Answer Quality |
  33. |----------|------------|------------|----------------|----------------|
  34. | **Feed docs to Claude** | 🔴 Very high (multiple file reads) | Instant | Yes - fills gaps | Variable retrieval |
  35. | **Web search** | 🟡 Medium | Instant | High - unreliable sources | Hit or miss |
  36. | **Local RAG** | 🟡 Medium-High | Hours (embeddings, chunking) | Medium - retrieval gaps | Depends on setup |
  37. | **NotebookLM Skill** | 🟢 Minimal | 5 minutes | **Minimal** - source-grounded only | Expert synthesis |
  38. ### What Makes NotebookLM Superior?
  39. 1. **Pre-processed by Gemini**: Upload docs once, get instant expert knowledge
  40. 2. **Natural language Q&A**: Not just retrieval — actual understanding and synthesis
  41. 3. **Multi-source correlation**: Connects information across 50+ documents
  42. 4. **Citation-backed**: Every answer includes source references
  43. 5. **No infrastructure**: No vector DBs, embeddings, or chunking strategies needed
  44. ---
  45. ## Installation
  46. ### The simplest installation ever:
  47. ```bash
  48. # 1. Create skills directory (if it doesn't exist)
  49. mkdir -p ~/.claude/skills
  50. # 2. Clone this repository
  51. cd ~/.claude/skills
  52. git clone https://github.com/PleasePrompto/notebooklm-skill notebooklm
  53. # 3. That's it! Open Claude Code and say:
  54. "What are my skills?"
  55. ```
  56. When you first use the skill, it automatically:
  57. - Creates an isolated Python environment (`.venv`)
  58. - Installs all dependencies including **Google Chrome**
  59. - Sets up browser automation with Chrome (not Chromium) for maximum reliability
  60. - Everything stays contained in the skill folder
  61. **Note:** The setup uses real Chrome instead of Chromium for cross-platform reliability, consistent browser fingerprinting, and better anti-detection with Google services
  62. ---
  63. ## Quick Start
  64. ### 1. Check your skills
  65. Say in Claude Code:
  66. ```
  67. "What skills do I have?"
  68. ```
  69. Claude will list your available skills including NotebookLM.
  70. ### 2. Authenticate with Google (one-time)
  71. ```
  72. "Set up NotebookLM authentication"
  73. ```
  74. *A Chrome window opens → log in with your Google account*
  75. ### 3. Create your knowledge base
  76. Go to [notebooklm.google.com](https://notebooklm.google.com) → Create notebook → Upload your docs:
  77. - 📄 PDFs, Google Docs, markdown files
  78. - 🔗 Websites, GitHub repos
  79. - 🎥 YouTube videos
  80. - 📚 Multiple sources per notebook
  81. Share: **⚙️ Share → Anyone with link → Copy**
  82. ### 4. Add to your library
  83. **Option A: Let Claude figure it out (Smart Add)**
  84. ```
  85. "Query this notebook about its content and add it to my library: [your-link]"
  86. ```
  87. Claude will automatically query the notebook to discover its content, then add it with appropriate metadata.
  88. **Option B: Manual add**
  89. ```
  90. "Add this NotebookLM to my library: [your-link]"
  91. ```
  92. Claude will ask for a name and topics, then save it for future use.
  93. ### 5. Start researching
  94. ```
  95. "What does my React docs say about hooks?"
  96. ```
  97. Claude automatically selects the right notebook and gets the answer directly from NotebookLM.
  98. ---
  99. ## How It Works
  100. This is a **Claude Code Skill** - a local folder containing instructions and scripts that Claude Code can use when needed. Unlike the [MCP server version](https://github.com/PleasePrompto/notebooklm-mcp), this runs directly in Claude Code without needing a separate server.
  101. ### Key Differences from MCP Server
  102. | Feature | This Skill | MCP Server |
  103. |---------|------------|------------|
  104. | **Protocol** | Claude Skills | Model Context Protocol |
  105. | **Installation** | Clone to `~/.claude/skills` | `claude mcp add ...` |
  106. | **Sessions** | Fresh browser each question | Persistent chat sessions |
  107. | **Compatibility** | Claude Code only (local) | Claude Code, Codex, Cursor, etc. |
  108. | **Language** | Python | TypeScript |
  109. | **Distribution** | Git clone | npm package |
  110. ### Architecture
  111. ```
  112. ~/.claude/skills/notebooklm/
  113. ├── SKILL.md # Instructions for Claude
  114. ├── scripts/ # Python automation scripts
  115. │ ├── ask_question.py # Query NotebookLM
  116. │ ├── notebook_manager.py # Library management
  117. │ └── auth_manager.py # Google authentication
  118. ├── .venv/ # Isolated Python environment (auto-created)
  119. └── data/ # Local notebook library
  120. ```
  121. When you mention NotebookLM or send a notebook URL, Claude:
  122. 1. Loads the skill instructions
  123. 2. Runs the appropriate Python script
  124. 3. Opens a browser, asks your question
  125. 4. Returns the answer directly to you
  126. 5. Uses that knowledge to help with your task
  127. ---
  128. ## Core Features
  129. ### **Source-Grounded Responses**
  130. NotebookLM significantly reduces hallucinations by answering exclusively from your uploaded documents. If information isn't available, it indicates uncertainty rather than inventing content.
  131. ### **Direct Integration**
  132. No copy-paste between browser and editor. Claude asks and receives answers programmatically.
  133. ### **Smart Library Management**
  134. Save NotebookLM links with tags and descriptions. Claude auto-selects the right notebook for your task.
  135. ### **Automatic Authentication**
  136. One-time Google login, then authentication persists across sessions.
  137. ### **Self-Contained**
  138. Everything runs in the skill folder with an isolated Python environment. No global installations.
  139. ### **Human-Like Automation**
  140. Uses realistic typing speeds and interaction patterns to avoid detection.
  141. ---
  142. ## Common Commands
  143. | What you say | What happens |
  144. |--------------|--------------|
  145. | *"Set up NotebookLM authentication"* | Opens Chrome for Google login |
  146. | *"Add [link] to my NotebookLM library"* | Saves notebook with metadata |
  147. | *"Show my NotebookLM notebooks"* | Lists all saved notebooks |
  148. | *"Ask my API docs about [topic]"* | Queries the relevant notebook |
  149. | *"Use the React notebook"* | Sets active notebook |
  150. | *"Clear NotebookLM data"* | Fresh start (keeps library) |
  151. ---
  152. ## Real-World Examples
  153. ### Example 1: Workshop Manual Query
  154. **User asks**: "Check my Suzuki GSR 600 workshop manual for brake fluid type, engine oil specs, and rear axle torque."
  155. **Claude automatically**:
  156. - Authenticates with NotebookLM
  157. - Asks comprehensive questions about each specification
  158. - Follows up when prompted "Is that ALL you need to know?"
  159. - Provides accurate specifications: DOT 4 brake fluid, SAE 10W-40 oil, 100 N·m rear axle torque
  160. ![NotebookLM Chat Example](images/example_notebookchat.png)
  161. ### Example 2: Building Without Hallucinations
  162. **You**: "I need to build an n8n workflow for Gmail spam filtering. Use my n8n notebook."
  163. **Claude's internal process:**
  164. ```
  165. → Loads NotebookLM skill
  166. → Activates n8n notebook
  167. → Asks comprehensive questions with follow-ups
  168. → Synthesizes complete answer from multiple queries
  169. ```
  170. **Result**: Working workflow on first try, no debugging hallucinated APIs.
  171. ---
  172. ## Technical Details
  173. ### Core Technology
  174. - **Patchright**: Browser automation library (Playwright-based)
  175. - **Python**: Implementation language for this skill
  176. - **Stealth techniques**: Human-like typing and interaction patterns
  177. Note: The MCP server uses the same Patchright library but via TypeScript/npm ecosystem.
  178. ### Dependencies
  179. - **patchright==1.55.2**: Browser automation
  180. - **python-dotenv==1.0.0**: Environment configuration
  181. - Automatically installed in `.venv` on first use
  182. ### Data Storage
  183. All data is stored locally within the skill directory:
  184. ```
  185. ~/.claude/skills/notebooklm/data/
  186. ├── library.json - Your notebook library with metadata
  187. ├── auth_info.json - Authentication status info
  188. └── browser_state/ - Browser cookies and session data
  189. ```
  190. **Important Security Note:**
  191. - The `data/` directory contains sensitive authentication data and personal notebooks
  192. - It's automatically excluded from git via `.gitignore`
  193. - NEVER manually commit or share the contents of the `data/` directory
  194. ### Session Model
  195. Unlike the MCP server, this skill uses a **stateless model**:
  196. - Each question opens a fresh browser
  197. - Asks the question, gets the answer
  198. - Adds a follow-up prompt to encourage Claude to ask more questions
  199. - Closes the browser immediately
  200. This means:
  201. - No persistent chat context
  202. - Each question is independent
  203. - But your notebook library persists
  204. - **Follow-up mechanism**: Each answer includes "Is that ALL you need to know?" to prompt Claude to ask comprehensive follow-ups
  205. For multi-step research, Claude automatically asks follow-up questions when needed.
  206. ---
  207. ## Limitations
  208. ### Skill-Specific
  209. - **Local Claude Code only** - Does not work in web UI (sandbox restrictions)
  210. - **No session persistence** - Each question is independent
  211. - **No follow-up context** - Can't reference "the previous answer"
  212. ### NotebookLM
  213. - **Rate limits** - Free tier has daily query limits
  214. - **Manual upload** - You must upload docs to NotebookLM first
  215. - **Share requirement** - Notebooks must be shared publicly
  216. ---
  217. ## FAQ
  218. **Why doesn't this work in the Claude web UI?**
  219. The web UI runs skills in a sandbox without network access. Browser automation requires network access to reach NotebookLM.
  220. **How is this different from the MCP server?**
  221. This is a simpler, Python-based implementation that runs directly as a Claude Skill. The MCP server is more feature-rich with persistent sessions and works with multiple tools (Codex, Cursor, etc.).
  222. **Can I use both this skill and the MCP server?**
  223. Yes! They serve different purposes. Use the skill for quick Claude Code integration, use the MCP server for persistent sessions and multi-tool support.
  224. **What if Chrome crashes?**
  225. Run: `"Clear NotebookLM browser data"` and try again.
  226. **Is my Google account secure?**
  227. Chrome runs locally on your machine. Your credentials never leave your computer. Use a dedicated Google account if you're concerned.
  228. ---
  229. ## Troubleshooting
  230. ### Skill not found
  231. ```bash
  232. # Make sure it's in the right location
  233. ls ~/.claude/skills/notebooklm/
  234. # Should show: SKILL.md, scripts/, etc.
  235. ```
  236. ### Authentication issues
  237. Say: `"Reset NotebookLM authentication"`
  238. ### Browser crashes
  239. Say: `"Clear NotebookLM browser data"`
  240. ### Dependencies issues
  241. ```bash
  242. # Manual reinstall if needed
  243. cd ~/.claude/skills/notebooklm
  244. rm -rf .venv
  245. python -m venv .venv
  246. source .venv/bin/activate # or .venv\Scripts\activate on Windows
  247. pip install -r requirements.txt
  248. ```
  249. ---
  250. ## Disclaimer
  251. This tool automates browser interactions with NotebookLM to make your workflow more efficient. However, a few friendly reminders:
  252. **About browser automation:**
  253. While I've built in humanization features (realistic typing speeds, natural delays, mouse movements) to make the automation behave more naturally, I can't guarantee Google won't detect or flag automated usage. I recommend using a dedicated Google account for automation rather than your primary account—think of it like web scraping: probably fine, but better safe than sorry!
  254. **About CLI tools and AI agents:**
  255. CLI tools like Claude Code, Codex, and similar AI-powered assistants are incredibly powerful, but they can make mistakes. Please use them with care and awareness:
  256. - Always review changes before committing or deploying
  257. - Test in safe environments first
  258. - Keep backups of important work
  259. - Remember: AI agents are assistants, not infallible oracles
  260. I built this tool for myself because I was tired of the copy-paste dance between NotebookLM and my editor. I'm sharing it in the hope it helps others too, but I can't take responsibility for any issues, data loss, or account problems that might occur. Use at your own discretion and judgment.
  261. That said, if you run into problems or have questions, feel free to open an issue on GitHub. I'm happy to help troubleshoot!
  262. ---
  263. ## Credits
  264. This skill is inspired by my [**NotebookLM MCP Server**](https://github.com/PleasePrompto/notebooklm-mcp) and provides an alternative implementation as a Claude Code Skill:
  265. - Both use Patchright for browser automation (TypeScript for MCP, Python for Skill)
  266. - Skill version runs directly in Claude Code without MCP protocol
  267. - Stateless design optimized for skill architecture
  268. If you need:
  269. - **Persistent sessions** → Use the [MCP Server](https://github.com/PleasePrompto/notebooklm-mcp)
  270. - **Multiple tool support** (Codex, Cursor) → Use the [MCP Server](https://github.com/PleasePrompto/notebooklm-mcp)
  271. - **Quick Claude Code integration** → Use this skill
  272. ---
  273. ## The Bottom Line
  274. **Without this skill**: NotebookLM in browser → Copy answer → Paste in Claude → Copy next question → Back to browser...
  275. **With this skill**: Claude researches directly → Gets answers instantly → Writes correct code
  276. Stop the copy-paste dance. Start getting accurate, grounded answers directly in Claude Code.
  277. ```bash
  278. # Get started in 30 seconds
  279. cd ~/.claude/skills
  280. git clone https://github.com/PleasePrompto/notebooklm-skill notebooklm
  281. # Open Claude Code: "What are my skills?"
  282. ```
  283. ---
  284. <div align="center">
  285. Built as a Claude Code Skill adaptation of my [NotebookLM MCP Server](https://github.com/PleasePrompto/notebooklm-mcp)
  286. For source-grounded, document-based research directly in Claude Code
  287. </div>

Ratings and comments

Sign in to rate this skill.

Sign in

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