# Google Gemini Upload Limits: File Caps, Size Ceilings & Large-Corpus Solutions

The Google Gemini upload limit restricts users to attaching a maximum of 10 files per prompt, with individual file sizes capped at 100MB and PDF documents limited to 48 pages on free accounts. Although Gemini models handle large context windows, prompt attachment caps trigger well before token exhaustion. Teams working with large document libraries bypass manual upload ceilings by connecting external workspaces through remote Model Context Protocol servers.

Source: https://fast.io/resources/gemini-upload-limit/
Author: [Tom Langridge](https://fast.io/authors/tom-langridge/)
Last reviewed: 2026-10-31

## What is the upload limit for Google Gemini?

The Google Gemini upload limit restricts users to attaching a maximum of 10 files per prompt, with individual file sizes capped at 100MB and PDF documents limited to 48 pages on free accounts. Google documents that Gemini Apps accept up to 10 files in a single prompt, with non-video files capped at 100 MB and video files capped at 2 GB. Whether you submit brief technical notes, research PDFs, or complex spreadsheets, the web interface rejects any individual document larger than `100 MB` or any prompt containing an eleventh file.

When users ask how many files can you upload to Gemini, Google restricts Gemini Apps uploads to 10 files in a single prompt across desktop web browsers, Android apps, and iOS clients. Under the official Gemini file upload size cap, Google restricts Gemini Apps non-video uploads to 100 MB per file, encompassing text documents, spreadsheets, presentations, and PDFs.

Google enforces distinct upload constraints depending on the access tier, interface, and protocol:

* **Gemini Web Interface (Free Tier):** Enforces the standard Gemini prompt upload limit of `10` files per 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 (and `50 MB` for PDF documents).

The following comparison table outlines the documented Gemini upload limits across 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`.

## Why token context windows and file upload caps collide

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.

Competitors frequently confuse Gemini's 1 million to 2 million token context window with prompt file upload caps, failing to explain that web UI upload limits trigger long before token exhaustion occurs. Gemini models feature extensive context windows, but those windows remain absolute boundaries:

* **Free Web Tier:** Features a `32,768` token context window, which translates to approximately `48` pages of standard text.
* **Google AI Plus:** Expands the context window to `128,000` tokens, processing roughly `190` pages.
* **Deep Think Mode:** Operates within a specialized `192,000` token context window, processing approximately `290` pages.
* **Google AI Pro and Ultra:** Provides a `1,000,000` token context window, capable of reading up to `1,500` pages of text or `30,000` lines of code.

When using the web interface, users encounter three specific failure modes and error warnings related to file processing:

* **Your uploads may be too large for the best results:** This warning appears when the attached document approaches the effective context limit. When prompted with massive documents, the model can miss connections or omit details scattered across distant sections.
* **Delete data to upload file:** Gemini Apps maintain an internal storage quota for data saved from previous chat activity, including uploaded files and generated artifacts. This storage is completely independent of Google Drive or Google Workspace storage limits. Users with terabytes of free Google Drive space still hit this wall if their Gemini chat history fills up. Resolving it requires deleting past Gemini chats or custom Gems.
* **You have reached your limit for chats with files:** Google enforces rolling capacity limits on how frequently users can upload and analyze files within a specific timeframe. Google publishes no fixed daily count or hourly quota, stating only that the limit resets after some time. Upgrading to paid tiers increases these rolling allowances but does not remove the cap.

## Ingesting Large Files with the Gemini Files API

For developers building automated pipelines, the Gemini web interface is not a practical ingestion layer. The `10`-file cap and manual drag-and-drop workflow break down in production environments. To support larger payloads, Google provides the Files API for Google AI Studio and Vertex AI.

As documented in Google's official developer specifications, 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 before automated deletion. Google directs developers to use the Files API whenever a total request payload exceeds `100 MB`, or whenever a single PDF document exceeds `50 MB`.

The following Python example demonstrates uploading a large document to the Files API and querying it using the official Google GenAI SDK:

```python
import os
from google import genai
from google.genai import types

client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])

uploaded_file = client.files.upload(
    file="audit_report.pdf",
    config=types.UploadFileConfig(
        display_name="Financial Audit Report",
        mime_type="application/pdf"
    )
)

print(f"File uploaded successfully: {uploaded_file.name}")
print(f"File URI: {uploaded_file.uri}")

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=[
        uploaded_file,
        "Extract all vendor cost variances and list them in a Markdown table."
    ]
)

print(response.text)

client.files.delete(name=uploaded_file.name)
```

While the Files API solves the `100 MB` per-file limitation of the web UI, it introduces operational constraints for production teams:

1. **Ephemeral Lifecycle:** Files vanish after 48 hours. If your application references technical documentation, standard operating procedures, or historical contracts, your code must continually re-upload files. This causes repeated upload latency, excessive bandwidth consumption, and duplicated processing.
2. **No Persistent Team Workspaces:** The Files API is an ephemeral staging bucket tied to an API key. It lacks shared team workspaces, version histories, access management, and collaborative review mechanisms.
3. **Download Restrictions:** Google allows developers to retrieve metadata about uploaded files, but user-uploaded file bytes cannot be downloaded back through the API.

## Comparing Gemini Upload Boundaries with Claude and ChatGPT

Evaluating file upload constraints across frontier AI platforms reveals notable differences in how vendors balance file size, file count, and context persistence. Understanding these differences helps technical teams select the right assistant for their document processing tasks.

* **Claude (Anthropic):** In a standard Claude chat, users can attach up to `20` files per prompt, with each file capped at `500 MB`. In Claude Projects, individual files are limited to `30 MB` each, but there is no fixed file-count cap. A project can hold hundreds of files as long as the combined project knowledge fits within Claude's `200,000`-token context window.
* **ChatGPT (OpenAI):** Supports file uploads up to `512 MB` per document. Free tier accounts can upload only `3` files per day, while paid Plus, Team, and Enterprise accounts permit `10` files per message and up to `80` files every 3 hours. Spreadsheets are capped at `50 MB`, and CSV files cannot exceed `10,000` rows.
* **Google Gemini:** Restricts web users to `10` files per prompt and `100 MB` per document, while offering up to `2 GB` for video files. Effective reading capacity ranges from `48` pages on free accounts to `1,500` pages on AI Pro plans.

The comparison table below details the practical limits across each platform:

| Platform & Interface | Prompt File Cap | Document Size Cap | Workspace or Project Persistence | Effective Free Reading Limit | API Staging Layer |
|---|---|---|---|---|---|
| Google Gemini (Web) | 10 files | 100 MB (2 GB video) | No shared project storage | ~48 pages (32K tokens) | 2 GB per file (48-hr retention) |
| Claude (Chat & Projects) | 20 files (chat) | 500 MB (chat), 30 MB (projects) | Unlimited files up to 200K tokens | Bounded by context window | Context-dependent API payloads |
| ChatGPT (Web & Team) | 10 files | 512 MB (50 MB spreadsheets) | Custom GPT knowledge files | 3 files daily limit | OpenAI Vector Stores & Files API |

Each platform presents a distinct tradeoff. Gemini leads the market in single-file video ingestion and token context volume on paid plans, but imposes the tightest file-count ceiling per prompt (`10` files) and a modest `100 MB` document cap. Claude offers generous per-file caps in chat (`500 MB`) and flexible project organization, but enforces a `200,000`-token ceiling. ChatGPT provides a balanced middle ground for individual documents but restricts daily free usage.

## Managing large document corpora with remote MCP workspaces

When analyzing a corporate repository containing thousands of technical specifications, legal contracts, or customer support archives, dragging `10` files at a time into a chat prompt is unsustainable. Slicing PDFs into `48`-page fragments or re-uploading entire directories to ephemeral API buckets every 48 hours wastes engineering hours.

Teams facing these limits typically evaluate three architectures:

1. **Local storage and self-hosted vector databases:** Running local vector stores like Chroma or Qdrant paired with local file systems allows semantic search, but requires continuous pipeline maintenance, embedding updates, and dedicated host resources.
2. **Raw cloud object storage:** Storing document collections in Amazon S3 or Google Cloud Storage resolves raw capacity ceilings, but leaves retrieval unhandled; engineering teams must manually construct chunking, indexing, and context-retrieval middleware before an LLM can query the archive.
3. **Intelligent workspaces:** Platforms that pair persistent cloud workspaces with automated hybrid search and open protocol connectivity bridge the gap between static file storage and conversational retrieval.

Intelligent workspaces solve the architectural bottleneck of prompt limits by decoupling document storage from prompt payloads. Instead of attaching raw file bytes directly to every conversation, teams store their corpus in a persistent, organization-owned workspace and connect their AI assistant through the Model Context Protocol (MCP).

[Fastio workspaces](/product/workspaces/) provide an intelligent platform designed specifically for teams using [storage for agents](/storage-for-agents/) and handling document-heavy operations:

* **Direct and Scheduled Ingestion:** Workspaces ingest multi-gigabyte document collections through chunked uploads supporting files up to `25 GB` on Starter, `50 GB` on Business, and `100 GB` on Enterprise plans. Alternatively, Cloud Sync connects Google Drive, Dropbox, Box, and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand, without routing data through local developer machines.
* **Automated Indexing with Intelligence Mode:** Once Intelligence Mode is enabled on a workspace, all uploaded and synced documents are automatically indexed for hybrid search, combining full-text keyword indexing, semantic meaning, and metadata retrieval. Teams avoid setting up external vector databases, managing embedding models, or maintaining chunking pipelines.
* **Remote Model Context Protocol (MCP) Connectivity:** AI assistants connect to Fastio workspaces over Streamable HTTP using client-specific endpoints. Claude applications and general tools connect at `https://mcp.fast.io/mcp/tools`. ChatGPT and Codex connect via the Fastio plugin, with custom servers using `https://mcp.fast.io/mcp/operations`. Coding agents like Gemini CLI, Cursor, Claude Code, and Cline connect at `https://mcp.fast.io/mcp/code`. Setup procedures are documented at [https://mcp.fast.io/docs](https://mcp.fast.io/docs).
* **Precision Retrieval with Source Citations:** Instead of forcing hundreds of megabytes of raw files into the model context window, the AI assistant queries the workspace via MCP tools. The search engine retrieves only the relevant passages and presents answers backed by citations to specific workspace documents. This approach keeps prompts lean, avoids file upload ceilings, and eliminates token bloat.
* **Structured Data Extraction with Metadata Views:** For teams that need structured records rather than conversational summaries, [Metadata Views](/product/document-data-extraction/) extracts typed fields (Text, Integer, Decimal, Boolean, URL, JSON, Date & Time) across document collections into sortable, filterable tables without manual OCR templates.
* **Governance and Access Control:** Role-based access permissions are established at the organization, workspace, and share levels. A detailed activity log records every modification, file addition, deletion, and share creation, maintaining an accountable audit record across team members and autonomous agents. Review available [pricing plans](/pricing/) to match storage volume with your team's document requirements.

For developer environments running Gemini CLI or compatible forks like Qwen Code, connect to the workspace by adding an entry to `settings.json` under `mcpServers`:

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

In these clients, `httpUrl` selects the Streamable HTTP transport (using `url` inadvertently selects SSE, which is unsupported). Interactive clients sign in with OAuth in the browser to grant access to the appropriate workspaces.

## Frequently asked questions

### What is the upload limit for Google Gemini?

The Google Gemini upload limit in the web interface restricts users to `10` files per prompt. Non-video documents including PDFs, Word documents, text files, and spreadsheets are capped at `100 MB` each. Video uploads can reach up to `2 GB` with a duration limit of 5 minutes on free accounts or 1 hour on Google AI Pro plans. For developers, Google supports individual uploads through the Files API up to `2 GB` with a `20 GB` per-project storage cap and 48-hour temporary retention.

### How many files can I upload to Gemini at once?

You can upload up to `10` files at once in a single Gemini web prompt. If you upload a folder or a ZIP file, Gemini unpacks the archive and counts every internal file individually toward the `10`-file maximum. If a folder contains more than `10` files, the upload will fail. The only exception is code folders or connected GitHub repositories, which allow a single folder containing up to `5,000` code files with a combined size cap of `100 MB`.

### Why did my file upload fail in Gemini?

File uploads in Gemini typically fail for four reasons: the file exceeds the `100 MB` size limit (or `2 GB` for video), the prompt contains more than `10` files, the file format is unsupported, or your Gemini Apps storage quota is full. If you see the message 'Delete data to upload file', your saved chat history and past file uploads have filled your Gemini Apps storage limit, which is separate from your Google Drive storage. Deleting past Gemini chats or custom Gems resolves this error.

### Does Google AI Pro or Gemini Advanced increase the 100 MB file upload limit?

No. Subscribing to Gemini Advanced through Google AI Pro or Google AI Ultra does not increase the `10`-file prompt limit or the `100 MB` document size cap. Paid plans expand the context window from `32,768` tokens to `1,000,000` tokens, increase video duration limits from 5 minutes to 1 hour, extend audio analysis from 10 minutes to 3 hours, and provide higher rolling rate limits. However, individual document uploads remain capped at `100 MB`.

### How does the Gemini Files API differ from web prompt uploads?

The Gemini Files API is designed for programmatic developer use in Google AI Studio and Vertex AI. Unlike the web interface's `100 MB` document limit, Google allows developers to stage files up to `2 GB` each in the Files API, accommodating up to `20 GB` of total storage per project. Files uploaded via the Files API are stored temporarily for 48 hours before automated deletion and cannot be downloaded back by users.

### Can Google Gemini process a 1,000-page PDF document?

Yes, but only on paid tiers or via the developer API. A 1,000-page PDF requires roughly `258,000` tokens of context. The free Gemini web tier has a `32,768`-token context window that reads approximately `48` pages before truncating or missing details. Google AI Pro and Ultra plans feature a `1,000,000`-token context window that can process up to `1,500` pages of text, provided the PDF file size remains below the `100 MB` upload ceiling.

## Sources

- [Google Gemini Apps Help: Upload & analyze files in Gemini Apps](https://support.google.com/gemini/answer/14903178?hl=en): Google restricts Gemini Apps uploads to 10 files per prompt and 100 MB per non-video file.
- [Google AI for Developers: Files API Documentation](https://ai.google.dev/gemini-api/docs/files): The Gemini Files API supports files up to 2 GB each with a 20 GB project storage ceiling and 48-hour retention.

## 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.