# Google Gemini Document Upload Limits: 10-File Caps, Sizes, and Workarounds

The Google Gemini document upload limit restricts web interface users to a maximum of 10 attached files per prompt up to 100MB each, while the Google Gemini File API allows individual files up to 2GB with a 20GB per-project storage cap and 48-hour retention. Working with enterprise repositories or large document sets requires bypassing manual chat attachments using remote retrieval architectures and shared workspaces.

Source: https://fast.io/resources/gemini-document-upload-limit/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-10-10

## What is the document upload limit in Google Gemini?

Google Gemini restricts web interface uploads to 10 files per prompt at 100 MB per document, as documented in Google's official Gemini Apps support specifications on October 10, 2026. This dual boundary means that whether you submit brief text notes, research PDFs, or complex spreadsheets, the web interface rejects any individual document larger than `100 MB` or any prompt containing an eleventh file.

The Google Gemini document upload limit restricts web interface users to a maximum of 10 attached files per prompt up to 100MB each, while the Google Gemini File API allows individual files up to 2GB with a 20GB per-project storage cap and 48-hour retention. Knowing where these boundaries lie prevents unexpected job failures when analyzing technical manuals, financial statements, or legal records.

Google enforces different upload constraints depending on the access tier, model deployment, and protocol:

* **Gemini Web Interface (Free Tier):** Accepts up to `10` files in a single prompt. Documents, spreadsheets, and text files are capped at `100 MB` per file. Video files can reach up to `2 GB` with a maximum duration of 5 minutes. Audio files are limited to 10 minutes.
* **Gemini Advanced (Google AI Pro and Google AI Ultra Plans):** Retains the standard `10`-file attachment limit and `100 MB` document size cap. The paid subscription increases video duration allowances to 1 hour and audio analysis to 3 hours.
* **Google Workspace Accounts (Work and School):** File uploads follow consumer size limits but are governed by organizational access policies. Connecting to Google Drive requires the Workspace administrator to enable Gemini Apps access.
* **Gemini Files API (Developer Tooling):** Intended for programmatic multimodal ingestion in Google AI Studio and Vertex AI. Supports files up to `2 GB` each with a project storage limit of `20 GB`. Uploaded files persist for 48 hours before automatic deletion.
* **Inline API Payloads:** Passing file bytes directly as base64-encoded strings inside prompt requests imposes a `100 MB` total payload ceiling per API call.

The following comparison table outlines the documented limits across Gemini environments as of October 2026:

| Interface or Tier | File Count Cap | Document Size Limit | Retention Period | Formats Supported | Verified Date |
|---|---|---|---|---|---|
| Gemini Web Free | 10 files per prompt | 100 MB per document | Active session | PDF, DOCX, TXT, CSV, Sheets | October 2026 |
| Gemini Advanced | 10 files per prompt | 100 MB per document | Active session | PDF, DOCX, TXT, CSV, Code | October 2026 |
| Gemini Workspace | 10 files per prompt | 100 MB per document | Policy dependent | PDF, Google Docs, Office files | October 2026 |
| Gemini Files API | 20 GB project cap | 2 GB per file | 48 hours | Documents, Audio, Video, Images | October 2026 |
| Inline API Calls | Token bounded | 100 MB total payload | Request lifetime | Base64 encoded media and text | October 2026 |

Specific constraints apply when uploading compressed archives or project directories. Uploading a folder through the web interface unpacks its contents, with every individual file counting toward the `10`-file maximum. If a folder holds 15 small text files, the upload fails. Standard ZIP archives are capped at `100 MB`, cannot contain audio or video files, and cannot hold more than `10` internal items. Dedicated code folder uploads and connected GitHub repositories allow up to `5,000` files with a combined maximum archive size of `100 MB`.

## How does Gemini calculate token limits against document file sizes?

Clearing the `100 MB` file size threshold does not guarantee that Gemini can process your document. File size measures disk storage in megabytes, whereas model comprehension is constrained by context window token capacity. A dense `40 MB` text export can contain several million words, exceeding the processing capacity of any frontier model. Conversely, an `80 MB` PDF containing scanned diagrams might contain only a few thousand words but will consume visual tokens for each rendered page.

Gemini models feature industry-leading context windows, but those windows remain absolute boundaries:

* **Gemini 1.5 Pro:** Supports an input context window of `2,097,152` tokens.
* **Gemini 1.5 Flash:** Provides an input context window of `1,048,576` tokens.
* **Gemini 2.0 Flash:** Maintains a `1,048,576` token input context window.

When a user uploads a PDF document, Gemini parses the content through two distinct tokenization pipelines:

* **Digital Text Layers:** Machine-readable text embedded in PDFs is extracted directly. In standard English prose, one token represents roughly four characters, or approximately 0.75 words. A 500-page plain text document contains roughly `200,000` tokens, which fits comfortably within Gemini's input window.
* **Scanned Pages and Visual Elements:** Scanned documents, technical drawings, charts, and embedded photographs are converted into visual tiles. Gemini standardizes image processing by dividing pages into 384 by 384 pixel patches, each consuming `258` tokens. A 300-page scanned legal filing consumes `77,400` visual tokens before accounting for optical character recognition of the text content.

### Transport ceilings versus context exhaustion

Multi-turn conversations compound token consumption rapidly. In the Gemini web interface, every question and answer in a chat thread is retained in memory. When you upload three 50-page reports totaling `120,000` tokens and ask six follow-up questions, Gemini re-evaluates the entire conversation history on every turn.

As context grows, responses can become slower or less focused. While Gemini handles large contexts effectively, dense multi-document prompts run the risk of missed details or degraded reasoning across distant sections. Starting a fresh chat thread for new questions clears accumulated dialogue history and keeps context focused.

### Multimodal resolution and prompt placement

In programmatic implementations using the Gemini API, developers can configure the `media_resolution` parameter to control token usage across visual inputs. Setting media resolution to low reduces token overhead for simple black-and-white documents, while high resolution preserves fidelity for detailed charts, financial tables, and blueprints.

Prompt placement also influences retrieval quality. Google documentation recommends placing reference files before instructional prompts when analyzing multiple documents, while placing single-page images after the instructional text helps ground specific visual extraction tasks.

## Why does the Gemini File API purge uploaded files after 48 hours?

The Gemini File API provides developer infrastructure for large multimodal files, but it is engineered as an ephemeral staging cache rather than a persistent document repository. Google's official documentation defines the exact storage boundaries: "The Files API lets you store up to 20 GB of files per project, with a per-file maximum size of 2 GB. Files are stored for 48 hours."

Google offers the Files API at no cost across all regions where the Gemini API operates. Because storage is unmetered, Google enforces automatic deletion after 48 hours to prevent the service from becoming an unmanaged dumping ground for terabytes of media. Developers can query file metadata or manually delete files before the 48-hour expiration using the `files.delete` method. However, user-uploaded files cannot be downloaded back through the API. The `files.download` method is restricted to model-generated assets, such as rendered video files.

This 48-hour retention limit introduces serious obstacles for enterprise production systems:

* **Broken Agent Loops:** Autonomous agents and automated data pipelines that store file resource names in relational databases fail when the 48-hour window expires, returning HTTP 404 errors on subsequent runs.
* **Bandwidth Overhead:** Ingesting a `15 GB` corporate documentation library requires re-uploading the entire dataset every two days. For distributed teams, this generates continuous network overhead and introduces latency into scheduled analysis jobs.
* **The Project Quota Ceiling:** When an organization needs to analyze `35 GB` of historic contracts or medical scans, the Files API rejects additional uploads once the `20 GB` project cap is reached. Engineers must write custom garbage collection scripts to prune older files.
* **Siloed Developer Keys:** Files uploaded to the Files API are bound to a single Google Cloud project and API key. Non-technical team members, auditors, and external collaborators cannot inspect, organize, or review the underlying documents.

## What errors occur when you exceed Gemini document upload limits?

Violating Gemini upload boundaries produces specific interface warnings and API errors. Identifying the root cause allows you to apply the correct technical fix rather than guessing at file formatting issues.

Common upload errors include:

* **"Delete data to upload file":** This error occurs in the Gemini web application when your internal Gemini Apps Activity storage is full. This storage allocation is independent from your Google Drive or Google One storage. Even if your Google One account has 2 TB of free space, a full Gemini Activity quota blocks further document uploads. To resolve this in personal accounts, open Gemini Apps Activity and delete historical conversations that contain heavy attachments. In Workspace accounts, your administrator must clear activity history or adjust retention policies.
* **File size ceiling warning:** Displayed in the Google Gemini browser interface when attempting to upload a document, spreadsheet, or archive that exceeds `100 MB`. To bypass this, split multi-chapter PDFs into smaller files or convert dense spreadsheets to compressed CSV formats.
* **"Too many files in prompt":** Appears when dragging more than `10` files into the chat box or uploading a folder containing more than `10` files. You must combine text into single files or upload documents sequentially in separate prompts.
* **"Upload limit reached" (Rolling Usage Limits):** Gemini applies rate limits to document analysis over rolling windows. If you submit several maximum-sized PDFs within minutes, the web interface temporarily disables attachments. Waiting one to two hours resets the rolling window.
* **"400 Invalid Argument: File size exceeds 2 GB":** Returned by the Gemini Files API when a file exceeds `2 GB` or the project crosses the `20 GB` threshold. Calling `files.list` and deleting expired files resolves the issue.
* **Context Window Truncation:** If a document's total tokens exceed the model's context capacity, Gemini either displays a processing error or truncates earlier text, leading to incomplete answers.

## How can teams analyze large document collections without hitting Gemini upload caps?

Organizations managing complex document libraries, such as compliance repositories, product technical manuals, or legal litigation archives, cannot rely on 10-file chat limits or 48-hour temporary API storage. Five architectural patterns allow teams to analyze large corpora without running into upload ceilings:

1. **Local File Splitting and Extraction:** Developers use local scripts with libraries like `pypdf` or `pdfcpu` to split 1,000-page files into smaller segments. While simple, this approach strips visual layouts, loses page context, and requires local computational resources.
2. **Google Drive Integration:** Gemini web users can connect Google Drive to query stored files. However, Workspace accounts require administrative activation, attachments remain subject to per-prompt token limits, and multi-file cross-referencing remains constrained.
3. **Pre-Signed Object Storage URLs:** Developers store documents in Google Cloud Storage or Amazon S3 buckets and pass temporary pre-signed URLs to the Gemini API. While bypassing the `2 GB` Files API limit, raw object storage provides no search indexing, forcing the model to ingest complete files on every request.
4. **Custom Vector Databases:** Engineering teams construct Retrieval Augmented Generation (RAG) pipelines using vector databases like Pinecone or Qdrant. While functional, building and maintaining custom chunking logic, embedding generation, vector indexes, and sync routines requires dedicated developer maintenance.
5. **Intelligent Cloud Workspaces via Model Context Protocol:** A cleaner approach connects Gemini directly to a persistent, intelligent cloud workspace. Instead of attaching files to prompts or re-uploading documents every 48 hours, teams store their complete document library in a shared workspace on [Fastio workspace storage for agents](/storage-for-agents/).

Fastio delivers an intelligent workspace platform designed for human-agent collaboration. Files uploaded to a workspace are automatically indexed for hybrid search, which combines full-text keyword indexing, semantic understanding, and search by metadata value. Rather than forcing an LLM to read 500 pages of text, an assistant queries the workspace and retrieves only the relevant paragraphs with citations.

Workspaces provide shared org-owned repositories, per-file version history, and a detailed activity log that records modifications across team members and agents. Documents can be imported from Google Drive, Dropbox, Box, and OneDrive. Fastio supports Cloud Sync for Google Drive, Dropbox, Box, and OneDrive on a schedule or on demand.

Connecting Gemini CLI or custom agents to Fastio takes minutes using the remote Model Context Protocol (MCP) server over Streamable HTTP. In the Gemini CLI configuration file (`settings.json`), add the server under `mcpServers`:

```json
{
  "mcpServers": {
    "fastio": {
      "httpUrl": "https://mcp.fast.io/mcp/code"
    }
  }
}
```

Sign in with OAuth in your browser to complete authentication. When an agent needs information from an indexed `500 MB` manual, it calls the `search` tool. Fastio returns the exact passages required for inference, consuming only `1,500` prompt tokens instead of exhausting context limits. Review setup steps in the [Fastio MCP setup documentation](https://mcp.fast.io/docs).

For structured document processing across contracts, receipts, or medical forms, teams deploy [Metadata Views](/product/document-data-extraction/). Metadata Views extracts typed fields (Text, Integer, Decimal, Boolean, URL, JSON, Date & Time) from unstructured documents into an interactive database without manual template training.

Monthly plans start with a 14-day free trial, which requires a credit card. Plans are Starter at `$9.99/mo` (3 seats, `250 GB`, 5 workspaces, `100,000` credits a month), Business at `$49.99/mo` (10 seats, `5 TB`, 50 workspaces, `600,000` credits a month), and Enterprise at `$199.99/mo` (30 seats included, more at `$1` a seat up to `200` seats, `25 TB`, 200 workspaces, `3,000,000` credits a month). Maximum upload sizes reach `25 GB` on Starter, `50 GB` on Business, and `100 GB` on Enterprise. Credits meter AI operations, with overage billed at `$10` per `100,000` credits. Extra storage is 1.5 cents per GB a month and extra bandwidth is 4 cents per GB. Check full plan details on the [Fastio pricing page](/pricing/).

## How do Claude and ChatGPT document limits compare to Gemini?

Evaluating document upload boundaries across leading AI platforms helps teams select the right environment for specific document processing requirements.

Anthropic Claude provides distinct attachment models across its web app and project workspaces. In standard Claude chat, users can upload up to `20` files at up to `500 MB` each. In Claude Projects, individual documents are capped at `30 MB`, but the total number of files is unlimited. The operational ceiling on a Claude Project is Claude's `200,000`-token context window; once total project files approach that limit, users must remove documents or seek external retrieval.

OpenAI ChatGPT allows users to attach up to `10` files per prompt, with an individual file cap of `512 MB`. ChatGPT processes documents using an internal code execution sandbox or vector retrieval store, subject to account-wide rolling usage caps.

Google Gemini balances smaller document caps in its web chat with larger developer file capacities. The Google Gemini web interface restricts uploads to `10` files per prompt at `100 MB` per document, while the developer Files API supports files up to `2 GB` with a 48-hour retention lifecycle.

The following table compares file constraints across the three major platforms:

| Platform and Interface | Files per Prompt | Max Document Size | Video File Cap | Persistence Model | Storage Ceiling |
|---|---|---|---|---|---|
| Google Gemini Web | 10 files | 100 MB | 2 GB | Session / Activity storage | Gemini Activity quota |
| Google Gemini Files API | Project quota | 2 GB | 2 GB | 48 hours | 20 GB per project |
| Anthropic Claude Chat | 20 files | 500 MB | Not supported | Active chat session | Context window bound |
| Anthropic Claude Projects | Unlimited count | 30 MB | Not supported | Persistent in Project | 200,000 token window |
| OpenAI ChatGPT Plus | 10 files | 512 MB | 512 MB | Session sandbox | Account usage quotas |

Each platform serves distinct use cases. Google Gemini provides unmatched video analysis capacity (up to `2 GB`) and an expansive 2-million-token window in Gemini 1.5 Pro. Anthropic Claude offers larger per-file document sizes in standard chat (`500 MB`) and structured project workspaces. However, all three platforms share the same core limitation: prompts and projects are designed for focused sessions, not enterprise-wide document archives. Offloading document repositories to a persistent, searchable workspace enables teams to use Gemini, Claude, and OpenAI models interchangeably without bumping into proprietary upload caps.

## Frequently asked questions

### What is the file size limit for Gemini document uploads?

In the Gemini web and mobile applications, the file size limit for documents, spreadsheets, text files, and code archives is `100 MB` per file. Video files can be up to `2 GB`. For developers using the Gemini Files API, the individual file size limit is `2 GB` across all supported file types, with a total project storage cap of `20 GB`.

### How many documents can you upload to Google Gemini at once?

In the Gemini web interface, you can upload up to `10` files in a single prompt. If you upload a folder, every file inside that folder counts toward the 10-file limit. ZIP archives are also limited to a maximum of `10` contained files and `100 MB` total size. Specialized code folders or connected GitHub repositories can include up to `5,000` files up to `100 MB` total.

### Does Gemini delete uploaded files after 48 hours?

Yes, files uploaded through the developer Gemini Files API are automatically deleted after 48 hours. During that 48-hour period, developers can run inference and inspect file metadata, but user-uploaded files cannot be downloaded back through the API. In the Gemini consumer web app, uploaded files persist within your Gemini Apps Activity until you delete them or clear your chat history.

### Can you upload ZIP files or folders directly to Gemini?

You can upload ZIP archives and folders to the Gemini web app, subject to strict constraints. ZIP files can be up to `100 MB` and contain a maximum of `10` individual files, with audio and video files excluded. Standard folders are unpacked upon upload, and each enclosed file counts against the 10-file per-prompt limit. Code repositories uploaded via the dedicated code feature can contain up to `5,000` files within a `100 MB` ceiling.

### How do you resolve the 'Delete data to upload file' error in Gemini?

The 'Delete data to upload file' error indicates that your Gemini Apps Activity storage is full. This storage pool is separate from Google Drive or Google One storage. To fix it, open Gemini Apps Activity and delete past conversations and uploaded attachments. In Google Workspace accounts managed by an organization, contact your Workspace administrator to clear stored activity or adjust retention settings.

### Can Fastio import documents from Google Drive for Gemini analysis?

Yes. Fastio supports cloud import from Google Drive, Dropbox, Box, and OneDrive, allowing you to bring existing documents into an intelligent workspace without local downloads. Fastio offers scheduled Cloud Sync for Google Drive, Dropbox, Box, and OneDrive. Once imported, workspace documents are automatically indexed for hybrid search, allowing Gemini assistants connected via MCP to query files without hitting upload caps.

## Sources

- [Google Help: Upload and analyze files in Gemini Apps](https://support.google.com/gemini/answer/14903178): Google Gemini web application caps document attachments at 10 files per prompt and 100 MB per file.
- [Google AI for Developers: Gemini API Files Documentation](https://ai.google.dev/gemini-api/docs/files): The Gemini Files API stores up to 20 GB per project with a 2 GB per-file cap and deletes files after 48 hours.

## 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, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli. MCP setup is at https://mcp.fast.io/docs: Claude and most MCP clients connect to https://mcp.fast.io/mcp/tools, ChatGPT to https://mcp.fast.io/mcp/operations, and coding agents to https://mcp.fast.io/mcp/code.