# Gemini Attachment Limit: File Caps and Multi-Document Workarounds

The Gemini attachment limit restricts uploads to 10 files per prompt (subject to availability) in the Gemini web and mobile apps, a figure Google's help page gives without separate numbers per plan. While Gemini models on paid plans work with a 1 million token context window, the interface blocks batch document ingestion for larger corpora. Teams can combine files, use developer APIs, or connect persistent external workspaces through Model Context Protocol servers to bypass upload caps.

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

## How Google Gemini Prompt Attachment Limits Work

Google Gemini restricts users from uploading more than 10 files in a prompt across web and mobile apps, as documented in [Google Gemini Help](https://support.google.com/gemini/answer/14903178?hl=en) guidelines. This limit applies uniformly whether interacting through desktop web browsers, Android devices, or iOS mobile applications. When users attempt to select or drag an eleventh file into the chat composer, the interface blocks the addition, forcing researchers and engineers to rethink how they ingest multi-document corpora.

The Gemini attachment limit is the maximum number of individual files, strictly capped at 10 attachments per prompt in the web interface, that a user can attach to a single prompt.

Understanding this ceiling requires distinguishing between file count constraints and underlying model capacity. While the transformer architecture powering Gemini can evaluate substantial context volumes, the consumer front end enforces discrete intake gates to maintain interface responsiveness and balance server loads.

The 10-file ceiling applies to all standard media and document formats supported by the web interface, including PDF files, DOCX documents, CSV spreadsheets, plain text notes, and raster images. Google also enforces distinct per-file size ceilings. Individual text documents, PDFs, spreadsheets, and images have a maximum file size of `100 MB`. Video uploads accept files up to `2 GB`, though total video duration is restricted to 5 minutes on standard accounts and 1 hour on Google AI Pro or Google AI Ultra subscriptions. Audio recordings can span up to 10 minutes on standard accounts or 3 hours on paid subscriptions.

The table below outlines how attachment limits, file size ceilings, and knowledge storage mechanisms compare across the major commercial AI assistant platforms:

| AI Assistant Platform | Attachment Limit | Per-File Size Ceiling | Persistent Project or Knowledge Cap | Documented Architecture |
|---|---|---|---|---|
| Google Gemini (Web & Mobile) | 10 files per prompt | 100 MB docs, 2 GB video | 1 code folder (5,000 files, 100 MB) or 10-file ZIP | Rolling upload limits; 1M token context on Google AI Pro and Ultra |
| Anthropic Claude (claude.ai) | 20 files per chat | 500 MB per file | Unlimited files in Projects (bounded by context window) | 200K to 1M token context window depending on model; project knowledge with RAG |
| OpenAI ChatGPT (Web) | Up to 80 files every 3 hours | 512 MB docs, 20 MB images | 5 to 40 files per Project by plan, 10 knowledge files per GPT | Rolling upload limits; up to 2M tokens per text file |

Comparing these numbers shows that file intake constraints are standard across consumer chat platforms. Anthropic Claude permits up to 20 files per chat as documented in [Claude Help Center](https://support.claude.com/en/articles/8241126-upload-files-to-claude) guides, while OpenAI's help center documents a rolling limit of 80 files every 3 hours for ChatGPT. However, differences emerge in how each platform handles persistent context and external file libraries.

### Understanding File Formats and Media Caps in Gemini Apps

Gemini Apps accept a broad array of input formats, yet each format interacts differently with Google ingestion pipeline. Standard office documents such as DOCX, XLSX, and PDF files are parsed upon upload. When a spreadsheet is attached, Gemini can parse tabular rows and render dynamic charts directly within the conversation window.

However, each file consumes a distinct portion of the 10-attachment quota regardless of file size. Attaching nine single-page receipts and one 50-page technical manual reaches the 10-file ceiling just as quickly as attaching 10 massive annual reports. Once ten files are attached to a prompt, Gemini does not accept another until one is removed.

Multimodal inputs introduce additional constraints. While images (JPEG, PNG, WebP, GIF) count as single file slots against the 10-file limit, video and audio files require substantial pre-processing time. If a user combines multiple high-resolution photos with audio recordings in a single submission, the total prompt payload must remain under the cumulative bandwidth and memory limits enforced by the active session.

### How Gemini Calculates Limits Across Free and Paid Tiers

A frequent point of confusion among technical teams involves the relationship between paid subscription tiers and prompt attachment limits. Google offers two primary consumer upgrades: Google AI Pro (formerly Gemini Advanced) and Google AI Ultra.

Upgrading to Google AI Pro provides access to Google's more capable models, a larger 1 million token context window, and longer uploads: total video length rises from 5 minutes to 1 hour and audio from 10 minutes to 3 hours. Google AI Ultra includes the same extended upload lengths with higher usage limits.

Google's help page states the 10-file-per-prompt figure without separate numbers per plan, and says a Google AI plan brings higher limits for this feature, such as the ability to upload more files or ask Gemini to reference uploaded files in more chats. The payment mainly buys a larger context window, longer media, and higher rolling usage limits, so plan multi-document work around 10 items per prompt.

## Why Multi-Document Research Fails at Prompt Attachment Caps

Enterprise knowledge work routinely exceeds 10 discrete source files. A legal team reviewing discovery material regularly parses dozens of deposition transcripts. A financial analyst conducting competitive research evaluates scores of quarterly filings and investor presentations. A software architecture committee evaluates dozens of system specification documents.

When an analyst attempts to run these workflows through the Gemini web interface, the 10-file attachment limit breaks the natural flow of investigation. The user must manually divide the corpus into arbitrary batches, asking the assistant to analyze files in sequential prompts.

This batching strategy fails because conversational AI models are not stateless databases. As a conversation grows, earlier documents become part of the prompt history, inflating token consumption and degrading the precision of subsequent responses.

### The Disconnect Between Token Context Windows and Attachment Caps

The primary paradox of the Gemini web interface is the sharp contrast between backend model capacity and front-end interface constraints. On paid Google AI plans, Gemini Apps work with a 1 million token context window. According to Google, a 1M token context window can take in up to 1,500 pages of text or 30,000 lines of code.

Mathematically, a one-million-token model could comfortably read dozens of average-length business documents in a single inference pass without exceeding its architectural boundaries. Yet the web application artificially restricts the prompt payload to 10 files.

Google does not publish its reasons, but the restriction sits at the application layer rather than the model layer. Uploading, scanning, and parsing arbitrary user files generates substantial input/output load on web servers, and converting multi-page PDFs, spreadsheets, and scanned documents into model input requires immediate compute resources. A per-prompt cap likely keeps individual web sessions from overwhelming document-processing services.

### Token Consumption and Retrieval Degradation Across Long Conversations

Attempting to bypass attachment caps by feeding documents across successive prompt turns creates severe operational inefficiencies. When files are attached directly to a chat session, their parsed text remains embedded in the conversation transcript. On every subsequent prompt, the client application re-submits the entire cumulative transcript, including all previously attached text, back to the model.

This cumulative resubmission triggers two distinct problems:

First, token consumption accelerates rapidly. A user who uploads 10 files in prompt one, asks a follow-up question in prompt two, and uploads 10 more files in prompt three forces the model to read the first 10 files three times and the second batch twice. In API environments, this multiplies token costs. In consumer web applications, it rapidly exhausts the user's compute allocation.

Second, models suffer from attention dilution, often described as the lost-in-the-middle phenomenon. When an assistant is forced to evaluate dozens of diverse documents crammed directly into its raw context transcript, its ability to recall specific granular facts, resolve cross-document contradictions, and extract accurate citations declines. Prompt attachments were designed for quick, ad-hoc queries, not for systematic enterprise knowledge retrieval.

## What Native Workarounds Exist Inside the Google Ecosystem

Before adopting external storage architectures, practitioners often explore native mechanisms provided within Google's software ecosystem. While certain native tools provide partial relief for specific technical workflows, each carries structural boundaries that limit general business utility.

Users frequently experiment with compressed archives, code folder upload tools, local document concatenation scripts, and developer APIs to move multi-document corpora into Gemini. Understanding the exact mechanical boundaries of each option clarifies why general business workflows require dedicated workspace storage rather than ad-hoc compression or custom scripting.

Each workaround involves balancing operational effort against file format restrictions and ongoing maintenance requirements. Evaluating these four standard paths reveals where native Google tools function smoothly and where complex multi-document research hits practical roadblocks.

### Using ZIP Files and Code Folders Within Google Guidelines

A common initial hypothesis among power users is that compressing multiple files into an archive will bypass the 10-attachment rule. However, Google's Gemini Apps documentation explicitly defines how archives are handled:

ZIP files uploaded to Gemini web and mobile apps can contain up to 10 files inside, must remain under `100 MB` total size, and cannot include audio or video files. Each file inside the archive counts against the user's available quota, so an archive of 12 documents exceeds the documented limit. Compressing files into a ZIP archive therefore bundles data for transfer convenience, but it does not expand total file allowances.

Google provides an exception specifically for software engineering workflows through code folders and GitHub repository imports. Users can upload a complete code folder or link a GitHub branch containing up to `5,000` files and up to `100 MB` total per chat.

While this code ingestion capability is valuable for software developers auditing repositories, it does not solve document research problems. The code import is built for source code and text files (such as .py, .js, .ts, .json, and .md), not for binary business formats like PDFs, DOCX files, PPTX decks, and high-resolution scanned records.

### Pre-Processing Document Concatenation and the Files API

Another common workaround is document concatenation: merging multiple smaller files into a single composite file prior to upload. For example, an engineer can use a command line utility like `pdfunite` or a Python script to bind 20 distinct PDF briefs into one consolidated 400-page PDF document.

While a single concatenated document consumes only one of the 10 attachment slots, it introduces serious practical disadvantages:
- Document boundaries, original file headers, and metadata become obscured, making accurate source attribution difficult.
- The consolidated file frequently exceeds the `100 MB` individual file size ceiling.
- Updating or replacing a single source document requires rebuilding and re-uploading the entire merged volume.

For engineering teams building custom software, Google AI Studio offers a developer-focused path through the Gemini Files API (`generativelanguage.googleapis.com`). The Files API allows developers to upload files up to `2 GB` each, with up to `20 GB` per project, and stores them on Google infrastructure for 48 hours. Developers can upload hundreds of files programmatically via REST calls and pass the resulting file URIs in API requests.

The Files API resolves file count caps for custom code, but it is an ephemeral developer API rather than a persistent collaborative workspace. Files expire and delete automatically after 48 hours, requiring continuous re-uploading. It also lacks a visual interface, role-based sharing, or version history for non-developer colleagues.

## How to Decouple Document Storage from Prompt Context with Fastio and MCP

The primary architectural solution to prompt attachment limits is decoupling document storage from prompt payloads. Instead of uploading static files directly into chat composer boxes, organizations store their document collections in persistent cloud workspaces. The AI assistant then accesses and searches the repository dynamically using the Model Context Protocol (MCP).

In this decoupled model, the assistant does not ingest entire document collections upfront. When a user asks a question, the assistant queries the workspace index, extracts only the relevant text excerpts with verifiable source citations, and synthesizes the answer.

Fastio leaves every vendor's prompt upload limit exactly where it is. What it adds is an indexed, searchable place for the files that do not fit into the prompt box. A research library containing 500 PDF contracts, 200 architectural schematics, or 1,000 research reports lives securely in [Fastio workspaces](/product/workspaces/), accessible to people through web interfaces and to AI assistants through standardized MCP tools.

### Connecting AI Assistants to Remote Workspaces via Streamable HTTP

Connecting an assistant to a Fastio workspace requires no local runtime wrappers, command-line bridges, or local disk syncing. The Fastio MCP server is a hosted remote service operating over the modern Streamable HTTP transport with OAuth authentication.

Depending on the AI client your team uses, you connect to the dedicated address:
- For Claude applications (claude.ai, Claude Desktop, Claude mobile, and Claude Cowork) and general personal agent runtimes, connect to `https://mcp.fast.io/mcp/tools`.
- For coding agents in IDEs and terminals (such as Claude Code, Cursor, Cline, and Gemini CLI), connect to `https://mcp.fast.io/mcp/code`.
- For ChatGPT and Codex, the Fastio plugin is available directly in the plugin directory; alternatively, custom connections point to `https://mcp.fast.io/mcp/operations`.

Consult the setup documentation at `https://mcp.fast.io/docs` for client-specific walkthroughs.

To populate the workspace, files can be uploaded directly or synchronized from existing repositories. Cloud Sync connects Google Drive, Dropbox, Box, and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. When files arrive, Intelligence Mode on [Fastio AI](/product/ai/) automatically parses and indexes content for hybrid search across full text, semantic meaning, and metadata properties without requiring a separate vector database.

### Hybrid Search and Document Retrieval in Action

Once connected through MCP, the AI assistant no longer needs files attached to its prompt. When a user asks a complex question across hundreds of documents, the assistant invokes the workspace `storage` tool with a search action:

```json
{
  "name": "storage",
  "arguments": {
    "action": "search",
    "query": "indemnification liabilities and third party intellectual property obligations",
    "workspace_id": "YOUR_WORKSPACE_ID"
  }
}
```

The workspace executes a hybrid retrieval pass, combining keyword indexing with semantic vector embeddings. Instead of flooding the conversation with 50 full-length agreements, the MCP server returns the precise paragraphs, page numbers, and file identifiers relevant to the prompt. The assistant answers the question accurately while consuming minimal context tokens.

When teams need structured tabular data extracted across hundreds of unstructured documents, [Metadata Views](/product/document-data-extraction/) allow users to define typed schemas (text, numbers, dates, booleans) in plain language. Fastio extracts fields automatically across invoices, insurance policies, or contracts into a filterable spreadsheet without brittle templates or OCR rules.

## How to Organize Large Document Sets for Agentic Teams

Managing large document collections across human teammates and autonomous agents requires clear governance, provenance tracking, and data security. Treating an AI assistant as a collaborative team member means giving it controlled access to shared workspaces rather than pasting raw files into temporary chat windows.

By establishing shared organization-owned workspaces, setting role-based permissions, and keeping a detailed activity log, distributed teams keep both humans and autonomous agents operating from a single, verified source of truth, with version history behind every change.

Teams working across legal discovery, technical documentation, or financial compliance require persistent environments where file updates land cleanly. Structured workspaces provide the operational foundation for agents and humans to share, inspect, and verify multi-document research libraries without running into prompt limits.

### Workspace Architecture and Access Governance

In Fastio, access controls and permissions are structured per organization, workspace, and share. Organization owners assign roles to team members and AI integrations at the workspace boundary, ensuring an agent inspecting financial audits cannot access unrelated personnel files.

When sharing materials externally with clients, partners, or contractors, teams use branded shares (Send, Receive, and Exchange). Shares can be configured with expiration dates, access passwords, and download restrictions. If an external client needs to review a confidential report, a share can disable file downloads entirely, allowing in-browser review with downloads turned off.

Every file stored in a workspace maintains complete per-file version history. When an agent updates a data summary or a human editor revises a brief, the prior version is preserved and restorable. Concurrently, a detailed activity log records all modifications, including file uploads, edits, moves, deletions, and share creations. The detailed activity log tracks operational changes across human and agent collaborators, providing clear oversight of project evolution.

### Multi-Agent Coordination and State Persistence

Autonomous agents frequently work in multi-step sequences where one agent gathers data, a second evaluates risk, and a third drafts executive summaries. If agents rely on local scratch folders or chat attachments, context evaporates the moment a process completes or encounters an error.

Fastio provides persistent workspaces where agents read and write shared assets reliably. To document research findings, agents and human teammates use Collaborative Notes kept directly beside project files in the workspace. Notes use version-checked saves rather than concurrent real-time co-editing, preventing conflicts when multiple agents record findings across research phases.

Advisory file locks are available for coordinating multi-agent updates. An agent acquires a temporary lease on a specific file through the `lock-acquire` action on the `storage_manage` tool and releases it with `lock-release`. Because locks never grant exclusive write rights, concurrent writes still land, and version history preserves every version.

For organizations deploying persistent workspaces, monthly plans start with a 14-day free trial that requires a credit card. Subscriptions are Starter at `$9.99/mo` (`3` seats, `250 GB` storage, `5` workspaces, `100,000` monthly credits), Business at `$49.99/mo` (`10` seats, `5 TB` storage, `50` workspaces, `600,000` monthly credits), and Enterprise at `$199.99/mo` (`30` seats included, more at `$1` a seat up to `200`, `25 TB` storage, `200` workspaces, `3,000,000` monthly credits). Additional storage beyond plan limits is `1.5 cents` per GB monthly, and credit overage is billed at `$10` per `100,000` credits. Review subscription options on the [Fastio pricing](/pricing/) page.

## Frequently asked questions

### How many files can you attach to Gemini at once?

In the Google Gemini web and mobile applications, you can attach a maximum of 10 files (subject to availability) in a single prompt. Google's help page gives this 10-file figure without separate numbers for free accounts, Google AI Pro (Gemini Advanced), or Google AI Ultra. Standard documents, spreadsheets, and images are limited to `100 MB` per file, while video files can be up to `2 GB`.

### Can I upload more than 10 files to Google Gemini?

The standard Gemini chat prompt blocks uploading more than 10 files at once. However, you can work around this limitation for software projects by uploading a code folder or importing a GitHub repository, which supports up to `5,000` files and `100 MB` total. For general document libraries, developers use the Gemini Files API to upload files up to `2 GB` each (up to `20 GB` per project), or connect persistent external workspaces through Model Context Protocol (MCP) servers.

### What is the file attachment limit for Gemini Advanced?

Google's help page lists 10 files per prompt (subject to availability) without a separate figure for Gemini Advanced, now offered through Google AI Pro and Google AI Ultra plans, though it says Google AI plans bring higher limits for file uploads, such as uploading more files or referencing uploaded files in more chats. Paid plans also provide a 1 million token context window and extend maximum video upload length from 5 minutes to 1 hour and audio from 10 minutes to 3 hours.

### Does compressing files into a ZIP archive bypass the Gemini attachment limit?

Compressing files into a ZIP archive does not bypass the 10-file limit. According to Google Gemini Apps guidelines, ZIP archives uploaded to the chat interface can contain up to 10 files inside. ZIP archives cannot include audio or video formats. Uploading an archive containing more than 10 files will result in extraction errors or missed files.

### How does Gemini file upload compare to Claude and ChatGPT?

Google Gemini allows up to 10 files per prompt with a `100 MB` document size cap. Anthropic Claude permits up to 20 files per chat at up to `500 MB` per file, and offers unlimited document uploads within Claude Projects subject to the model's context window. OpenAI ChatGPT documents a `512 MB` document ceiling and a rolling limit of 80 files every 3 hours.

### How can AI agents search hundreds of documents without prompt uploads?

Instead of attaching raw documents directly to chat prompts, agents connect to persistent cloud workspaces using the Model Context Protocol (MCP). Workspaces index large document libraries with hybrid search combining keyword and semantic matching. When prompted, the assistant searches the index via MCP tools and retrieves only relevant excerpts, bypassing front-end prompt attachment caps and preserving context tokens.

## Sources

- [Google Gemini Help: Upload & analyze files in Gemini Apps](https://support.google.com/gemini/answer/14903178?hl=en): Google Gemini restricts users from uploading more than 10 files in a prompt across web and mobile apps, including files inside ZIP archives.
- [Claude Help Center: Upload files to Claude](https://support.claude.com/en/articles/8241126-upload-files-to-claude): Anthropic Claude permits up to 20 files per chat with individual file sizes up to 500MB.

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