# Google NotebookLM Context Window: Source Limits, Token Math, and Workspaces

NotebookLM was renamed Gemini Notebook on 16 July 2026. The Gemini Notebook context window combines Gemini's long-context attention architecture with a structured ingestion limit of 50 sources per notebook, capped at 500,000 words per document. While a notebook can hold up to 25 million words aggregate, direct ingestion gates prevent attaching massive document archives. Research teams decouple storage by keeping their primary collections in intelligent workspaces and querying indexed files on demand via Model Context Protocol.

Source: https://fast.io/resources/notebooklm-context-window/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-09-12

## What Is the Google NotebookLM Context Window?

NotebookLM was renamed Gemini Notebook on 16 July 2026. Google's official [Gemini Notebook documentation](https://support.google.com/gemininotebook/answer/16215270) establishes that uploaded file sources are restricted to a maximum of 500,000 words or 200MB per document, capped at 50 sources per notebook on the free plan as of September 2026. The Gemini Notebook context window combines Gemini's long-context attention architecture with a structured ingestion limit of 50 sources per notebook, capped at 500,000 words (roughly 665,000 tokens) per individual document.

Understanding the notebooklm context window requires distinguishing between raw neural network capacity and product-level ingestion guardrails. Google powers Gemini Notebook with Gemini 1.5 Pro and Gemini 2.0 models, which feature native context windows capable of processing one to two million tokens in developer APIs. However, NotebookLM does not expose an open prompt where you can paste raw token streams up to the model's physical limit. Instead, it wraps the underlying model in a structured container architecture designed for document-grounded retrieval.

When you add a source to a notebook, Google's pipeline parses the document, strips non-text elements, extracts the core text, and indexes it within an internal retrieval system. Across an entire notebook on the free tier, the cumulative limit reaches 50 sources, creating an aggregate notebook ceiling of 25 million words. That aggregate capacity represents an enormous amount of reading material, roughly equivalent to 50 lengthy textbooks or several years of technical reports.

However, the architecture imposes two distinct boundaries that catch researchers off guard:

* **Container Source Limits:** You cannot add a 51st source to a free notebook, regardless of how short your existing 50 files are. Fifty single-page memos consume your entire source quota just as quickly as fifty 400-page monographs.
* **Per-Document Density Caps:** You cannot upload a single document that exceeds 500,000 words or 200MB, even if it is the only source in your notebook.

These twin gates mean that the effective google notebooklm context limit is governed by file ingestion rules rather than raw transformer attention math.

### Token Math: Converting Words and Characters to Context Tokens

Many users attempt to compare the notebooklm token limit directly against developer API limits, leading to common confusion. LLMs process text in tokens (sub-word fragments) rather than whole words. In standard English prose, text typically converts at an average rate of roughly four tokens for every three words, with approximately four to five characters per word including punctuation and whitespace.

Applying this ratio to NotebookLM's ingestion parameters reveals the underlying token math:

* **Single-Source Word Cap:** 500,000 words translates to approximately 665,000 to 700,000 model tokens.
* **Single-Source Character Volume:** At five characters per word, 500,000 words equates to 2,500,000 to 3,000,000 characters.
* **Aggregate Notebook Tokens:** Fifty sources at maximum word density theoretically equals 33 to 35 million tokens across the entire container.

The following comparison illustrates how vendor metrics map across tokens, words, and storage boundaries:

| Dimension | Vendor Specification | Estimated Token Equivalent | Ingestion Scope | Date Checked |
|---|---|---|---|---|
| Single Source Word Cap | 500,000 words | 665,000 to 700,000 tokens | Per uploaded document | 2026-09-12 |
| Single Source File Size | 200MB | Format dependent | Local upload ceiling | 2026-09-12 |
| Free Notebook Sources | 50 sources | ~33 to 35 million tokens aggregate | Standard Free plan | 2026-09-12 |
| Premium Notebook Sources | 100 to 600 sources | Up to 400 million tokens aggregate | Google AI paid tiers | 2026-09-12 |
| Gemini API Context Window | 1,000,000 to 2,000,000 tokens | 750,000 to 1,500,000 words | Direct API prompt | 2026-09-12 |
| Notebook Chat Prompt | ~2,000 to 4,000 characters | ~350 to 700 tokens | Single query input | 2026-09-12 |

While the API lets developers pass two million tokens into a single inference call, Gemini Notebook uses an internal retrieval layer. When you chat with your notebook, the system does not place 25 million words into the active attention window for every prompt. Doing so would produce unsustainable latency and massive inference compute costs. Instead, Gemini Notebook queries the indexed sources, retrieves the most relevant passages, and passes those focused segments into the model's active attention window alongside your question.

## How NotebookLM Source Limits Compare Across Subscription Plans

In 2026, Google aligned Gemini Notebook quotas with its unified Google AI subscription tiers. Upgrading to a paid plan increases the number of sources you can attach to a notebook and raises your daily query thresholds, but it leaves the per-source file size and word caps completely unchanged.

The following table details the operational limits across every plan tier, verified against Google's documentation:

| Plan Tier | Sources per Notebook | Notebooks per Account | Max File Size | Word Cap per Source | Daily Chat Queries | Date Checked |
|---|---|---|---|---|---|---|
| Standard (Free) | 50 | 100 | 200MB | 500,000 words | 50 queries/day | 2026-09-12 |
| Plus | 100 | 200 | 200MB | 500,000 words | 200 queries/day | 2026-09-12 |
| Pro | 300 | 500 | 200MB | 500,000 words | 500 queries/day | 2026-09-12 |
| Ultra 20TB | 500 | 500 | 200MB | 500,000 words | 2,500 queries/day | 2026-09-12 |
| Ultra 30TB | 600 | 500 | 200MB | 500,000 words | 5,000 queries/day | 2026-09-12 |
| Google Cloud Enterprise | 500+ | Org Managed | 200MB | 500,000 words | Custom quota | 2026-09-12 |

The core implication of this quota structure is that paid subscriptions solve volume challenges, not single-document size challenges. Upgrading from the free plan to Google AI Pro multiplies your source allowance from 50 to 300 items, and Google AI Ultra pushes the limit to 600 items. Yet if you have a massive litigation transcript, historical ledger, or municipal record set exceeding 200MB or 500,000 words, no subscription tier permits you to upload that single document directly.

Collaboration rules also introduce operational boundaries. According to Google's official Gemini Notebook documentation, sharing a notebook does not change the source limit for any collaborator. If a user on an Ultra plan creates a notebook with 550 sources and shares it with a colleague on the free plan, that collaborator can query all 550 sources. However, the free user cannot upload new sources into the notebook once the creator's or container's cap is reached, and their personal daily chat query quotas remain constrained by their individual tier.

### Format Ingestion Rules and Processing Constraints

The 200MB and 500,000-word limits on uploaded file sources interact differently depending on the document format. Because the ingestion pipeline extracts raw text from binary formats, document formatting and internal structures directly influence success.

**PDF Files and Scanned Records**

Digital-native PDFs generated directly from word processors contain lightweight vector fonts and structured text streams. These files can span thousands of pages while remaining compact on disk. In contrast, scanned historical records, legal pleadings, and engineering drawings often consist of uncompressed bitmap images. A scanned deposition binder can easily exceed the 200MB limit for uploaded file sources, triggering immediate rejection before text extraction occurs. Furthermore, password-protected or DRM-locked PDFs fail ingestion across all plan tiers.

**Google Drive Documents and Spreadsheets**

Importing files from Google Drive establishes a live link that periodically checks for revisions. However, format-specific constraints apply:

* Google Sheets documents are evaluated against internal token ceilings. Dense spreadsheets containing tens of thousands of rows will truncate during ingestion, leaving trailing rows unindexed.
* Google Slides presentations enforce a hard ceiling of 100 slides per uploaded deck.
* Footnotes, user comments, and suggested revisions in Google Docs are stripped during text extraction.

**Web URLs and Multimedia Captions**

Adding a public web URL extracts only the visible HTML text body. Script tags, navigation chrome, paywalled content, and embedded media players are ignored.

For YouTube videos, NotebookLM does not process video pixels or audio waveforms directly. Instead, it extracts the official captions or auto-generated transcript. As long as the video has public captions and the transcript remains under the 500,000-word limit for uploaded sources, the import succeeds. Uploaded local audio recordings (MP3, WAV, M4A, AAC) undergo server-side speech recognition, generating a text transcript that serves as the permanent source.

## Why Multi-Document Corpora Hit the Context Window Wall

Direct-upload AI tools treat document storage as an attachment mechanism. You drag files into an isolated browser container, the service parses the text, and a conversational interface answers questions based on that closed set. While this design works well for analyzing a handful of research papers or a single handbook, it fails when applied to enterprise document archives, deep research programs, or technical documentation hubs.

The primary failure mode is source container limits. In Gemini Notebook, the 50-source wall on free accounts restricts ingestion. In Claude Projects, project knowledge is limited by the context window, 30MB per file (https://support.claude.com/en/articles/8241126-upload-files-to-claude). Attaching static files directly to prompt projects does not scale across large research libraries.

Beyond container caps, forcing dozens of massive documents into a single model context degrades analytical precision. In natural language processing, this performance drop is widely recognized as the lost-in-the-middle phenomenon. While frontier models like Gemini 1.5 Pro boast context windows exceeding one million tokens, attention mechanisms do not distribute focus uniformly across massive input sequences. Information placed at the start or conclusion of a prompt receives strong recall, whereas facts tucked away in the middle of lengthy appendices suffer from degraded retrieval accuracy and occasional hallucinations.

Furthermore, direct-upload tools create rigid repository silos. In NotebookLM, each notebook is completely isolated from every other notebook. You cannot run a unified query across Notebook A (Regulatory Filings) and Notebook B (Internal Technical Specs). To compare findings across projects, you must duplicate source files into a third notebook, burning duplicate source slots and fracturing document versioning.

Finally, consumer research notebooks offer no integration pathways for automated developer workflows. There is no standard Model Context Protocol (MCP) server, no programmatic API access, and no mechanism for autonomous agents like Claude Code, Cursor, or Codex to query your notebook sources. The documents remain trapped inside a proprietary web interface.

### Decoupling Storage from Active Model Context

Solving the context limit dilemma requires rethinking the relationship between storage and inference. In traditional computing, operating systems do not load entire multi-terabyte hard drives into CPU cache registers. Instead, the storage layer holds persistent data, and the memory bus loads only the specific instructions and records needed for the current computation.

AI document architectures require the exact same separation. The persistent corpus should live in a scalable, intelligent cloud workspace where files are permanently stored, versioned, and indexed. When an AI assistant or human user poses a question, an intelligent retrieval layer searches across the entire library, extracts only the precise relevant paragraphs, and injects those focused excerpts into the model's active context window.

This decoupled architecture provides three immediate technical advantages:

* **Resumable Chunked Ingestion:** Large files upload in resumable chunks, allowing teams to organize extensive reference libraries without encountering container-level source caps or word ceilings.
* **Maximized Attention Precision:** Because the LLM receives only highly relevant excerpts rather than twenty full-length PDFs, attention mechanisms focus directly on the pertinent facts, avoiding context dilution and retrieval degradation.
* **Universal Tool Interoperability:** Any assistant, human collaborator, or autonomous agent can query the centralized knowledge base via standardized protocols without requiring proprietary file re-uploads.

## Architecting External Workspaces for Scalable Document Retrieval

Implementing a decoupled research architecture is straightforward using [Fast.io Workspaces](/product/workspaces/). Instead of pushing entire documents into isolated chat windows, teams centralize their primary research collections in an intelligent cloud workspace. Fast.io serves as an intelligent workspace platform for agentic teams, providing persistent storage, automatic document indexing, and standardized agent connectivity.

The workflow operates across three coordinated layers:

**1. Centralized Workspace Ingestion**

Teams organize documents in shared, organization-owned Fast.io workspaces. Large files upload in resumable chunks without browser connection timeouts. Alternatively, teams can use cloud import to bring in repositories from Dropbox, Box, OneDrive, or Google Drive. Cloud Sync ships for Dropbox, Box, and OneDrive, supporting scheduled or on-demand synchronization. Google Drive imports today, with sync coming soon.

**2. Intelligence Mode and Hybrid Semantic Indexing**

Once files land in the workspace, enabling Intelligence Mode activates automatic document indexing for retrieval-augmented generation (RAG). Fast.io indexes PDFs, text files, markdown documents, spreadsheets, presentations, and images for hybrid search. This system combines full-text keyword matching with semantic vector embeddings and search-by-metadata-value. When a query is submitted, the intelligence layer returns direct answers backed by document citations that link directly to specific source passages. There is no need to configure standalone vector databases, write chunking pipelines, or manage embedding models.

**3. Remote Model Context Protocol (MCP) Integration**

Rather than uploading files into each AI tool, you connect your assistant directly to the workspace using Fast.io's remote MCP endpoint at `https://mcp.fast.io/mcp`. Fast.io exposes a consolidated MCP toolset over Streamable HTTP at `https://mcp.fast.io/mcp` and legacy Server-Sent Events (SSE) at `https://mcp.fast.io/sse`. Detailed specifications are documented in the guide to [Fast.io storage for AI agents](/storage-for-agents/).

When an assistant requires background knowledge to answer a question, it queries the workspace index using MCP tools, retrieves relevant passages, and brings only those excerpts into its active context window. Crucially, this architecture does not alter or raise Google's or Anthropic's vendor-specific upload limits. Instead, it bypasses the need to upload files into those containers entirely.

### Connecting AI Assistants to Indexed Workspaces via MCP

Configuring an AI assistant or desktop environment to query your Fast.io workspace takes only a few minutes. When connecting desktop assistants like Claude Desktop or coding agents like Cursor and Cline, you route requests to `https://mcp.fast.io/mcp/key` and pass your account API key in the authorization header.

Here is a standard client configuration block:

```json
{
  "mcpServers": {
    "fastio": {
      "url": "https://mcp.fast.io/mcp/key",
      "headers": {
        "Authorization": "Bearer YOUR_FASTIO_API_KEY"
      }
    }
  }
}
```

Once connected, your assistant gains on-demand semantic access to your entire research corpus. When you issue a complex prompt, such as asking for a cross-matter risk analysis across thirty commercial contracts, the assistant executes a semantic search across the workspace, retrieves matching sections, and synthesizes a citation-grounded response.

This architecture introduces several operational strengths over static notebook uploads:

* **Unified Team Access:** Human researchers review and organize files through the web interface, while autonomous agents read and write workspace documents through the MCP server or REST API at `https://api.fast.io/current/`.
* **Collaborative Notes:** Humans and AI agents can co-edit live research summaries in Collaborative Notes, refining working drafts and project briefs directly inside the shared space.
* **Per-File Version History:** Every document maintains full version history and an append-only audit log. When an agent or human updates a file, the changes are recorded and the intelligence index refreshes automatically.
* **Predictable Trial and Subscription Plans:** Fast.io organizes subscriptions into Starter, Business, and Growth plans, with each organization beginning with a 14-day free trial that requires a credit card. Creating a personal user account is free; team workspaces run on organization subscriptions.

## Preprocessing Techniques for Collections That Exceed Source Caps

If your immediate workflow strictly requires working directly within Google NotebookLM's native interface, several practical preprocessing strategies can help compress and restructure documents to stay under the 200MB and 500,000-word ceilings.

**1. Splitting Dense Documents with Command-Line Tools**

When a single regulatory filing, academic dissertation, or technical handbook breaches the 500,000-word or 200MB ceiling, segmenting the file into logical chapters allows you to upload each section as a distinct source.

On macOS and Linux systems, you can segment large PDFs cleanly using `qpdf`:

```bash
qpdf input-large-corpus.pdf --pages . 1-150 -- part-1.pdf
qpdf input-large-corpus.pdf --pages . 151-300 -- part-2.pdf
```

Segmenting by topic or chapter ensures that internal cross-references remain coherent within each uploaded file.

**2. Compressing Raster Graphics in Scanned PDFs**

Oversized PDF files almost always result from high-resolution bitmap scans rather than textual volume. Downsampling embedded raster images to 150 DPI provides clean text for NotebookLM's optical character recognition while cutting file size by half or more.

You can downsample oversized scans using Ghostscript:

```bash
gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/ebook \
   -dNOPAUSE -dQUIET -dBATCH \
   -sOutputFile=compressed-document.pdf input-scanned-record.pdf
```

The `/ebook` profile recompresses internal images to 150 DPI, bringing bulky scans safely under the 200MB limit for uploaded file sources without compromising readability.

**3. Converting Audio to Text Transcripts Locally**

Uploading raw audio recordings directly to NotebookLM consumes significant network bandwidth and relies on server-side transcription queues. For lengthy panel discussions, client interviews, or conference recordings, transcribe the audio locally using open-source transcription models before uploading. A multi-hour audio recording that occupies hundreds of megabytes in raw format compresses to a lightweight plain text file under the 500,000-word limit for uploaded sources, importing in seconds.

**4. Extracting Tabular Data into Structured Metadata Views**

Large spreadsheets and tabular appendices often trigger row truncation in NotebookLM or produce poor analytical results in unstructured chat prompts. For structured records such as invoices, legal contracts, or real estate leases, use [Metadata Views](/product/document-data-extraction/) within Fast.io.

Metadata Views convert unstructured documents into an interactive, typed spreadsheet. Users describe the fields they want extracted in natural language, and AI designs a schema covering Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time types. Connected agents and human team members can filter, sort, and query structured data via MCP without consuming file upload slots or cluttering model context windows.

## Frequently asked questions

### What is the context window of NotebookLM?

Google NotebookLM operates on Gemini models with long-context capabilities, but it enforces an ingestion limit of 50 sources per notebook on the free plan, with each source capped at 500,000 words or 200MB. This provides an aggregate notebook capacity of up to 25 million words.

### How many tokens can NotebookLM handle?

An individual source capped at 500,000 words corresponds to roughly 665,000 to 700,000 tokens. Across a full 50-source notebook on the free tier, aggregate storage reaches approximately 33 to 35 million tokens. However, NotebookLM retrieves relevant excerpts for each query rather than passing all 35 million tokens into active model attention at once.

### What is the maximum file size and source limit for Google NotebookLM?

Google NotebookLM enforces a maximum file size limit of 200MB per uploaded file and a word limit of 500,000 words per source. Free accounts can upload up to 50 sources per notebook, while paid Google AI tiers expand source capacity to between 100 and 600 sources per notebook.

### Does upgrading to Google AI Pro increase the per-source word limit in NotebookLM?

No. Upgrading to paid plans like Google AI Pro or Ultra increases the number of sources you can attach to a notebook (up to 300 or 600 sources) and raises daily query quotas, but the single-source ceiling remains strictly 500,000 words and 200MB across all plans.

### How does the NotebookLM context window differ from the Gemini API context window?

The Gemini developer API allows passing up to two million raw tokens directly into an active inference prompt. In contrast, NotebookLM is an end-user application that indexes uploaded sources and uses internal retrieval mechanisms to pull relevant passages into the prompt context on demand.

### How can teams query document collections that exceed 50 sources?

Teams can store large document archives in an intelligent cloud workspace such as Fast.io with Intelligence Mode enabled. Connected AI assistants query the indexed corpus using the remote Model Context Protocol (MCP) server, retrieving matching passages on demand through [Fast.io storage for AI agents](/storage-for-agents/) without hitting container upload caps.

## Sources

- [Google: Gemini Notebook Help - Add or discover new sources for your notebook](https://support.google.com/gemininotebook/answer/16215270) — Google NotebookLM documentation specifies that each source can contain up to 500,000 words or up to 200MB for uploaded files, with up to 50 sources allowed for free users, totaling up to 25 million words aggregate.
- [Google: Gemini Notebook Help - Upgrade Gemini Notebook](https://support.google.com/gemininotebook/answer/16213268) — Collaborating on a shared notebook does not alter the source capacity limit for any collaborator across plan tiers scaling from 50 to 600 sources.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server at https://mcp.fast.io/mcp, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli.