# NotebookLM Fast Research vs Deep Research: Understanding the Two Query Modes

> Understand NotebookLM fast research vs deep research. Fast mode offers quick scans with URLs, while deep mode provides exhaustive web crawls and richer summaries. Choose the right mode for your research needs.

- Repository: [Teng Lin/notebooklm-py](https://github.com/teng-lin/notebooklm-py)
- Tags: deep-dive
- Published: 2026-03-09

---

**Fast research performs quick web or Drive scans returning URLs immediately, while deep research triggers exhaustive web-only crawls with richer summaries but significantly longer processing times.**

The `teng-lin/notebooklm-py` library exposes two distinct research depths when adding sources via the `source add-research` command. Understanding the technical differences between **fast research** and **deep research** modes helps developers optimize latency versus comprehensiveness in automated workflows.

## Core Architectural Differences

### RPC Method Signatures and Payloads

The divergence between modes begins in [`src/notebooklm/_research.py`](https://github.com/teng-lin/notebooklm-py/blob/main/src/notebooklm/_research.py) within the `ResearchAPI.start` method, which constructs distinct RPC payloads for Google’s internal `batchexecute` endpoint.

**Fast research** invokes the `START_FAST_RESEARCH` method (ID: `Ljjv0c`) with a compact four-element array:

```python
params = [[query, source_type], None, 1, notebook_id]
rpc_id = RPCMethod.START_FAST_RESEARCH

```

**Deep research** calls `START_DEEP_RESEARCH` (ID: `QA9ei`) using a five-element payload where the integer `5` signals the heavyweight pipeline:

```python
params = [None, [1], [query, source_type], 5, notebook_id]
rpc_id = RPCMethod.START_DEEP_RESEARCH

```

The method IDs are defined in [`src/notebooklm/rpc/types.py`](https://github.com/teng-lin/notebooklm-py/blob/main/src/notebooklm/rpc/types.py) and documented in [`docs/rpc-reference.md`](https://github.com/teng-lin/notebooklm-py/blob/main/docs/rpc-reference.md).

### Source Type Validation

Fast research supports both **web** (`source_type=1`) and **Drive** (`source_type=2`) sources via the `--from` flag. Deep research validates strictly against web-only queries, raising a `ValidationError` if you attempt to combine `mode=deep` with `source=drive`. This constraint reflects the server-side architecture: deep mode triggers a full-stack web crawler that cannot access Google Drive indices.

## Operational Characteristics

### Processing Pipeline and Latency

Fast research utilizes a **lightweight search pipeline** that queries existing indexes and returns results within seconds. This makes it suitable for ad-hoc queries where blocking execution is acceptable.

Deep research activates the **heavyweight research pipeline**, which crawls additional pages, performs supplementary ranking algorithms, and generates summaries. According to the source code, this operation is classified as a long-running task that may require many minutes to complete.

### Response Data Structures

The return formats differ significantly in `ResearchAPI.poll` (located in [`src/notebooklm/_research.py`](https://github.com/teng-lin/notebooklm-py/blob/main/src/notebooklm/_research.py)):

- **Fast research** returns sources as `[url, title, description, type, …]`. The presence of URLs allows the CLI to import sources immediately without secondary resolution.
- **Deep research** returns `[None, title, None, type, …, [report]]`. URLs are omitted initially (gathered later during import), and the extra `[report]` field contains a generated summary of the discovered content.

## Practical Implementation

### Command-Line Workflows

Use fast research for synchronous, low-latency operations:

```bash

# Fast web research (blocking)

notebooklm source add-research "Quantum computing basics" --mode fast

# Fast Drive research (blocking)

notebooklm source add-research "Project plan" --from drive --mode fast

```

Use deep research for asynchronous, agent-oriented workflows with the `--no-wait` flag:

```bash

# Deep web research (non-blocking)

notebooklm source add-research "AI safety papers" --mode deep --no-wait

# Poll for completion and import results

notebooklm research wait --import-all

```

### Python API Integration

The Python client in [`src/notebooklm/_research.py`](https://github.com/teng-lin/notebooklm-py/blob/main/src/notebooklm/_research.py) exposes these modes through the `research.start` method:

```python
from notebooklm import NotebookLMClient
import asyncio

async with await NotebookLMClient.from_storage() as client:
    # Fast research: web or drive, returns immediately

    fast_result = await client.research.start(
        notebook_id, 
        "large language models",
        mode="fast"
    )
    
    # Deep research: web only, long-running

    deep_task = await client.research.start(
        notebook_id, 
        "large language models",
        mode="deep", 
        source="web"
    )
    
    # Poll until completion for deep research

    while True:
        status = await client.research.poll(notebook_id)
        if status["status"] == "completed":
            break
        await asyncio.sleep(5)
    
    # Import discovered sources

    await client.research.import_sources(
        notebook_id, 
        deep_task["task_id"], 
        status["sources"]
    )

```

## When to Use Each Mode

**Choose fast research when:**
- Latency is critical and you need results within seconds
- You are querying both web and Drive sources in the same workflow
- Building scripts that require deterministic, short-lived request cycles

**Choose deep research when:**
- Conducting comprehensive literature reviews requiring exhaustive web crawling
- Working with agent-oriented systems that can tolerate multi-minute processing times
- You need the enriched `[report]` summaries generated by the deep pipeline

## Summary

- **Fast research** (`START_FAST_RESEARCH`) supports web and Drive sources, returns URLs immediately, and completes in seconds using a lightweight pipeline.
- **Deep research** (`START_DEEP_RESEARCH`) is web-only, omits URLs initially in favor of summary reports, and triggers long-running exhaustive crawls flagged by the integer `5` in the RPC payload.
- Both modes return a `task_id` for polling via `ResearchAPI.poll`, but deep research requires asynchronous handling with `notebooklm research wait` or manual polling loops.
- The implementation enforces source-type validation in [`src/notebooklm/_research.py`](https://github.com/teng-lin/notebooklm-py/blob/main/src/notebooklm/_research.py), preventing invalid deep research queries against Drive sources.

## Frequently Asked Questions

### Can I use deep research mode with Google Drive sources?

No. According to the validation logic in [`src/notebooklm/_research.py`](https://github.com/teng-lin/notebooklm-py/blob/main/src/notebooklm/_research.py), deep research explicitly supports **web sources only**. Attempting to execute `notebooklm source add-research "query" --from drive --mode deep` raises a `ValidationError` because the heavyweight crawler cannot access Drive indices.

### Why does deep research take significantly longer than fast research?

Deep research triggers the **full-stack web crawler and summarizer** on Google's servers, which performs multi-page crawling, additional ranking algorithms, and generates comprehensive summaries. The RPC payload includes a fixed flag `5` that signals this resource-intensive pipeline, whereas fast research queries existing lightweight indexes.

### How do I handle the asynchronous nature of deep research in production scripts?

Use the `--no-wait` flag with the CLI to return immediately with a `task_id`, then poll using `notebooklm research wait` or the Python `ResearchAPI.poll` method. In Python, implement a polling loop that checks `status["status"]` until it returns `"completed"` before calling `ResearchAPI.import_sources` to finalize the discovered content.