ChatGPT Plus Upload Limit: File Size, Count, and Rolling Caps

As of September 2026, ChatGPT Plus subscribers are limited to 80 file uploads every 3 hours, a 512 MB maximum size per file, and a 25 GB end-user storage cap. While the headline file size accommodates substantial document drops, multiple concurrent constraints govern how OpenAI processes uploaded files.

ChatGPT Plus upload limit is OpenAI's policy capping Plus subscribers at 80 file uploads every 3 hours, a 512 MB maximum size per file, and a 10-million-token lifetime extraction limit per file.

Competitors report generic file size caps without mentioning the critical 80 files per 3 hours rolling window or 10M token lifetime extraction rule. In practice, hitting an upload wall rarely stems from a single boundary. Instead, users encounter different operational ceilings depending on whether they upload raw text documents, high-resolution images, dense spreadsheets, or custom project files.

The following reference table outlines the documented file size limits, accepted formats, and primary operational constraints across ChatGPT Plus surfaces:

Understanding the distinction between transport limits and execution limits prevents runtime errors. Transporting a file under 512 MB over HTTP into ChatGPT storage succeeds initially. However, if that file contains hundreds of millions of text characters or hundreds of thousands of spreadsheet rows, downstream execution environments reject the payload during parsing.

• Gemini Gems File Limit: 10-File Upload Cap and Knowledge Base SolutionsThe Gemini Gems file limit caps custom knowledge bases at 10 reference files and 100 MB per document. While attached...
• CSV File Size Limits: AI Assistant Upload Caps, Parsing Ceilings, and FixesCSV file size limits vary from strict row boundaries in spreadsheets to memory and token constraints in AI chat...
• Notion File Upload Limits: Size Caps by Plan and Large-File WorkaroundsNotion limits individual file uploads to 5MB on the Free plan and provides unlimited file uploads with a 5GB maximum...
• OpenAI Assistant File Limits: Upload Caps, Size Limits, and SolutionsOpenAI assistant file limits balance responsiveness against overhead, restricting direct attachments while capping...
• Excel File Size Limits: Documented Caps and Large Workbook WorkaroundsMicrosoft Excel enforces a 1,048,576 row cap per worksheet, Excel Online restricts browser editing to 100MB workbooks,...
• GitLab File Size Limits: Repository Caps, LFS, and Agent WorkspacesGitLab file size limits restrict web UI attachments to 100 MB by default and individual git pushes to 5 GiB through...

More on this subject: Agent File and Document Workflows (269 guides)

When working with batches of research papers, legal contracts, or log archives, upload failures often occur well before reaching individual file size boundaries. ChatGPT Plus enforces cadence constraints that operate across rolling timeframes and individual conversational turns.

1. The 80-File Rolling 3-Hour Window

Eligible ChatGPT users face a rolling ceiling of up to 80 files every 3 hours, which OpenAI may reduce during peak hours. This is a dynamic rolling window, not a static quota that resets at midnight UTC.

Every upload increments an internal counter that records the exact timestamp of the transaction. A file uploaded at 1:15 PM occupies a quota slot until 4:15 PM. If a user uploads 50 files at 1:15 PM and 30 files at 2:00 PM, the account hits the limit. The user cannot upload another file until 4:15 PM, when the first batch of slots expires.

2. The 20-File Per-Message Ceiling

In the ChatGPT web and desktop interfaces, users can attach up to 20 files to an individual prompt. Dragging more than 20 files into the composer triggers an immediate client-side error.

Submitting four consecutive messages containing 20 files each consumes the entire rolling allowance for the next 3 hours. For teams conducting batch analysis across dozens of client reports, this ceiling creates an operational barrier that halts work midway through an evaluation pipeline.

3. Why Failed Upload Attempts Consume Quota

A common frustration occurs when an account gets blocked after uploading only a handful of completed files. OpenAI documents that failed upload attempts can sometimes count toward the upload-rate cap.

If an upload fails due to an unsupported file container, an intermittent network disconnection, or a malformed PDF, the request may still register on OpenAI's rate limiting proxy. Retrying a failed upload ten times in rapid succession burns ten slots from your rolling window. When an upload error appears, repeating the upload immediately without correcting the root cause accelerates account throttling.

4. ChatGPT Projects Boundaries

ChatGPT Projects provide dedicated workspaces for organizing chats, custom instructions, and reference documents. In ChatGPT Plus, Projects enforce two specific boundaries:

• File Capacity: Each project supports a collection of 25 files.
• Batch Upload Cap: Ingestion accepts 10 files uploaded at one time.

Attaching reference documentation to a Project draws from this pool. Once a Project reaches 25 files, additional uploads fail until existing files are removed, regardless of remaining storage capacity in the user's account.

Beyond physical file size and message count, ChatGPT Plus enforces strict computational ceilings on document text and spreadsheet execution.

The 512 MB Transport Versus 50 MB Execution Boundary

While the file uploader accepts tabular spreadsheets up to 512 MB, running Advanced Data Analysis on large CSV or Excel files presents a severe bottleneck.

Spreadsheets uploaded to ChatGPT undergo automated processing inside a sandboxed Python container running libraries like pandas and openpyxl. Parsing a CSV requires converting raw text records into memory structures, DataFrame objects, and type arrays. A raw spreadsheet containing numeric telemetry or customer transaction logs can expand into several gigabytes of memory once loaded into a DataFrame.

Because OpenAI restricts container RAM to maintain cluster multi-tenancy, tabular files exceeding approximately 50 MB routinely trigger memory exhaustion, script termination, or generic execution errors. For tabular data, 50 MB represents the practical ceiling for stable interactive analysis.

Document Token Extraction Ceilings

For unstructured text files, such as PDFs, Markdown documentation, and Word documents, OpenAI evaluates content volume using token counts rather than byte sizes:

• Single Document Ceiling: Text and document files uploaded to ChatGPT conversations are capped at 2,000,000 tokens per file.
• Advanced Data Analysis Cap: Advanced Data Analysis caps individual file extraction at 10,000,000 tokens across a file's extraction lifetime.

If a technical manual, legal transcript, or codebase archive exceeds these token boundaries, ChatGPT truncates the document during ingestion or drops older passages from model context. Users asking questions about sections located toward the end of an oversized document receive hallucinated or incomplete answers because those tokens never reached the active inference layer.

Pre-Checking File Metrics Before Upload

To avoid consuming rolling upload slots with files that exceed execution limits, engineering teams can inspect token counts and memory footprints locally using Python:

import sys
import pandas as pd
import tiktoken

def inspect_file_for_chatgpt(file_path: str):
    enc = tiktoken.get_encoding("cl100k_base")
    
    if file_path.endswith((".csv", ".tsv", ".xlsx")):
        df = pd.read_csv(file_path) if file_path.endswith(".csv") else pd.read_excel(file_path)
        mem_mb = df.memory_usage(deep=True).sum() / (1024 * 1024)
        print(f"Rows: {len(df):,}, Columns: {len(df.columns)}")
        print(f"Estimated In-Memory Footprint: {mem_mb:.2f} MB")
        if mem_mb > 50.0:
            print("WARNING: In-memory footprint exceeds 50 MB. Split table before uploading.")
    else:
        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
            text = f.read()
        tokens = len(enc.encode(text))
        print(f"Total Tokens: {tokens:,}")
        if tokens > 2_000_000:
            print("WARNING: Document exceeds 2,000,000 token limit. Truncation will occur.")

if __name__ == "__main__":
    inspect_file_for_chatgpt(sys.argv[1])

Running this check beforehand ensures that files sent to ChatGPT Plus remain within supported analytical boundaries.

Scale Beyond ChatGPT Upload Limits With Persistent Storage

Organize large document corpora in persistent Fastio workspaces. Index multi-gigabyte collections for semantic retrieval through the remote MCP server without hitting chat upload caps. Every organization starts with a 30-day free trial (credit card required).

Start 30-Day Trial

When ChatGPT displays an error message such as "Upload Failed" or "You have reached your file upload limit", apply a systematic diagnostic workflow to resolve the issue without burning rolling quota slots.

1. Verify File Format and Container Size

Confirm that the asset complies with OpenAI's documented specifications:

• Images: Must be under 20 MB and formatted as PNG, JPEG/JPG, or non-animated GIF. Formats like HEIC, TIFF, and SVG should be converted locally to PNG before uploading.
• Spreadsheets: Ensure the raw file is under 50 MB. If working with large exports, drop unneeded historical columns or filter date ranges to reduce size.
• Text Documents: Ensure files are under 512 MB and under 2,000,000 tokens. Remove embedded base64 image strings from Markdown or HTML files.

2. Check the 3-Hour Rolling Window Timeline

If you recently uploaded files in bulk, note the exact timestamp and timezone of your earliest upload. Avoid testing repeated uploads while rate-limited, as failed requests can register against the quota. Allow 3 hours from the initial upload burst before sending new file batches.

3. Deconstruct Multi-File Messages

If a prompt containing numerous attachments fails to process, the issue may stem from combined prompt weight rather than an individual file defect. Split the workload into smaller logical groups of three or four files. Provide clear instructions with each sub-group to maintain conversational continuity.

4. Audit Account Storage and Purge Unused Files

Open the ChatGPT Library view from your account settings. ChatGPT Plus provides 20 GB of Library storage within a broader 25 GB end-user file cap.

Deleting a chat conversation does not remove files that were saved to your Library. To reclaim storage space:

1. Open account settings and select the Library tab.
2. Review stored documents and sort by file size.
3. Permanently delete outdated datasets and completed analysis files.

5. Check Service Status Before Repeated Attempts

Before diagnosing account-level errors, check the official OpenAI Status page at status.openai.com. Database maintenance, vision pipeline outages, or code execution container degradation can present as upload rejections. If an active service incident is underway, wait until operations normalize before attempting further uploads.

While ChatGPT Plus provides convenient interactive analysis for individual files, conversational chat interfaces present architectural friction when applied to persistent, multi-gigabyte document collections.

Engineering and operations teams frequently encounter three fundamental limitations when relying solely on direct chat attachments:

• Context Dilution: Attaching large files floods the context window with raw text, reducing room for reasoning and triggering lost-in-the-middle degradation.
• Ephemeral Persistence: Uploaded files remain siloed within individual chat threads or capped projects, preventing centralized version management across team members.
• Quota Bottlenecks: High-throughput workflows regularly hit rolling file upload caps, interrupting scheduled analytical operations.

Comparing Large-Corpus Storage Strategies

Teams handling large document collections typically evaluate three distinct approaches:

Decoupling File Storage from Model Inference

The sustainable solution for large document collections is decoupling storage from model context. Instead of forcing files through conversational upload dialogs, teams maintain their document corpus in persistent cloud workspaces and expose that data to AI assistants through the Model Context Protocol (MCP).

In this architecture, document collections reside in Fastio workspaces. Intelligence Mode automatically indexes incoming files for hybrid search (combining full-text, semantic retrieval, and metadata search). When an assistant needs information, it does not ingest the entire file. Instead, it queries the workspace via MCP, retrieves relevant text passages with precise citations, and grounds its response using minimal context tokens.

Fastio Workspace Capabilities for Agentic Teams

Fastio provides dedicated workspace infrastructure designed for collaborative teams and AI workflows:

• Remote MCP Server: Assistants connect to Fastio via Streamable HTTP at https://mcp.fast.io/mcp/tools (ChatGPT connects through the Fastio plugin, with a custom MCP server at https://mcp.fast.io/mcp/operations as an alternative). The consolidated MCP toolset enables assistants to search workspaces, read files, inspect metadata, and save outputs.
• Automated Cloud Sync: Connect external cloud storage directly to your workspace. Cloud Sync supports Dropbox, Box, and OneDrive with one-way or two-way synchronization on a schedule or on demand. Google Drive imports files today, with automated sync coming soon.
• Metadata Views: Extract structured data from complex files without building custom OCR pipelines. Described at /product/document-data-extraction/, Metadata Views turn messy contracts, invoices, and research papers into queryable tables with typed fields.
• Per-File Version History: Every modification made by human editors or AI assistants is tracked in complete version history, allowing teams to audit changes and restore prior revisions.
• Append-Only Audit Log: Maintain immutable activity logging for file access, updates, and share downloads.
• Collaborative Notes: Co-edit project documentation and analysis summaries alongside AI assistants in real time.
• E-Signature Workflows: Send documents for electronic signature directly from workspaces with signer sequencing, audit certificates, and completed files stored back into the workspace, available at /product/e-signature/.

Transparent Workspace Plans

Every organization begins with a 30-day trial (credit card required). Ongoing subscriptions provide transparent capacity:

• Starter ($29/mo): 5 seats, 1 TB storage, 300,000 AI credits monthly ($290 billed annually).
• Business ($99/mo): 20 seats, 10 TB storage, 1,200,000 AI credits monthly ($990 billed annually).
• Enterprise ($299/mo): 50 seats, 50 TB storage, 4,500,000 AI credits monthly ($2,990 billed annually). Additional seats can be added as team requirements expand. Additional credits are available at $10 per 100,000 credits.

For teams building autonomous workflows, explore technical architecture at Fast.io Storage for Agents, read agent onboarding specifications at fast.io/llms.txt, and review subscription details on the Fast.io Pricing page.