# ChatGPT Plus File Limit: Upload Caps, Attachment Counts & Storage

The ChatGPT Plus file limit permits users to upload up to `10` files per prompt, with each file capped at `512 MB` and text files capped at `2,000,000` tokens. While individual uploads handle substantial datasets, conversational context saturation and rolling caps create strict operational boundaries for active research. Connecting an external indexed workspace allows teams to query large corpora without hitting attachment or memory ceilings.

Source: https://fast.io/resources/chatgpt-plus-file-limit/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-10-15

## What Are the Documented ChatGPT Plus File Limits?

The ChatGPT Plus file limit permits users to upload up to `10` files per prompt, with each file capped at `512 MB` and text/document files capped at `2,000,000` tokens. According to official [OpenAI documentation](https://help.openai.com/en/articles/8555545-file-uploads-faq), users can upload up to `80` files every `3` hours, with free accounts limited to `3` file uploads per day, and each end-user account capped at a total of `25 GB` of storage. While these headline numbers accommodate standard daily tasks, production research environments encounter distinct technical constraints across file counts, byte thresholds, and token extraction boundaries.

Understanding the chatgpt plus file upload limit requires separating network transport boundaries from model execution limits. For users evaluating the chatgpt plus attachment limit or asking about chatgpt plus how many files can be submitted at once, the conversational composer enforces a strict ceiling of `10` attachments per individual prompt.

Documented Claude mechanics from official [Anthropic documentation](https://support.claude.com/en/articles/8241126-upload-files-to-claude) show a different architectural approach: Claude chat sessions accept up to `20` files at up to `500 MB` each, while Claude Projects accept files up to `30 MB` each with an unlimited file count bounded by the context window. Claude Projects has no fixed file-count cap, so any fixed project file count is false. The practical ceiling on a project is the context window itself, and reaching that boundary forces teams with large document corpora to look for alternative architectures.

The following reference table outlines the documented file caps, operating conditions, and downstream failure modes across ChatGPT Plus surfaces:

| Environment or Asset Type | Documented File Cap | Primary Operating Constraint | Downstream Bottleneck | Date Checked |
|---|---|---|---|---|
| Single Prompt Attachments | Up to 10 files per message | Web and desktop composer | Drag-and-drop blocked on eleventh file | October 2026 |
| Document Files (PDF, DOCX, TXT) | 512 MB per file | 2,000,000 tokens per file | Text truncation during extraction | October 2026 |
| Tabular Data (CSV, XLSX, TSV) | 512 MB transport cap | Approximately 50 MB execution limit | Python sandbox RAM exhaustion | October 2026 |
| Image Inputs (PNG, JPEG, WEBP) | 20 MB per image | Vision token conversion | Maximum 1,445 tokens per image | October 2026 |
| Rolling Ingestion Cadence | 80 files per 3 hours | Shared rolling account window | Upload blocking on rate-limit proxy | October 2026 |
| Account Library Storage | 25 GB end-user cap | Cumulative account retention | Upload failure until library files purged | October 2026 |
| ChatGPT Projects | 25 files per project | 10 files uploaded at one time | Shared project context boundary | October 2026 |
| Claude Chat Attachments | Up to 20 files per chat | 500 MB per file | Chat context limit | October 2026 |
| Claude Projects | Unlimited file count | 30 MB per file | Bounded only by 200,000-token context | October 2026 |

The core technical boundaries for ChatGPT Plus document ingestion include:

* **Attachment Count**: `10` files attached to a single prompt.
* **Individual File Size**: `512 MB` maximum across supported document formats.
* **Text Extraction Boundary**: `2,000,000` tokens per individual file.
* **Rolling Ingestion Rate**: `80` files across a `3`-hour rolling window.
* **Account Storage Ceiling**: `25 GB` of cumulative file storage in the user workspace library.

When evaluating these metrics, practitioners must account for how file contents are read. A file under `512 MB` transfers successfully to OpenAI storage, but downstream processing determines whether the model can reason across its contents.

## Why Multi-Document Ingestion Triggers Context Saturation and Eviction

Competitors frequently summarize headline file sizes without explaining the practical failure mode that occurs during multi-document analysis: context saturation and attachment eviction.

When a user attaches files to a prompt, ChatGPT does not immediately feed hundreds of megabytes of binary data into the neural network. Instead, the backend extracts raw text or parses file contents into structured data chunks. The model running behind the conversational interface, such as GPT-4o, operates with an active context window of `128,000` tokens.

While a user can attach up to `10` documents that consume hundreds of megabytes on disk, the extracted text from those files quickly exceeds the model's active working memory. Consider a practical research scenario where an analyst attaches five legal agreements or technical manuals, each spanning `40` printed pages. A typical printed page of dense text generates roughly `500` tokens. Five `40`-page documents represent `100,000` input tokens. When combined with system prompts, analytical instructions, and prior conversational turns, the total token volume saturates the `128,000`-token context window in just two or three exchanges.

To prevent prompt overflow, ChatGPT employs dynamic context compaction and internal retrieval mechanisms. In active sessions, this causes attachment eviction:

1. **Working Memory Eviction**: Older document passages or earlier attached files are dropped from active attention to make room for new user prompts and generated responses.
2. **Focus Narrowing**: The model begins answering exclusively from the most recently referenced document, ignoring relevant sections from earlier attachments.
3. **Hallucinated Cross-References**: When asked to compare provisions across five separate agreements, the model frequently generates plausible contractual clauses that do not exist in the source files because the earlier documents were evicted from active memory.
4. **Tail Truncation**: In large single documents exceeding `2,000,000` tokens or several hundred pages, content located toward the end of the file is omitted during text extraction.

Context saturation means that successful file upload does not guarantee comprehensive document comprehension. In multi-turn analytical sessions, prompt attachments act as temporary conversational references rather than a durable knowledge base.

## How Spreadsheet Memory Ceilings Restrict Advanced Data Analysis

A common operational trap occurs when working with structured tabular data. While the file uploader accepts spreadsheets and CSV exports up to `512 MB`, running Advanced Data Analysis on large datasets regularly fails.

Advanced Data Analysis executes code within an ephemeral, sandboxed Linux microVM equipped with Python data science libraries like pandas, numpy, and openpyxl. When a user requests data analysis, the Python environment reads the uploaded tabular file into memory as a DataFrame.

The bottleneck is memory expansion. On disk, a CSV file stores comma-delimited text characters. When pandas parses that text into numeric arrays, datetime indexes, and object-typed string columns, the in-memory footprint expands substantially. A `40 MB` raw CSV containing numeric telemetry or customer transaction logs routinely expands to `600 MB` or `1 GB` of RAM inside the Python process.

OpenAI enforces strict container resource limits to maintain multi-tenant cluster stability. Ephemeral execution environments are allocated bounded RAM, typically between `1 GB` and `2 GB`, alongside a strict per-command execution timeout of roughly `60` seconds. When a script exceeds memory thresholds, the Linux kernel terminates the Python process with an out-of-memory error. In the ChatGPT interface, this surfaces as an unhelpful failure message such as 'Error analyzing file' or 'Script execution timed out.'

For tabular datasets, `50 MB` represents the practical ceiling for stable, iterative analysis in ChatGPT Plus. Files larger than `50 MB` should be filtered or aggregated locally before upload.

Data teams can evaluate file metrics and estimate in-memory footprint locally using standard Python libraries:

```python
import os
import pandas as pd

def inspect_tabular_file(file_path: str):
    file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
    print(f"File Size on Disk: {file_size_mb:.2f} MB")
    
    if file_size_mb > 50:
        print("Warning: File exceeds the recommended 50 MB threshold for ChatGPT Advanced Data Analysis.")
    
    sample_df = pd.read_csv(file_path, nrows=1000)
    sample_mem = sample_df.memory_usage(deep=True).sum()
    estimated_total_mem_mb = (sample_mem / 1000) * (os.path.getsize(file_path) / (1024 * 1024))
    
    print(f"Sample Memory Usage: {sample_mem / 1024:.2f} KB")
    print(f"Estimated Full DataFrame RAM Footprint: {estimated_total_mem_mb:.2f} MB")

if __name__ == '__main__':
    inspect_tabular_file('quarterly_transactions.csv')
```

Pre-checking file dimensions avoids consuming rolling upload slots on datasets destined to fail during execution.

## What Are the File Limits in ChatGPT Projects and Custom GPTs?

Beyond one-off chat attachments, ChatGPT Plus provides two mechanisms for maintaining reference files across multiple conversations: ChatGPT Projects and Custom GPTs. Both mechanisms introduce distinct storage boundaries that teams must manage.

### ChatGPT Projects Boundaries

ChatGPT Projects allow Plus and Team subscribers to organize conversations, custom system instructions, and reference documents into dedicated working spaces. In ChatGPT Projects, file handling is governed by three specific rules:

* **Project File Capacity**: Each project accepts up to `25` files in its reference library.
* **Batch Ingestion Cap**: Users can upload up to `10` files in a single batch operation.
* **Shared Working Context**: Files uploaded to a project are referenced across all chats opened within that project, drawing from the shared `25`-file pool.

Once a project reaches `25` files, new attachments are blocked until existing documents are removed. While this setup helps maintain consistent context across related chats, it does not expand the underlying model's `128,000`-token context window. Queries within a project still rely on internal semantic chunking, and multiple dense documents remain vulnerable to context saturation.

### Custom GPT Knowledge Base Limits

When building Custom GPTs, creators can attach documentation to the builder's Knowledge section:

* **File Count Limit**: Custom GPTs permit up to `20` files in the knowledge configuration.
* **File Size Cap**: Each individual file can reach up to `512 MB`.
* **Retrieval Method**: Files are automatically converted into vector embeddings for similarity search when users interact with the GPT.

### The 25 GB Account Library Ceiling

All files uploaded to conversational prompts, ChatGPT Projects, and Custom GPTs count against a cumulative account storage ceiling. OpenAI documentation specifies that each end-user account is capped at `25 GB` of total storage.

OpenAI does not automatically prune older files. When an account reaches `25 GB` of cumulative storage, upload attempts fail across all chats and projects. Restoring upload capability requires users to manually open the ChatGPT Library settings, locate obsolete files, and delete them individually.

### Team Collaboration Drawbacks

Relying on ChatGPT's built-in file storage creates operational silos. Documents uploaded directly to ChatGPT are locked inside an individual user's account or closed Project environment. Team members cannot verify when a colleague updates a reference file, cannot inspect version histories, and cannot coordinate updates across departments. When a corporate policy or codebase changes, every team member must manually re-upload the revised document to their own chats or Projects.

## How to Architect Large-Corpus Analysis with External Workspaces and MCP

When analytical work involves hundreds of contracts, multi-gigabyte engineering archives, or active departmental folders, prompt-based file attachments hit a structural barrier. Forcing large document collections through individual chat attachments creates context saturation, attachment eviction, and storage silos.

Engineering teams address this challenge through several architectural patterns:

1. **Local Retrieval Scripts and Vector Databases**: Setting up local scripts connected to vector databases like Qdrant or Chroma allows granular retrieval. However, this approach requires building and maintaining ingestion pipelines, chunking logic, and embedding models, while isolating non-technical colleagues from the underlying documents.
2. **Standard Cloud Storage Buckets**: Storing files in Google Drive, Dropbox, Box, or OneDrive preserves central file access, but standard cloud folders lack automated semantic indexing and cannot communicate directly with conversational AI models without custom middleware.
3. **Intelligent Workspaces Connected via Model Context Protocol (MCP)**: Storing the corpus in an intelligent workspace that indexes documents automatically and connects directly to AI assistants.

Fast.io provides shared, org-owned [workspaces](/product/workspaces/) that serve as a persistent coordination layer for teams and AI agents. Instead of uploading large files directly to a chat prompt, teams keep their document collections in Fast.io workspaces:

* **Storage Capacity**: Workspaces accommodate substantial archives without hitting chat quotas. Starter plans include `250 GB` of storage across `5` workspaces, Business plans provide `5 TB` across `50` workspaces, and Enterprise plans offer `25 TB` across `200` workspaces. Maximum single-file upload limits are `25 GB` on Starter, `50 GB` on Business, and `100 GB` on Enterprise.
* **Automated Cloud Sync**: [Cloud Sync](/alternatives/google-drive/) connects Google Drive, Dropbox, Box, and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. Files stay synchronized with existing enterprise storage without manual re-uploading.
* **Intelligence Mode**: Enabling Intelligence Mode on a workspace automatically indexes every uploaded document for hybrid search, combining full-text search, semantic search, and metadata filtering. Documents are queryable immediately through [Fast.io AI capabilities](/product/ai/) without configuring external vector databases.

### Connecting ChatGPT to Fast.io Workspaces

Assistants connect to Fast.io over Streamable HTTP via the Model Context Protocol. Rather than attaching a `500 MB` document to a prompt, ChatGPT queries the Fast.io MCP server to retrieve only the specific sentences or data points relevant to the user's prompt.

Teams can configure the connection through two straightforward methods:

1. **ChatGPT Plugin Directory (Preferred)**: Open the ChatGPT plugin directory at chatgpt.com/plugins, locate Fastio, select Install plugin, and sign in to Fastio when prompted. Users can then query indexed workspaces directly by mentioning `@Fastio` in any chat session.
2. **Custom MCP Server (Alternative)**: In ChatGPT Settings, open Security and login and turn on Developer mode. Navigate to chatgpt.com/plugins, select the plus button, name the server Fastio, enter `https://mcp.fast.io/mcp/operations` as the server URL, create the connection, and sign in when prompted.

When ChatGPT queries Fast.io, the assistant receives targeted excerpts of roughly `300` to `500` tokens rather than entire multi-megabyte files. This pattern keeps the `128,000`-token context window clean, prevents attachment eviction, and allows users to search across tens of thousands of documents without hitting ChatGPT Plus upload caps. See [storage for agents](/storage-for-agents/) for additional deployment patterns.

Every document keeps per-file version history, while a detailed activity log of changes records uploads, modifications, and permission updates across the organization.

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` storage, `100,000` credits a month), Business at `$49.99/mo` (`10` seats, `5 TB` storage, `600,000` credits a month), and Enterprise at `$199.99/mo` (`30` seats included, `25 TB` storage, `3,000,000` credits a month). AI operations are metered by credits, with overage billed at `$10` per `100,000` credits. Setup documentation is available at [Fast.io MCP docs](https://mcp.fast.io/docs), and tool reference is documented at `https://mcp.fast.io/skill.md`. Review [Fast.io pricing](/pricing/) for full plan specifications.

## Frequently asked questions

### How many files can I upload to ChatGPT Plus at once?

You can attach up to `10` files to a single prompt in the ChatGPT composer. In addition, ChatGPT Plus enforces a rolling rate limit of up to `80` file uploads every `3` hours.

### What is the individual file size limit for ChatGPT Plus?

The individual file size limit is `512 MB` per file across supported document formats, including PDFs, Word documents, text files, and spreadsheets. For text files, OpenAI also enforces an extraction ceiling of `2,000,000` tokens per file.

### How do I analyze more than `10` files in ChatGPT Plus?

To analyze more than `10` files, you can upload them across consecutive prompts, compress them into a zip archive (which counts as a single file up to `512 MB`), or connect an external indexed repository through the Fastio MCP server so ChatGPT searches files by semantic relevance rather than prompt attachment.

### What happens when uploaded files exceed the ChatGPT context window?

When uploaded documents exceed the model's `128,000`-token context window, ChatGPT experiences context saturation. The platform uses internal chunking to retrieve relevant excerpts, but in active, multi-turn sessions, older attachments or earlier sections are evicted from working memory, leading to incomplete answers or hallucinations.

### Does ChatGPT Plus have an overall account storage limit?

OpenAI documentation specifies that each end-user account is capped at `25 GB` of total storage across saved conversation files, project documents, and ChatGPT Library assets. When your account reaches `25 GB`, new file uploads are blocked until older files are deleted.

### Why does Advanced Data Analysis fail on spreadsheets under `512 MB`?

While the transport limit is `512 MB`, Advanced Data Analysis processes spreadsheets in an ephemeral Python container with strict memory limits. Converting a raw CSV into pandas DataFrames expands the data in memory. Tabular files exceeding roughly `50 MB` frequently exhaust container RAM, resulting in script timeouts or failed executions.

## Sources

- [OpenAI Help Center: File Uploads FAQ](https://help.openai.com/en/articles/8555545-file-uploads-faq): OpenAI documentation specifies that users can upload up to 80 files every 3 hours, with free accounts limited to 3 file uploads per day, and each end-user account capped at a total of 25 GB of storage.
- [Claude Help Center: Upload Files to Claude](https://support.claude.com/en/articles/8241126-upload-files-to-claude): Anthropic Claude chat sessions accept up to 20 files at up to 500MB each, while Claude Projects accept files up to 30MB each with an unlimited file count bounded by the context window.

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