notebooklm

name	notebooklm
description	Guide for managing Google NotebookLM from the command line using nlm CLI. Use when the user wants to create notebooks, manage sources, generate audio overviews, or mentions NotebookLM, nlm, notebook management, or research organization.

NotebookLM CLI Guide

This skill helps you interact with Google's NotebookLM from the command line using the nlm CLI tool. Manage notebooks, sources, notes, and generate audio overviews efficiently.

Quick Start

Basic workflow for using NotebookLM CLI:

1. Authenticate - Set up credentials with nlm auth
2. Create notebook - Start with nlm create <title>
3. Add sources - Populate with nlm add <notebook-id> <input>
4. Generate content - Create guides, outlines, or audio with generation commands
5. Manage notes - Organize with note commands
6. Monitor - Check analytics and source freshness

What is NotebookLM CLI?

nlm is a command-line interface for Google's NotebookLM that enables:

• Notebook management: Create, list, and delete research notebooks
• Source operations: Add, remove, rename, and refresh content sources
• Note management: Create, edit, and organize notes within notebooks
• Audio generation: Create and share AI-generated audio overviews
• Content generation: Generate guides, outlines, and sections
• Analytics: Monitor notebook usage and engagement
• Batch operations: Execute multiple commands efficiently

Authentication

Initial Setup

Before using nlm commands, authenticate with Google:

nlm auth

This command:

• Opens browser for Google OAuth flow
• Requests NotebookLM API permissions
• Stores credentials securely locally
• Enables subsequent commands

Re-authentication: Run nlm auth again if:

• Credentials expire
• Switching Google accounts
• Permission errors occur

Notebook Commands

List Notebooks

View all your notebooks:

nlm list
# or shorthand
nlm ls

Output includes:

• Notebook ID (for use in other commands)
• Title
• Creation date
• Source count
• Last modified timestamp

Filtering examples:

# List recent notebooks
nlm ls | head -n 10

# Search by title pattern
nlm ls | grep "Research"

Create Notebook

Create a new notebook:

nlm create "Research Project Title"

Best practices:

• Use descriptive, searchable titles
• Include project or topic identifiers
• Consider date prefixes for temporal organization: "2024-Q4: Market Analysis"

Returns:

• Notebook ID (save this for subsequent operations)
• Creation confirmation

Example workflow:

# Create and capture ID
NOTEBOOK_ID=$(nlm create "AI Ethics Research" | grep -oE '[a-f0-9-]{36}')
echo "Created notebook: $NOTEBOOK_ID"

Delete Notebook

Remove a notebook permanently:

nlm rm <notebook-id>

Warning: This action is irreversible and deletes:

• All sources in the notebook
• All notes
• Generated content
• Audio overviews

Safe deletion workflow:

# Review before deletion
nlm analytics <notebook-id>
nlm sources <notebook-id>

# Confirm and delete
nlm rm <notebook-id>

Notebook Analytics

View usage statistics:

nlm analytics <notebook-id>

Metrics include:

• Total views
• Source interactions
• Note creation count
• Audio overview plays
• Recent activity timestamps
• Engagement trends

Use cases:

• Track research progress
• Identify popular content
• Monitor collaboration activity
• Audit notebook usage

Source Commands

List Sources

View all sources in a notebook:

nlm sources <notebook-id>

Output details:

• Source ID
• Source name/title
• Type (URL, PDF, text, etc.)
• Upload date
• Status (processing, ready, error)
• Word count or size

Sorting and filtering:

# Most recent sources
nlm sources <notebook-id> | head -n 5

# Find specific source type
nlm sources <notebook-id> | grep "PDF"

Add Source

Add content to a notebook:

nlm add <notebook-id> <input>

Supported input types:

URL/webpage:

nlm add <notebook-id> "https://example.com/article"

Local file:

nlm add <notebook-id> "/path/to/document.pdf"
nlm add <notebook-id> "/path/to/notes.txt"

Text content:

nlm add <notebook-id> "Direct text content to add as source"

Multiple sources:

# Add multiple URLs
for url in $(cat urls.txt); do
  nlm add <notebook-id> "$url"
  sleep 2  # Rate limiting
done

Supported file formats:

• PDF documents
• Text files (.txt, .md)
• Word documents (.docx)
• Webpages (URLs)
• Google Docs (share links)

Remove Source

Delete a source from notebook:

nlm rm-source <notebook-id> <source-id>

Workflow:

# List sources to find ID
nlm sources <notebook-id>

# Remove specific source
nlm rm-source <notebook-id> <source-id>

# Verify removal
nlm sources <notebook-id>

Note: This does not affect notes or other sources referencing the deleted source.

Rename Source

Change source display name:

nlm rename-source <source-id> "New Source Name"

Best practices:

• Use descriptive names: "Q3 2024 Financial Report"
• Include version info: "API Documentation v2.1"
• Add context: "Interview Transcript - Dr. Smith"

Example:

# Generic URL becomes readable
nlm rename-source <source-id> "McKinsey AI Report 2024"

Refresh Source

Update source content from origin:

nlm refresh-source <source-id>

Use cases:

• Update webpage content that changed
• Reload edited Google Docs
• Re-process failed sources

Note: Only works for sources with accessible origin URLs (not uploaded files).

Check Source Freshness

Verify if source content is current:

nlm check-source <source-id>

Returns:

• Last update timestamp
• Origin modification date
• Freshness status (current, outdated, unavailable)
• Recommended actions

Monitoring workflow:

# Check all sources in notebook
for source in $(nlm sources <notebook-id> | awk '{print $1}'); do
  nlm check-source $source
done

Note Commands

List Notes

View all notes in a notebook:

nlm notes <notebook-id>

Output includes:

• Note ID
• Title
• Creation date
• Word count
• Last edited timestamp
• Preview snippet

Create Note

Add a new note to notebook:

nlm new-note <notebook-id> "Note Title"

Returns:

• Note ID (for editing)
• Creation confirmation

Workflow:

# Create note and capture ID
NOTE_ID=$(nlm new-note <notebook-id> "Meeting Notes" | grep -oE '[a-f0-9-]{36}')

# Add content immediately
nlm edit-note <notebook-id> $NOTE_ID "Meeting summary content..."

Edit Note

Update note content:

nlm edit-note <notebook-id> <note-id> "Updated content here"

Content handling:

• Replaces entire note content
• Use quotes for multi-line content
• Supports markdown formatting

Examples:

# Simple update
nlm edit-note <notebook-id> <note-id> "New findings from research."

# Multi-line with heredoc
nlm edit-note <notebook-id> <note-id> "$(cat <<EOF
# Research Findings

## Key Insights
- Finding 1
- Finding 2

## Next Steps
- Action items here
EOF
)"

Remove Note

Delete a note:

nlm rm-note <note-id>

Warning: Permanent deletion - cannot be recovered.

Audio Commands

Create Audio Overview

Generate AI audio discussion:

nlm audio-create <notebook-id> "Instructions for audio generation"

Instructions guide the AI hosts:

• Focus areas: "Focus on methodology and findings"
• Target audience: "Explain for non-technical audience"
• Tone: "Conversational and engaging tone"
• Length: "Create 5-minute overview"
• Emphasis: "Emphasize practical applications"

Examples:

# Research summary
nlm audio-create <notebook-id> "Create engaging overview of key findings for general audience"

# Technical deep-dive
nlm audio-create <notebook-id> "Technical analysis of methodologies and data, 10 minutes"

# Comparative analysis
nlm audio-create <notebook-id> "Compare approaches across all sources, highlight differences"

Processing:

• Generation takes 2-5 minutes
• Check status with nlm audio-get
• Receive notification when ready

Get Audio Overview

Retrieve generated audio:

nlm audio-get <notebook-id>

Returns:

• Audio URL (direct download link)
• Duration
• Generation date
• Transcript (if available)
• Status (processing, ready, failed)

Download workflow:

# Get audio URL
AUDIO_URL=$(nlm audio-get <notebook-id> | grep -o 'https://.*\.mp3')

# Download audio
curl -o "notebook-audio.mp3" "$AUDIO_URL"

Delete Audio Overview

Remove generated audio:

nlm audio-rm <notebook-id>

Use cases:

• Free up storage
• Remove outdated content before regenerating
• Clear failed generation attempts

Regeneration workflow:

# Remove old audio
nlm audio-rm <notebook-id>

# Generate new with updated instructions
nlm audio-create <notebook-id> "New instructions here"

Share Audio Overview

Get shareable link:

nlm audio-share <notebook-id>

Returns:

• Public share URL
• Embed code (optional)
• Expiration info (if applicable)

Privacy notes:

• Anyone with link can access
• Does not share notebook sources or notes
• Can be revoked by deleting audio

Generation Commands

Generate Notebook Guide

Create comprehensive guide from sources:

nlm generate-guide <notebook-id>

Output:

• Structured summary of all sources
• Key themes and concepts
• Important quotes and references
• Suggested reading order
• Knowledge gaps identified

Use cases:

• Onboarding to new research area
• Review before deep work
• Share context with collaborators
• Identify information needs

Generate Content Outline

Create structured outline:

nlm generate-outline <notebook-id>

Output format:

• Hierarchical topic structure
• Main themes and subtopics
• Source references per topic
• Suggested organization
• Missing elements

Applications:

• Article/paper planning
• Presentation structure
• Research organization
• Content strategy

Generate New Section

Create focused content section:

nlm generate-section <notebook-id>

Interactive prompts for:

• Section topic
• Desired length
• Specific sources to include
• Target audience level
• Output format

Use cases:

• Draft article sections
• Create summaries
• Extract specific topics
• Synthesize multiple sources

Batch Operations

Execute Multiple Commands

Run commands from file:

nlm batch <commands-file>

Command file format:

create "Research Project"
add $NOTEBOOK_ID "https://example.com/article1"
add $NOTEBOOK_ID "https://example.com/article2"
add $NOTEBOOK_ID "/path/to/document.pdf"
generate-guide $NOTEBOOK_ID
audio-create $NOTEBOOK_ID "Create engaging overview"

Best practices:

• One command per line
• Use variables for IDs
• Include error handling
• Add sleep for rate limiting

Complex batch example:

# batch-commands.txt
create "Market Research Q4 2024"
add $NOTEBOOK_ID "https://reports.example.com/q4"
add $NOTEBOOK_ID "https://analysis.example.com/trends"
add $NOTEBOOK_ID "/data/survey-results.pdf"
new-note $NOTEBOOK_ID "Executive Summary"
generate-outline $NOTEBOOK_ID
audio-create $NOTEBOOK_ID "Focus on key trends and recommendations"

Execution:

nlm batch batch-commands.txt

Workflow Patterns

Research Project Setup

Complete notebook initialization:

#!/bin/bash

# Create notebook
NOTEBOOK_ID=$(nlm create "Research: AI Ethics 2024" | grep -oE '[a-f0-9-]{36}')
echo "Created notebook: $NOTEBOOK_ID"

# Add primary sources
nlm add $NOTEBOOK_ID "https://arxiv.org/paper1"
nlm add $NOTEBOOK_ID "https://arxiv.org/paper2"
nlm add $NOTEBOOK_ID "/research/literature-review.pdf"

# Create organizational notes
nlm new-note $NOTEBOOK_ID "Research Questions"
nlm new-note $NOTEBOOK_ID "Methodology Notes"
nlm new-note $NOTEBOOK_ID "Key Findings"

# Generate initial guide
nlm generate-guide $NOTEBOOK_ID

echo "Setup complete! Notebook ID: $NOTEBOOK_ID"

Source Management Routine

Regular maintenance workflow:

#!/bin/bash
NOTEBOOK_ID="your-notebook-id"

# Check source freshness
echo "Checking source freshness..."
for source in $(nlm sources $NOTEBOOK_ID | awk '{print $1}'); do
  nlm check-source $source
done

# Refresh outdated sources
echo "Refreshing outdated sources..."
# (add logic based on check-source output)

# Verify all sources loaded
echo "Source status:"
nlm sources $NOTEBOOK_ID

Audio Generation Pipeline

Complete audio workflow:

#!/bin/bash
NOTEBOOK_ID="your-notebook-id"

# Remove old audio if exists
nlm audio-rm $NOTEBOOK_ID 2>/dev/null

# Generate new audio
echo "Generating audio overview..."
nlm audio-create $NOTEBOOK_ID "Create engaging 7-minute overview focusing on practical applications for business leaders"

# Wait for completion (check every 30 seconds)
echo "Waiting for audio generation..."
while true; do
  STATUS=$(nlm audio-get $NOTEBOOK_ID | grep "Status")
  if [[ $STATUS == *"ready"* ]]; then
    break
  fi
  sleep 30
done

# Download and share
AUDIO_URL=$(nlm audio-get $NOTEBOOK_ID | grep -o 'https://.*\.mp3')
curl -o "research-overview.mp3" "$AUDIO_URL"

SHARE_LINK=$(nlm audio-share $NOTEBOOK_ID)
echo "Audio ready: $SHARE_LINK"

Content Generation Workflow

Complete content creation:

#!/bin/bash
NOTEBOOK_ID="your-notebook-id"

# Generate comprehensive guide
echo "Generating notebook guide..."
nlm generate-guide $NOTEBOOK_ID > guide.txt

# Create content outline
echo "Creating outline..."
nlm generate-outline $NOTEBOOK_ID > outline.txt

# Generate individual sections
echo "Generating sections..."
nlm generate-section $NOTEBOOK_ID > section1.txt

# Create summary note
NOTE_ID=$(nlm new-note $NOTEBOOK_ID "Generated Content Summary" | grep -oE '[a-f0-9-]{36}')
nlm edit-note $NOTEBOOK_ID $NOTE_ID "$(cat guide.txt outline.txt)"

echo "Content generation complete!"

Collaborative Research Setup

Prepare notebook for team:

#!/bin/bash

# Create project notebook
NOTEBOOK_ID=$(nlm create "Team Research: Product Strategy" | grep -oE '[a-f0-9-]{36}')

# Add shared resources
nlm add $NOTEBOOK_ID "https://docs.google.com/shared-doc"
nlm add $NOTEBOOK_ID "https://company.com/market-report"

# Create team notes
nlm new-note $NOTEBOOK_ID "Meeting Notes"
nlm new-note $NOTEBOOK_ID "Action Items"
nlm new-note $NOTEBOOK_ID "Decisions"

# Generate initial materials
nlm generate-guide $NOTEBOOK_ID > team-guide.txt
nlm audio-create $NOTEBOOK_ID "Create onboarding overview for new team members"

# Get share link
AUDIO_SHARE=$(nlm audio-share $NOTEBOOK_ID)
echo "Share audio with team: $AUDIO_SHARE"
echo "Notebook ID for team: $NOTEBOOK_ID"

Best Practices

Notebook Organization

Naming conventions:

• Include project code: "PROJ-123: Market Analysis"
• Add dates: "2024-Q4: Competitive Research"
• Use tags: "[AI] [Ethics] Research Compilation"

Source management:

• Rename sources with descriptive titles
• Remove outdated or irrelevant sources
• Check freshness regularly for web sources
• Group related sources with prefixes

Note structure:

• Create index note with links
• Use consistent formatting
• Tag notes by category
• Date-stamp entries

Performance Optimization

Rate limiting:

# Add delays between commands
nlm add $NOTEBOOK_ID "url1"
sleep 2
nlm add $NOTEBOOK_ID "url2"

Batch operations:

• Group related commands
• Use batch command file
• Handle errors gracefully

Resource management:

• Archive completed notebooks
• Delete unused audio overviews
• Remove obsolete sources

Error Handling

Common issues:

Authentication errors:

# Re-authenticate
nlm auth

Rate limit errors:

# Add delays
sleep 5

Invalid notebook ID:

# Verify ID exists
nlm ls | grep <notebook-id>

Source processing failures:

# Check source status
nlm sources <notebook-id>

# Retry failed sources
nlm rm-source <notebook-id> <failed-source-id>
nlm add <notebook-id> <source-input>

Automation Scripts

Template for automation:

#!/bin/bash
set -e  # Exit on error

# Configuration
NOTEBOOK_TITLE="Automated Research $(date +%Y-%m-%d)"
SOURCE_LIST="sources.txt"

# Error handling
trap 'echo "Error on line $LINENO"' ERR

# Create notebook
echo "Creating notebook..."
NOTEBOOK_ID=$(nlm create "$NOTEBOOK_TITLE" | grep -oE '[a-f0-9-]{36}')

# Validate notebook creation
if [ -z "$NOTEBOOK_ID" ]; then
  echo "Failed to create notebook"
  exit 1
fi

# Add sources with error handling
echo "Adding sources..."
while IFS= read -r source; do
  if ! nlm add "$NOTEBOOK_ID" "$source"; then
    echo "Warning: Failed to add source: $source"
  fi
  sleep 2
done < "$SOURCE_LIST"

# Generate content
echo "Generating content..."
nlm generate-guide "$NOTEBOOK_ID"
nlm audio-create "$NOTEBOOK_ID" "Create comprehensive overview"

echo "Complete! Notebook ID: $NOTEBOOK_ID"

Troubleshooting

Common Issues

"Authentication failed"

• Run nlm auth to re-authenticate
• Check Google account permissions
• Verify NotebookLM API access

"Notebook not found"

• Verify notebook ID with nlm ls
• Check for typos in ID
• Ensure notebook not deleted

"Source processing failed"

• Check source URL accessibility
• Verify file format supported
• Try re-adding source
• Check file size limits

"Rate limit exceeded"

• Add delays between commands
• Use batch operations
• Reduce concurrent requests

"Audio generation timeout"

• Normal for large notebooks
• Check status with nlm audio-get
• Generation can take 5+ minutes

Debug Mode

Enable verbose output:

# Set debug environment variable
export NLM_DEBUG=true

# Run commands with debug info
nlm <command>

Logs and Support

Check logs:

# Location varies by OS
# macOS/Linux: ~/.nlm/logs/
# Windows: %APPDATA%/nlm/logs/

tail -f ~/.nlm/logs/nlm.log

Get help:

nlm --help
nlm <command> --help

Advanced Usage

Scripting Examples

Bulk notebook creation:

#!/bin/bash
# Create multiple project notebooks

PROJECTS=("AI Ethics" "Market Analysis" "Technical Review")

for project in "${PROJECTS[@]}"; do
  NOTEBOOK_ID=$(nlm create "Q4 2024: $project" | grep -oE '[a-f0-9-]{36}')
  echo "$project: $NOTEBOOK_ID" >> notebooks.txt

  # Initialize with template
  nlm new-note "$NOTEBOOK_ID" "Project Overview"
  nlm new-note "$NOTEBOOK_ID" "Resources"
  nlm new-note "$NOTEBOOK_ID" "Tasks"
done

Periodic source refresh:

#!/bin/bash
# Refresh all web sources weekly

NOTEBOOK_ID="your-notebook-id"

# Get web sources (filter URLs)
nlm sources $NOTEBOOK_ID | grep "http" | awk '{print $1}' | while read source_id; do
  echo "Refreshing: $source_id"
  nlm refresh-source $source_id
  sleep 5
done

Content export pipeline:

#!/bin/bash
# Export all notebook content

NOTEBOOK_ID="your-notebook-id"
OUTPUT_DIR="export-$(date +%Y%m%d)"

mkdir -p "$OUTPUT_DIR"

# Export guide
nlm generate-guide $NOTEBOOK_ID > "$OUTPUT_DIR/guide.md"

# Export outline
nlm generate-outline $NOTEBOOK_ID > "$OUTPUT_DIR/outline.md"

# Export all notes
nlm notes $NOTEBOOK_ID | while read note_id _; do
  nlm edit-note $NOTEBOOK_ID $note_id > "$OUTPUT_DIR/note-$note_id.md" 2>/dev/null || true
done

# Download audio if available
nlm audio-get $NOTEBOOK_ID | grep -o 'https://.*\.mp3' | xargs -I {} curl -o "$OUTPUT_DIR/audio.mp3" {}

echo "Export complete: $OUTPUT_DIR"

Quick Reference

Essential Commands

# Setup
nlm auth

# Notebooks
nlm ls                           # List all
nlm create "title"              # Create
nlm rm <id>                     # Delete
nlm analytics <id>              # Stats

# Sources
nlm sources <id>                # List
nlm add <id> <input>           # Add
nlm rm-source <id> <source>    # Remove
nlm rename-source <id> "name"  # Rename
nlm refresh-source <source>    # Refresh
nlm check-source <source>      # Check

# Notes
nlm notes <id>                  # List
nlm new-note <id> "title"      # Create
nlm edit-note <id> <note> "content"  # Edit
nlm rm-note <note>             # Remove

# Audio
nlm audio-create <id> "instructions"  # Create
nlm audio-get <id>              # Get
nlm audio-rm <id>               # Delete
nlm audio-share <id>            # Share

# Generation
nlm generate-guide <id>         # Guide
nlm generate-outline <id>       # Outline
nlm generate-section <id>       # Section

# Batch
nlm batch <file>                # Run commands

Key Principles

1. Authenticate first - Run nlm auth before any operations
2. Save notebook IDs - Store returned IDs for subsequent commands
3. Descriptive naming - Use clear, searchable titles for notebooks and sources
4. Regular maintenance - Check source freshness and remove outdated content
5. Rate limiting - Add delays between batch operations
6. Error handling - Check command output and handle failures gracefully
7. Organize notes - Structure information consistently across notebooks
8. Generate content - Use AI features to synthesize and summarize
9. Share selectively - Audio overviews are public when shared
10. Automate workflows - Script repetitive tasks for efficiency

Workflow Summary

When user wants to use NotebookLM CLI:

1. Verify authentication - Check credentials with nlm auth
2. Identify operation - Create, manage, or generate content
3. Get notebook ID - List or create notebook as needed
4. Execute commands - Run appropriate nlm commands
5. Handle errors - Check output and retry if needed
6. Verify results - Confirm operations completed successfully
7. Organize content - Rename, structure, and maintain sources
8. Generate insights - Use AI features for guides, audio, outlines
9. Share appropriately - Export or share relevant content
10. Automate - Script repetitive workflows for efficiency

Remember: NotebookLM CLI enables powerful research workflows through command-line automation. Combine with bash scripts and automation for maximum productivity.