# How to Upload a Folder to Claude: Multi-File Projects, ZIPs, and MCP Workspaces

Claude does not provide a native folder upload button, but users can attach compressed ZIP archives to chats, drag multi-selected files into Claude Projects Knowledge, or query full directory trees through an MCP server. While chats accept up to 20 files at 500MB each, Claude Projects accepts files up to 30MB with unlimited file count bounded by context window capacity. External MCP workspaces allow Claude to search indexed files on demand.

Source: https://fast.io/resources/upload-folder-to-claude/
Author: [Tom Langridge](https://fast.io/authors/tom-langridge/)
Last reviewed: 2026-11-05

## What Documented Limits Apply to Claude File and Folder Uploads

Anthropic documents explicit upload boundaries on its official support page: standard chat conversations accept up to 20 files at up to 500MB each, while Claude Projects accepts individual files up to 30MB each with no fixed file-count cap, limited only by the model context window. When users drag an uncompressed folder from their desktop into the chat prompt, the browser file picker rejects the directory.

Claude does not offer a native folder upload button, but users can attach compressed ZIP archives to individual chats, drag multi-selected files into Claude Projects Knowledge, or query full directory trees via an MCP server.

Understanding how Claude handles bulk content requires distinguishing between ephemeral chat messages and persistent project environments. In a standard chat, every attached file is uploaded for that single session. Individual chats accept common formats such as PDF, TXT, CSV, DOCX, and code files up to 500MB per file, but you cannot drag a raw folder into the attachment dialog. 

In Claude Projects, files are stored inside Project Knowledge, making them available across every conversation within that project. Many competing online guides state that Claude Projects limits users to 5 or 10 files. That claim is incorrect. Anthropic verified that file count in Claude Projects is unlimited, provided the cumulative text fits within Claude's context window. However, the maximum individual file size drops from 500MB down to 30MB in Projects, and text extraction is applied to every document except multimodal PDFs.

| Claude Interface | Max File Size | File Count Limit | Directory/Folder Ingestion | Primary Constraint | Source and Verification Date |
|---|---|---|---|---|---|
| Standard Chat | 500MB per file | 20 files per chat | Rejected (flat files or ZIP only) | Message context and attachment count | Anthropic Support (checked 2026-09-14) |
| Claude Projects | 30MB per file | Unlimited file count | Flat file drag-and-drop into Knowledge | Context window capacity | Anthropic Support (checked 2026-09-14) |
| Claude Code CLI | API token budget | Unlimited local files | Native directory traversal via terminal | Model token budget and rate limits | Anthropic CLI Docs (checked 2026-11-05) |
| Remote MCP Workspaces | 25 GB Starter, 50 GB Business, 100 GB Enterprise | Unlimited directory trees | Full remote folder hierarchies | On-demand search retrieval | Fastio Documentation (checked 2026-11-05) |

### Why the Browser File Picker Rejects Folders

The web client at claude.ai uses standard HTML file input elements without directory selection enabled. When an operating system drag event drops a directory entry onto the drop target, the browser identifies the payload as a directory object rather than a regular file stream. Because the browser input does not implement recursive directory parsing, it rejects the dropped folder with an invalid format notice or fails silently.

To pass folder contents to Claude through the web browser, you must unpack the folder locally and select the contained files, pack the directory into an accepted archive or structured text file, or expose the folder through an external server protocol.

## How to Upload Folder Contents Using Projects, ZIP Bundles, and MCP

Working with multi-file folders in Claude requires choosing the right ingestion pathway for your workload. Depending on whether you need persistent team reference, quick one-off analysis, or interactive access to a large directory, three proven methods bypass the absence of a native folder upload button.

Each method addresses a different operating scenario. Project Knowledge suits reference documentation and small code collections that you consult across multiple conversations. Bundling scripts and compressed archives suit quick single-turn reviews where you need Claude to analyze an entire module at once. Remote workspaces connected through the Model Context Protocol suit large repositories, media libraries, and active team files where context bloat must be avoided entirely. Evaluating these three paths allows teams to work with multi-file directory structures without breaking interface limits or wasting manual effort on repetitive file selection.

### Method 1: Multi-Selecting Files into Claude Projects Knowledge

Claude Projects provides the closest native experience to a persistent folder. Available on paid Pro, Team, and Enterprise plans, Projects allows you to group instructions and knowledge files into a reusable workspace.

Follow these steps to ingest a complete directory into Project Knowledge:

1. Open your project in Claude and locate the Project Knowledge sidebar on the right side of the screen.
2. Open your local operating system file explorer (Finder on macOS or File Explorer on Windows) and open the target directory.
3. Select all files inside the folder using Cmd+A on Mac or Ctrl+A on Windows. If your folder contains nested subdirectories, use your file manager's search filter to list all contained files in a flat view.
4. Drag the selected files directly into the Project Knowledge panel.
5. Wait for Claude to complete text extraction for each file.

Every individual file uploaded into Claude Projects must remain under the 30MB per-file ceiling. Once processed, these documents form the background context for all chats started within that project.

### Method 2: Bundling Directories and Codebases for Single Chats

When you need to analyze a directory in a standard chat without creating a dedicated project, bundling the directory into a single file or archive is the most effective approach.

Individual chats accept up to 20 files per chat at 500MB per file. You can prepare directories for chat ingestion using two techniques:

First, code bundling tools like Repomix or custom terminal scripts combine a directory tree into a single structured markdown or XML document. The script walks your directory, outputs an ASCII representation of the folder hierarchy, and wraps the content of each file inside tagged code blocks. This preserves the relative paths of files like `src/components/Button.tsx` and `src/utils/format.ts` that Claude would otherwise lose.

Second, compressing a folder into a ZIP archive allows you to upload the bundle directly. When paired with Claude's built-in analysis tools, Claude can inspect the contents of the archive, extract specific text components, and process multi-file scripts. Keep archives clean by stripping binary assets, compiled artifacts, and lockfiles before uploading.

### Method 3: Connecting Deep Directory Trees Over MCP

For large folders, monorepos, and document libraries that exceed context limits, pushing raw files into chat inputs creates severe operational friction. The Model Context Protocol (MCP) establishes a live connection between Claude and external storage environments.

Instead of pasting files into the browser, you connect Claude to a remote MCP server. Claude then acts as an active agent: it reads folder listings, searches file contents, and retrieves specific sections when answering your questions.

This architecture decouples storage from conversational context. Your files remain organized in their original folder structure in the cloud, while Claude retrieves only the specific files or paragraphs relevant to the current prompt.

## Why Claude Projects Hit Context Limits with Large Folders

While Claude Projects accepts an unlimited number of files, every file in Project Knowledge consumes valuable context window tokens. In modern foundation models like Claude 3.7 Sonnet and Claude 3.5 Sonnet, the context window spans 200,000 tokens. While 200,000 tokens accommodates substantial reference material, it is not an infinite archive.

Project Knowledge does not function as an isolated, selective database by default. When you upload files into Project Knowledge, Claude loads that reference material into the system context for conversations in that project. If your uploaded folder contains 80 documents averaging 2,000 tokens each, the knowledge base consumes 160,000 tokens before you type a single prompt.

This structural overhead creates three immediate challenges:

1. Token Exhaustion: With 160,000 tokens consumed by background files, only 40,000 tokens remain for user prompts, tool calls, and model responses. Multi-turn conversations quickly hit the context ceiling.
2. Attention Dilution: Language models exhibit reduced recall precision across vast context spans. Spreading attention across hundreds of background pages degrades the model's ability to extract fine-grained details.
3. Cost and Latency: Sending massive prompt contexts on every conversational turn increases response latency and accelerates API credit consumption.

Anthropic sets the individual file limit in Projects to 30MB specifically because documents beyond that threshold typically contain dense binary structures or extensive token volumes that overwhelm conversational reasoning.

### Decoupling Folder Storage from Prompt Context with Fastio Workspaces

Engineering teams and knowledge workers solve context exhaustion by decoupling storage from prompt injection. Instead of dragging massive folders into Project Knowledge, teams store directories in intelligent cloud workspaces on Fastio.

In [intelligent workspaces](/product/workspaces/) on Fastio, files are indexed automatically for hybrid search across full-text, semantic meaning, and document metadata. Claude connects to the workspace using the Model Context Protocol, querying indexed folders only when an answer requires specific context. You can explore how [persistent storage for AI agents](/storage-for-agents/) changes context economics.

Cloud Sync connects Google Drive, Dropbox, Box, and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. This allows organizations to sync hundreds of folders containing thousands of documents without uploading files manually.

Connecting Claude to a Fastio workspace requires no local scripting:

1. In Claude (web, desktop, or mobile), open Customize, then select Connectors.
2. Add a custom connector and paste `https://mcp.fast.io/mcp/tools` as the endpoint.
3. Select Connect and sign in to Fastio in the browser window that opens. Fastio displays a Review Permissions screen where you choose your organization and workspace access.
4. In any chat conversation, turn Fastio on from the + menu under Connectors.

Once connected, Claude uses a consolidated MCP toolset to inspect directories, search file contents, and retrieve exact excerpts. Rather than burning 150,000 tokens by attaching an entire folder, Claude retrieves only the two relevant paragraphs needed to answer your question, consuming 400 tokens.

Fastio provides organization-owned workspaces with per-file version history, a detailed activity log of changes, and role-based permissions set per organization, workspace, and share. Monthly plans start with a 14-day free trial that requires a credit card. Review options on the [Fastio pricing](/pricing/) page:

| Plan | Monthly Price | Included Storage | Included Seats | Monthly AI Credits |
|---|---|---|---|---|
| Starter | $9.99/mo | 250 GB | 3 seats | 100,000 credits |
| Business | $49.99/mo | 5 TB | 10 seats | 600,000 credits |
| Enterprise | $199.99/mo | 25 TB | 30 seats | 3,000,000 credits |

## How to Structure Nested Codebase Directories for Claude

Uploading software codebases presents unique structural hurdles. Codebases rely heavily on nested directory trees, relative import paths, and module hierarchies that flat file uploads easily disrupt. When you drag and drop files from multiple directories into Claude, the application receives the file blobs but often drops the relative path prefixes unless you establish explicit conventions.

Applying disciplined file preparation preserves codebase integrity and keeps Claude focused on actionable logic. Without careful pruning and path retention, models can hallucinate incorrect import locations or confuse identically named files across different microservices. Taking a few deliberate steps before uploading code directories prevents hours of debugging and gives Claude a clear understanding of the architecture of your software from the first turn.

### Preserving Directory Structure in Claude Projects

When you multi-select files across nested folders and drop them into Claude Projects, the interface flattens the file list. Files located at `src/api/auth.ts` and `src/models/auth.ts` both appear as `auth.ts` in the UI list, potentially confusing the model during code synthesis.

To retain directory context:

- Include relative paths as top-level file comments: Add a comment to the first line of each source file showing its repository path, such as `// filepath: src/api/auth.ts`.
- Provide an architectural manifest: Create a standalone `DIRECTORY_TREE.md` file in the root of your project using the terminal `tree` command (`tree -I 'node_modules|dist|.git' > DIRECTORY_TREE.md`) and upload it to Project Knowledge. This gives Claude a comprehensive roadmap of module relationships.
- Use structured bundlers: Tools that format files with clear file path headers allow Claude to reference imports and exports accurately across deep directory trees.

### Filtering Dependencies and Build Artifacts Before Ingestion

The most common mistake when uploading a development folder is including package managers, build outputs, and cache directories. A single `node_modules` folder or Python virtual environment can contain tens of thousands of files and millions of tokens, instantly breaking upload tools and exhausting context windows.

Always strip the following elements before uploading or bundling directories:

- Package managers and libraries: `node_modules/`, `venv/`, `.venv/`, `vendor/`, and `packages/`.
- Build and compilation outputs: `dist/`, `build/`, `out/`, `target/`, and `.next/`.
- Version control metadata: `.git/`, `.svn/`, and `.hg/`.
- Lockfiles and binaries: `package-lock.json`, `pnpm-lock.yaml`, `Cargo.lock`, compiled binaries, and database SQLite dumps.

Excluding these directories strips unnecessary bulk from the repository, leaving a clean collection of source code and documentation that fits comfortably within Claude's ingestion thresholds.

## How to Resolve Common Folder Upload Errors in Claude

When uploading collections of files to Claude, users frequently run into specific system boundaries and interface errors. Identifying the root cause allows you to resolve the failure quickly without abandoning your multi-file workflow.

Most upload errors in Claude stem from three underlying causes: exceeding per-file size thresholds, exceeding the attachment count ceiling in standard chats, or attempting to drag unsupported file types and directories into the browser window. Understanding how Claude's ingestion pipeline validates incoming files helps you apply the right fix, whether that means breaking down a massive PDF document, pruning an archive, or routing your documents through an external storage connector.

### Fixing the Uploaded File Is Too Large Error

Anthropic displays the "Uploaded file is too large" error when an individual file exceeds the platform threshold for the current interface.

In standard chat, individual files cannot exceed 500MB per file. In Claude Projects, the threshold drops to 30MB per file for individual project files. PDFs are strictly limited to 1,000 pages. Claude processes text and visual elements (such as charts and graphics) in PDFs of 100 pages or fewer; for PDFs between 101 and 1,000 pages, Claude extracts text only. Uploading a PDF with 1,001 pages triggers an immediate file size error.

To resolve this issue, split oversized documents into smaller sections, compress large images, or remove embedded video and media assets before uploading.

### Resolving Browser Freezes and Dropped Connections

Selecting and dragging dozens of files simultaneously into a browser window can cause memory spikes and browser tab crashes. The browser client must calculate checksums and initiate parallel uploads for every file in the batch.

If your browser tab freezes or drops uploads:

- Batch your uploads into groups of 20 to 30 files at a time.
- Verify that your files use supported extensions. Claude supports PDF, DOCX, CSV, TXT, HTML, ODT, RTF, EPUB, JSON, XLSX, and standard image formats (JPEG, PNG, GIF, WebP).
- For large media or extensive research sets, shift ingestion to a remote MCP workspace rather than relying on browser uploads.

## Frequently asked questions

### Can I upload a folder to Claude?

Claude does not have a native folder upload button in its web interface. Dragging an uncompressed directory directly into the chat box is rejected by the browser file picker. You can work around this by multi-selecting individual files inside the folder, compressing the directory into a ZIP archive, bundling files into a single text document, or connecting a remote workspace using the Model Context Protocol.

### How do I add multiple folders to Claude Projects?

To add multiple folders to Claude Projects, open your operating system file manager and open the target folders. Select the files inside each folder and drag them into the Project Knowledge section on the right side of the project interface. Claude Projects accepts an unlimited number of individual files up to 30MB each, provided the total content fits within Claude's 200,000-token context window.

### What is the best way to share a codebase directory with Claude?

The best approach depends on project size. For small codebases, bundling source files into a single markdown file using a tool like Repomix preserves relative directory paths. For medium codebases, dragging filtered source files (excluding node_modules and build artifacts) into Claude Projects Knowledge provides persistent access. For large codebases and monorepos, connecting an MCP server allows Claude to browse and search the repository structure on demand without token bloat.

### What is the maximum file size for uploads in Claude?

Upload size limits depend on the interface. Standard chat conversations accept files up to 500MB each, with a maximum of 20 files per chat. Claude Projects enforces an individual file size limit of 30MB per document, with an unlimited total file count bounded only by context window capacity. PDFs across all interfaces cannot exceed 1,000 pages.

### Does Claude maintain nested folder structures in Project Knowledge?

Claude Projects flattens directory structures upon upload, displaying all uploaded documents in a flat file list. To help Claude understand folder relationships, add a relative path comment at the top of each file (such as // filepath: src/utils/auth.ts) or upload an ASCII directory tree generated by the terminal tree command.

## Sources

- [Anthropic: Upload files to Claude](https://support.claude.com/en/articles/8241126-upload-files-to-claude): Claude Projects allows an unlimited number of individual files with a 30MB per-file limit per project, bounded by context window capacity.
- [Anthropic: Upload files to Claude](https://support.claude.com/en/articles/8241126-upload-files-to-claude): Standard Claude chat conversations accept up to 20 files per chat at 500MB per file for individual chats.

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