# Claude Desktop File Size Limits: Chat Uploads, Projects, and MCP Buffers

The Claude Desktop file size limit is 500MB per file in direct chat uploads and 30MB in Projects, but local filesystem MCP integrations encounter practical JSON-RPC buffer limits between 4MB and 10MB. Understanding these distinct ceilings prevents Electron application crashes, context window exhaustion, and IPC timeout errors. This guide details documented upload limits, local transport bottlenecks, and how to query gigabyte-scale document archives using external intelligent workspaces.

Source: https://fast.io/resources/claude-desktop-file-size-limit/
Author: [Tom Langridge](https://fast.io/authors/tom-langridge/)
Last reviewed: 2026-10-21

## What Are the Claude Desktop File Size Limits for Chat and Projects?

Anthropic caps direct chat attachments in Claude Desktop at 500MB per file across a maximum of 20 files, while Project knowledge files face a 30MB limit per document. The Claude Desktop file size limit is 500MB per file in direct chat uploads and 30MB in Projects, but local filesystem MCP integrations encounter practical JSON-RPC buffer limits between 4MB and 10MB. When you drag and drop a file into a Claude conversation on macOS or Windows, the client hashes the asset and transmits it to Anthropic's ingestion pipeline. The application extracts the underlying text and visual components before sending the formatted prompt to the Claude foundation model.

As verified in the [Claude Help Center](https://support.claude.com/en/articles/8241126-upload-files-to-claude), Anthropic documents that Claude chat uploads allow up to 20 files per conversation at 500MB each. This allowance provides substantial headroom for large standalone assets such as video transcripts, extensive codebases packaged as plain text, or comprehensive reports. However, specific file formats carry operational constraints beyond raw byte size:

* **PDF Documents:** Anthropic documents that Claude chat uploads accept PDF documents limited to 1,000 pages per file. Anthropic applies multimodal visual processing to analyze text alongside diagrams, charts, and embedded graphics in PDFs up to 100 pages. For PDFs ranging from 101 to 1,000 pages, the engine switches automatically to text-only extraction and ignores visual elements. Uploading a PDF exceeding 1,000 pages causes an immediate rejection error indicating the file is too large.
* **Image Assets:** Images support resolutions up to 8000x8000 pixels. Accepted formats include JPEG, PNG, GIF, and WebP. For optimal OCR and visual comprehension, Anthropic recommends resolutions of at least 1000x1000 pixels.
* **Structured Data and Office Documents:** Supported formats include DOCX, CSV, TXT, HTML, ODT, RTF, EPUB, JSON, and XLSX. Spreadsheets in XLSX format require enabling code execution and file creation within account settings. For non-PDF document formats, Claude extracts text exclusively and drops embedded imagery.

Claude Projects enforces a different architecture. Anthropic documents that Claude Project knowledge files are capped at 30MB per file. While Anthropic documents no fixed cap on the number of files you can add to a Project, the cumulative volume of text across all project documents must fit within Claude's conversational context window. Understanding how these thresholds compare across deployment channels prevents workflow interruptions:

| Interface or Channel | File Size Ceiling | File Count Cap | Extraction Method | Verification Date |
| --- | --- | --- | --- | --- |
| Claude Desktop Direct Chat | 500MB per file | 20 files per chat | Text extraction and multimodal vision (PDFs under 100 pages) | October 2026 |
| Claude Desktop Projects | 30MB per file | Unlimited (bounded by context) | Text-only ingestion into persistent prompt context | October 2026 |
| Claude Files API | 500MB per file | Organization rate limit | Direct document upload for API prompt reference | October 2026 |
| Local MCP Filesystem Server | 4MB to 10MB practical limit | Single file per tool call | JSON-RPC serialization over standard I/O pipes | October 2026 |
| Remote MCP Workspace (Fast.io) | 25 GB (Starter) to 100 GB (Enterprise) | Unlimited (bounded by plan storage) | Server-side RAG indexing and on-demand semantic retrieval | October 2026 |

## Why Claude Desktop Fails on Large Local Files: MCP Buffers and IPC Timeouts

Most guides repeat vendor upload figures without addressing the operational bottleneck developers hit when connecting local storage through the Model Context Protocol (MCP). Claude Desktop runs as an Electron application on macOS and Windows, packaging a Chromium frontend with a local Node.js runtime. When you configure a local filesystem MCP server (such as `@modelcontextprotocol/server-filesystem`) in your desktop configuration, Claude Desktop spawns the server as an independent child process. Communication between the desktop application and the MCP server occurs over standard input and standard output (`stdio`) using JSON-RPC 2.0 messages.

This architectural pattern works well for inspecting project directories and editing configuration files, but it encounters immediate friction when handling large local files:

1. **JSON Serialization and Memory Ceilings:** When Claude Desktop invokes a tool like `read_file`, the local MCP server reads the file from disk, loads the content into memory, and wraps the payload inside a stringified JSON-RPC message. Reading a massive server log file or database export requires allocating a continuous string in V8 memory. The serialized JSON message, escaping quotes and newlines, expands the byte size substantially. In practice, Node.js child process stream buffers and Electron IPC channels degrade or drop messages when single payloads exceed practical buffer thresholds.
2. **Hardcoded SDK Request Timeouts:** Under the hood, the Model Context Protocol TypeScript SDK enforces a default request timeout of 60 seconds (`DEFAULT_REQUEST_TIMEOUT_MSEC = 60000`). If a local MCP server takes longer than 60 seconds to scan a massive folder hierarchy, calculate file hashes, or parse a dense archive, Claude Desktop aborts the operation and returns `MCP error -32001: Request timed out`. Adding custom `"timeout"` flags inside `claude_desktop_config.json` fails to resolve the issue because the desktop client ignores dynamic overrides for internal SDK thresholds.
3. **Stdio Stream Pollution:** Local MCP servers must maintain strict separation between communication channels. The JSON-RPC protocol relies entirely on clean `stdout` streams. If an underlying library or custom script outputs debug statements, initialization banners, or diagnostic traces to `stdout` rather than `stderr`, the JSON parser encounters syntax errors (`MCP error -32603`). When reading large archives, unhandled buffer warnings written to `stdout` corrupt the data stream and crash the MCP connection.
4. **Context Saturation from Tool Returns:** Even if a local server successfully buffers and transmits a multi-megabyte raw text file over `stdio`, the entire content is injected directly into Claude's prompt context as the tool response. When Claude Project knowledge approaches context window limits, Claude enables RAG mode to expand capacity by up to 10x, but local tool outputs have no such automatic retrieval buffer. Dumping hundreds of thousands of words into a single tool turn instantly exhausts the conversational context window, resulting in session corruption, UI state freezes, or sudden conversation aborts.

## How Context Windows Create a Hidden Ceiling on Claude Projects

The primary reason users encounter failures with the 30MB Project file limit is the fundamental difference between storage bytes on disk and tokens in memory. Anthropic documents that Claude Project files are capped at 30MB, which can suggest that users can upload extensive technical documentation or code repositories. In practice, attempting to upload even a fraction of that volume in plain text will exhaust your context window before you approach the file size ceiling.

In natural English text, one token corresponds to approximately four characters, or roughly 0.75 words. A single megabyte of plain text contains approximately one million characters, translating to hundreds of thousands of tokens. Because standard Claude Pro and Team plans feature a 200,000 token context window, a single large file of uncompressed text can exceed the entire capacity of the model.

Token density varies widely depending on file format and content structure:

* **Tabular Datasets (CSV, TSV, JSON):** Structured data formats exhibit exceptionally high token density. Repeated column headers, JSON syntax keys, commas, quotes, and numerical values prevent tokenizers from grouping characters into common words. A dense data export from a database can consume hundreds of thousands of tokens, overwhelming a Project context within moments.
* **Source Code and Schemas:** Programming languages contain dense punctuation, camelCase identifiers, and indentation spaces that inflate token counts. A multi-file repository containing complex source code frequently requires hundreds of thousands of tokens.
* **Formatted Prose (PDF and DOCX):** While prose maintains predictable token ratios, PDFs often contain boilerplate footers, metadata dictionaries, and repetitive legal disclaimers that compound token consumption across multiple documents.

When your Project knowledge base approaches the context ceiling, several failure modes occur. The desktop interface becomes sluggish as prompt caching recalculates large context trees. In multi-turn conversations, older messages are truncated or dropped to accommodate the massive Project knowledge base. More critically, models experience attention dilution: when searching for specific answers across massive preloaded reference material, retrieval precision drops compared to targeted query lookups.

As documented in the Claude Help Center, when Claude Project knowledge approaches context window limits, Claude enables RAG mode to expand capacity by up to 10x. However, this built-in capability operates exclusively inside the Anthropic hosted environment. It does not solve local desktop file access, cannot be updated programmatically from local pipelines without manual re-uploads, and provides no shared storage layer across different development tools or team members.

## How to Work Around Claude Desktop Limits with Chunking and Filters

When working with files that exceed Claude Desktop upload limits or MCP buffer thresholds, developers rely on several architectural patterns to process large archives without crashing local runtimes.

### 1. Programmatic File Chunking
Rather than attempting to feed a massive log file or dataset into Claude Desktop in one pass, split the source file into deterministic smaller segments. Keeping individual chunk files small ensures they stay within local MCP buffer safe zones and consume manageable token budgets.

The following Python script reads any large text file and divides it into clean, line-bounded segments suitable for Claude Desktop ingestion:

```python
import os
import sys

def split_text_file(input_path, max_bytes=2 * 1024 * 1024):
    """Split large text files into 2MB chunks for reliable processing."""
    if not os.path.exists(input_path):
        print(f"File not found: {input_path}")
        return
    chunk_idx = 1
    current_bytes = 0
    current_lines = []
    base_name, ext = os.path.splitext(input_path)
    with open(input_path, "r", encoding="utf-8", errors="replace") as f:
        for line in f:
            line_bytes = len(line.encode("utf-8"))
            if current_bytes + line_bytes > max_bytes and current_lines:
                output_path = f"{base_name}_part{chunk_idx}{ext}"
                with open(output_path, "w", encoding="utf-8") as out:
                    out.writelines(current_lines)
                print(f"Created {output_path} ({current_bytes} bytes)")
                chunk_idx += 1
                current_lines = []
                current_bytes = 0
            current_lines.append(line)
            current_bytes += line_bytes
        if current_lines:
            output_path = f"{base_name}_part{chunk_idx}{ext}"
            with open(output_path, "w", encoding="utf-8") as out:
                out.writelines(current_lines)
            print(f"Created {output_path} ({current_bytes} bytes)")

if __name__ == "__main__":
    if len(sys.argv) > 1:
        split_text_file(sys.argv[1])
```

### 2. Pre-Filtering and Targeted Extraction
Passing an entire raw data dump into an AI model is inefficient. You can drastically reduce payload size by using standard shell utilities to extract relevant subsets before exposing the data to Claude Desktop:

```bash
grep -E "ERROR|CRITICAL|FATAL" production-api.log | tail -n 500 > error-window.log
jq '.users[] | {id: .id, role: .role, last_login: .last_login}' full-export.json > user-roles.json
```

### 3. Repository Hygiene for Filesystem MCP
If you use `@modelcontextprotocol/server-filesystem` to grant Claude Desktop access to local directories, restrict the server path to specific subfolders rather than pointing it at root project directories. Ensure build artifacts and dependencies are strictly excluded. Large directories like `node_modules`, `dist`, `.git`, `.venv`, and generated lockfiles (`package-lock.json`, `pnpm-lock.yaml`) contain thousands of files and millions of lines of machine-generated code that can trigger MCP discovery timeouts during startup.

### 4. Evaluating Local Vector Search vs. Cloud Workspace Storage
Some developers deploy local vector databases (such as Chroma, LanceDB, or SQLite-VSS) through custom local MCP servers to index large archives locally. While this approach keeps data on your local drive, it introduces substantial friction:

* Running local embedding models consumes system RAM and CPU cycles alongside Claude Desktop.
* Managing chunking strategies, vector re-indexing, and local SQLite databases requires continuous maintenance.
* Local vector databases remain locked to a single laptop, preventing teammates or automated agents from sharing the same indexed documents.
* Local MCP tool execution remains bounded by standard `stdio` buffer caps and 60-second execution timeouts.

## How to Connect Claude Desktop to Scalable Workspace Storage

The permanent solution for large archives is decoupling storage and retrieval from Claude Desktop's local process memory. Instead of attaching massive files to chats or forcing bloated payloads through local JSON-RPC pipes, files reside in persistent cloud workspaces where they are indexed on arrival. Claude Desktop then queries the workspace remotely, retrieving only the specific excerpts required to answer your prompt.

Fast.io provides an [intelligent workspace platform](/product/workspaces/) designed for human teams and AI agents. It leaves Claude's native upload limits untouched while providing a dedicated repository for files that do not fit into direct chats or local buffers. You can read more about connecting AI clients in the [Fast.io storage for agents guide](/storage-for-agents/).

### How Remote MCP Workspace Access Operates
When you upload documents to a Fast.io workspace, the platform's Intelligence Mode parses and indexes the contents across three dimensions: full-text lexical search, semantic vector embeddings, and structured metadata properties. Rather than sending entire files across the network, Claude Desktop interacts with the workspace via a remote Model Context Protocol (MCP) server running over Streamable HTTP at `https://mcp.fast.io/mcp/tools`.

When you submit a prompt regarding a 400-page contract, a massive software manual, or an archive of quarterly reports, Claude invokes the `storage` tool with the `search` action. The remote server executes hybrid search across the workspace and returns concise, relevant passages with source document citations. The active context window remains clean, local memory usage never spikes, and operations complete well within MCP timeout limits. Detailed technical setup instructions are available in the [Fast.io MCP setup documentation](https://mcp.fast.io/docs).

### Step-by-Step Setup in Claude Desktop
Connecting Claude Desktop to Fast.io requires no command-line scripts or configuration file editing:

1. Open Claude Desktop on your computer.
2. Select **Customize** from the user menu, then choose **Connectors**.
3. Select **Add custom connector**.
4. In the connector URL field, paste `https://mcp.fast.io/mcp/tools`.
5. Select **Connect**. A browser window opens prompting you to sign in to your Fast.io account and select which workspaces the connector can reach.
6. Return to Claude Desktop. In any conversation, open the **+** menu under Connectors and enable Fast.io.

### Multi-Cloud Synchronization and Scale
For organizations with data dispersed across legacy platforms, Cloud Sync connects Google Drive, Dropbox, Box and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. Files synced from these sources are automatically indexed by Intelligence Mode, making enterprise repositories instantly searchable by Claude Desktop without manual upload steps.

Workspace plans provide scalable capacity for engineering teams, as outlined on the [Fast.io pricing page](/pricing/):

| Plan | Monthly Price | Included Storage | Included Workspaces | AI Credits | Max Upload Size |
| :--- | :--- | :--- | :--- | :--- | :--- |
| Starter | $9.99/mo | 250 GB | 5 workspaces | 100,000 credits | 25 GB |
| Business | $49.99/mo | 5 TB | 50 workspaces | 600,000 credits | 50 GB |
| Enterprise | $199.99/mo | 25 TB | 200 workspaces | 3,000,000 credits | 100 GB |

Monthly plans start with a 14-day free trial that requires a credit card. Credits meter AI work only. Storage beyond the plan is $0.015 per GB a month and extra bandwidth $0.04 per GB, billed in money. Team members collaborate within org-owned workspaces featuring per-file version history, role-based access permissions at the organization, workspace, and share levels, and a detailed activity log recording uploads, edits, moves, deletions, membership and permission changes, and share creation.

## Frequently asked questions

### What is the maximum file size you can upload directly to Claude Desktop?

Anthropic documents that Claude chat uploads allow up to 20 files per conversation at 500MB each. In Claude Projects, Anthropic documents that Claude Project knowledge files are capped at 30MB per file with no fixed file count, provided the total content fits within Claude's context window. PDF documents are limited to 1,000 pages, with visual multimodal analysis supported for documents up to 100 pages.

### Why does Claude Desktop fail or time out when reading large local files through an MCP server?

Claude Desktop connects to local MCP servers over standard input and output streams using JSON-RPC. Reading raw files creates massive string serialization overhead and memory pressure inside Node.js child processes. The MCP TypeScript SDK enforces a 60-second default request timeout, terminating the call if parsing or reading takes too long. Returning raw megabyte-scale files directly into prompt context also exhausts the conversational context window.

### How do you give Claude Desktop access to files larger than 30MB or 500MB?

To query archives that exceed native upload limits, store documents in an external cloud workspace and connect Claude Desktop via a remote Model Context Protocol (MCP) server. Storing files in a Fast.io workspace with Intelligence Mode auto-indexes documents for hybrid semantic and keyword search. Claude queries relevant excerpts on demand over `https://mcp.fast.io/mcp/tools` rather than loading entire raw files into context.

### Does subscribing to Claude Pro or Team increase the 500MB per-file upload cap?

No. Anthropic documents that Claude chat uploads allow up to 500MB per file and Project files are capped at 30MB across Claude Free, Pro, Team, and Enterprise accounts. Upgraded tiers provide higher messaging frequency, access to frontier models, and larger context allowances, but individual file size ceilings are fixed across all subscription tiers.

### What document formats does Claude Desktop support for direct chat attachments?

Claude Desktop accepts PDF, DOCX, CSV, TXT, HTML, ODT, RTF, EPUB, JSON, and XLSX files, as well as JPEG, PNG, GIF, and WebP images. XLSX spreadsheets require enabling code execution and file creation in account settings. Non-PDF formats undergo text extraction only; embedded images and illustrations in DOCX or RTF files are not parsed.

### Can Claude Desktop search indexed cloud storage without attaching files to the chat?

Yes. By adding a remote MCP connector such as Fast.io at `https://mcp.fast.io/mcp/tools`, Claude Desktop interacts directly with workspace storage tools. Claude issues search queries against the indexed workspace and retrieves specific, citation-backed passages, keeping your conversational context lightweight while accessing gigabytes of background files.

## Sources

- [Claude Help Center: Upload files to Claude](https://support.claude.com/en/articles/8241126-upload-files-to-claude): Anthropic documents that Claude chat uploads allow up to 20 files per conversation at 500MB each, while Project knowledge files are capped at 30MB per file within the context window, and PDF documents are limited to 1,000 pages with visual analysis on 100 pages.
- [Claude Help Center: Retrieval augmented generation (RAG) for projects](https://support.claude.com/en/articles/11473015-retrieval-augmented-generation-rag-for-projects): When Claude Project knowledge approaches context window limits, Claude enables RAG mode to expand capacity by up to 10x.

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