# Box File Size Limit: Upload Caps by Plan and Large-Corpus AI Search

Box documents an individual file upload limit across account plans, ranging from 250 MB on free accounts to 5 GB on Business, 50 GB on Enterprise, and up to 150 GB on Enterprise Plus. While higher tiers support large assets, browser drops, folder ownership inheritance, and API chunking complicate bulk transfers. Connecting Box to AI assistants requires offloading data to indexed workspaces instead of attaching files to context windows.

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

## How Does the Box File Size Limit Work Across Account Tiers?

Box documents an individual file upload limit across account plans, shared folders, and enterprise repositories, ranging from 250 MB for free Individual accounts to 5 GB for Personal Pro, 15 GB for Business Plus, 50 GB for Enterprise, and up to 150 GB for Enterprise Plus. On Enterprise Advanced tiers, Box documents an individual file upload limit up to 500 GB across enterprise repositories. While these upper boundaries accommodate high-resolution video masters, virtual machine disk images, and massive database dumps, treating file limits as an unconditional allowance creates immediate operational friction. The file upload limit dictates the maximum size of any single asset, but completing an upload depends on the subscription plan of the folder owner, total account storage allowances, and the specific client or API protocol handling the payload.

A common point of operational confusion is the difference between per-file upload caps and overall account capacity. Box specifies distinct individual file limits for each tier, alongside varying storage allowances across consumer, business, and enterprise subscriptions:

- Box Free Personal: Individual consumer accounts include a strict 250 MB individual file upload limit across Box personal folders, alongside 10 GB of total account storage. If an asset exceeds the 250 MB individual file upload limit across account plans by even a few kilobytes, the transfer fails immediately.
- Box Starter: Commercial starter packages provide a 2 GB individual file upload limit across account plans with 100 GB of pooled organizational storage, supporting teams between 3 and 10 members.
- Box Personal Pro: Paid single-user account plans raise the individual file upload limit to 5 GB, supported by 100 GB of total account storage space.
- Box Business: Standard commercial account plans support an individual file upload limit up to 5 GB with unmetered organizational capacity, requiring a 3-user minimum.
- Box Business Plus: Intermediate commercial account plans expand the individual file upload limit to 15 GB with unmetered organizational capacity and expanded administrative reporting.
- Box Enterprise: Standard enterprise accounts provide a 50 GB individual file upload limit across account plans, unmetered storage, and content governance controls.
- Box Enterprise Plus: High-tier deployments expand the individual file upload limit to 150 GB across enterprise repositories with unmetered storage.
- Box Enterprise Advanced: Specialized high-capacity enterprise repositories support an individual file upload limit up to 500 GB for petabyte-scale data ingestion and large system archives.

The following comparison details how individual file caps and overall storage allowances align across Box subscription tiers:

| Box Account Plan | Maximum Individual File Size | Default Account Storage Quota | Primary Limitation Factor | Date Checked |
| :--- | :--- | :--- | :--- | :--- |
| Free Personal | 250 MB | 10 GB | Strict per-file ceiling and 10 GB account cap | 2026-10-14 |
| Starter | 2 GB | 100 GB | Low per-file cap for small teams | 2026-10-14 |
| Personal Pro | 5 GB | 100 GB | Account storage boundary for individual users | 2026-10-14 |
| Business | 5 GB | Unmetered | Baseline commercial upload limit | 2026-10-14 |
| Business Plus | 15 GB | Unmetered | Mid-tier commercial ceiling | 2026-10-14 |
| Enterprise | 50 GB | Unmetered | Advanced administrative tier cap | 2026-10-14 |
| Enterprise Plus | 150 GB | Unmetered | High-capacity data tier cap | 2026-10-14 |
| Enterprise Advanced | 500 GB | Unmetered | Maximum infrastructure upload ceiling | 2026-10-14 |

### The Shared Folder Ownership Rule

In collaborative environments, teams frequently encounter unexpected upload rejections caused by folder hierarchy permissions. Box enforces upload ceilings based on the subscription tier of the folder owner, rather than the account tier of the user performing the upload.

For example, consider an engineering lead on an Enterprise account plan who attempts an individual file upload into shared folders owned by an external contractor on a Free Personal account. Box rejects the transfer immediately. Because the root directory belongs to a free account, the workspace enforces the 250 MB individual file upload limit across shared folders. Conversely, when an external contractor on a free account uploads raw footage into a shared directory owned by an Enterprise account, the contractor can complete an individual file upload across shared folders up to the owner's 50 GB or 150 GB ceiling, provided the owner account holds sufficient storage.

### Application-Specific Upload Caps

Certain client applications and ingestion mechanisms enforce fixed ceilings that operate below the account plan maximum:

- Box Mobile: Mobile applications on iOS and Android enforce a 15 GB individual file upload limit across mobile apps regardless of whether the organization subscribes to an Enterprise Plus tier.
- Box Sync: The legacy Box Sync desktop client enforces a hardcoded 15 GB individual file upload limit across local folders. The newer Box Drive application supports transfers up to the account plan ceiling, but legacy deployments running Box Sync enforce an individual file upload limit error across local folders above 15 GB.
- Email Uploads: When users upload files by forwarding email attachments to a folder's unique upload email address, Box enforces an individual file upload limit of 50 MB per attached asset.

To inspect the active upload ceiling on an account, select your profile icon in the upper-right corner of the Box web application, choose Account Settings, and locate the Max file size row under Account details.

## Why Large Box Uploads Encounter API Chunking and Browser Failures

Although enterprise Box plans support individual assets reaching 50 GB, 150 GB, or 500 GB, moving multi-gigabyte files across standard web browsers or automation scripts exposes several technical bottlenecks. Understanding these constraints helps engineering teams avoid broken transfers and corrupted archives.

### 1. Browser Connection Terminations and Lack of Byte Resumption

Web browser interfaces rely on standard HTTP multipart POST transactions. Because web browsers run within sandboxed client processes without low-level operating system socket controls, extended transfers remain susceptible to routine network interruptions:

- TCP Reset Failures: When a user switches networks, traverses a VPN gateway, or encounters transient packet loss, the active TCP socket terminates. Standard browser uploads lack block-level checkpointing to query the remote server for received byte offsets. The connection aborts, and the user must retransmit the asset from byte zero.
- Gateway Timeout Thresholds: Corporate proxies, firewalls, and cloud load balancers enforce strict connection timeouts, often terminating persistent HTTP streams that run longer than ten to fifteen minutes. An individual file upload moving across an intermediate proxy often drops midway through transmission when sending multi-gigabyte video reels.
- Inactive Tab Resource Throttling: Contemporary browsers conserve memory by throttling background tabs. If an employee navigates to another browser tab while a large upload runs, the browser suspends the script's timers, causing the remote storage server to time out the idle session.

### 2. Box REST API Chunking Architecture for Payloads Over 50 MB

For developers building ingestion pipelines or agent tools, Box establishes a strict operational threshold on its Content API. For direct single-request operations to developer endpoints, Box documents an individual file upload limit of 50 MB.

When an individual file upload to Box folders exceeds 50 MB, Box requires developers to initialize chunked upload sessions. Transmitting an individual file upload to Box folders larger than 50 MB through developer endpoints triggers an immediate HTTP 400 Bad Request or HTTP 413 Request Entity Too Large failure.

The Box Chunked Upload API uses a structured three-phase transaction model:

1. Session Creation: The client dispatches a POST request to https://upload.box.com/api/2.0/files/upload_sessions, supplying the target folder_id, file_name, and total file_size. Box verifies permissions and returns an upload session record with an allocated chunk size (standardized at 8 MB or 16 MB) for the individual file upload limit across target folders.
2. Part Transmission: The client divides the source file into byte slices matching the allocated chunk size. Each slice is dispatched via a PUT request to the session endpoint with a `Content-Range` header (such as `bytes 0-8388607/104857600`) and a SHA-1 `Digest` header. Parts can transmit sequentially or across concurrent threads.
3. Session Assembly: Once all slices upload successfully, the client issues a POST request to the commit endpoint, submitting an ordered manifest of part IDs and checksum digests. Box concatenates the chunks on its storage cluster, validates the global file hash, and registers the file object.

While upload sessions permit retry logic for failed chunks, orchestrating this flow inside custom automation scripts introduces significant engineering overhead, including state tracking, thread pooling, and hash computation.

### 3. Filesystem Path and Character Restrictions

Automated ingestion routines must also respect Box naming conventions:

- Path and Name Length: Individual file and folder names cannot exceed 255 characters.
- Disallowed Characters: Box rejects filenames containing forward slashes (`/`), backslashes (`\`), non-printable ASCII characters, or leading and trailing whitespace.
- Folder Item Density: Although tenant quotas support vast file counts, storing more than twenty thousand files in a single flat directory slows down web UI rendering and introduces API pagination latency.

## The Context Window Dilemma: Why AI Assistants Cannot Ingest Massive Box Repositories

Enterprises maintain extensive institutional knowledge within Box accounts: clinical trial records, commercial lease agreements, corporate merger dossiers, software specifications, and customer intelligence archives. These collections regularly span hundreds of gigabytes across thousands of multi-page documents.

As organizations adopt advanced AI systems such as Claude to examine enterprise assets, teams face immediate physical barriers when attempting to feed raw Box folders directly into chat prompts or project workspaces.

Anthropic establishes clear structural parameters for document ingestion:

- Standard Conversations: In direct chat sessions, Claude accepts up to 20 files per chat, with an individual file size limit of 500 MB.
- Claude Projects: Anthropic caps Claude Project files at 30 MB each with total project content 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, and reaching it is when people with a large corpus look for another path.

Attempting to attach a multi-gigabyte Box archive directly into an LLM context window creates severe operational bottlenecks:

- Prompt Capacity Exhaustion: A corporate document library containing hundreds of policy guides or case files represents tens of millions of text tokens. Even modern large context windows cannot ingest a comprehensive document repository in a single prompt without dropping content.
- Computational Latency and Expense: Resending hundreds of thousands of background tokens with every conversational turn introduces high inference latency and multiplies API token expenditure.
- Context Degradation and Hallucination: Language models experience noticeable degradation in recall when processing vast unindexed prompts. Critical facts, contractual exceptions, or numeric figures positioned deep within multi-hundred-page files are frequently overlooked.

The sustainable architectural pattern requires decoupling storage from inference: preserve the master repository in an indexed cloud workspace, and equip the AI assistant with Model Context Protocol (MCP) search tools to inspect relevant document fragments dynamically on demand.

## Connecting Box Repositories to Fast.io for Assistant Querying via MCP

To make enterprise Box collections accessible to AI assistants without saturating prompt limits or rebuilding ingestion pipelines, organizations connect their storage infrastructure to Fast.io. Fast.io provides intelligent workspaces built specifically for human and agentic workflows.

### 1. Ingest Box Repositories via Cloud Sync

Instead of downloading terabytes of files to local workstations and manually uploading them to new destinations, teams establish direct cloud connectivity. 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 syncing a Box directory to a Fast.io workspace, data streams directly across cloud infrastructure without consuming local network bandwidth or desktop storage. For direct uploads outside of sync connections, Fast.io supports direct chunked uploads through its browser interface and public REST API (located at https://api.fast.io/current/), handling large individual assets without browser tab crashes.

### 2. Automatic Parsing and Hybrid Search with Intelligence Mode

When files arrive in a Fast.io workspace, enabling Intelligence Mode activates native content indexing:

- Broad Format Parsing: The system extracts plain text and tabular data from PDFs, Word documents, spreadsheets, presentations, markdown notes, and scanned records.
- Hybrid Retrieval Architecture: Fast.io combines full-text lexical search with semantic vector embeddings. AI assistants and team members can query documents using exact technical terms or broad conceptual questions.
- Built-In Vector Management: Retrieval indexing runs natively within the workspace substrate, eliminating the need to provision, configure, and maintain external vector databases like Pinecone or Qdrant.

### 3. Structured Data Extraction via Metadata Views

When teams need structured insight from contracts, invoices, financial disclosures, or equipment logs, [Metadata Views](/product/document-data-extraction/) converts unstructured file collections into queryable database tables.

Users define target extraction fields using natural language instructions. Fast.io automatically generates a typed schema (including Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time formats), scans workspace documents, and populates a filterable spreadsheet view. The extraction operates across PDFs, scanned sheets, and office documents without rigid OCR templates or manual data entry.

### 4. Connect Claude and Autonomous Agents via Remote MCP

Rather than uploading raw files to chat windows, Claude connects to Fast.io using the Model Context Protocol over Streamable HTTP:

- For Claude (Web, Desktop, and Mobile): Open Customize, then Connectors. Add a custom connector and enter `https://mcp.fast.io/mcp/tools`. Select Connect and complete OAuth sign-in to Fastio in the browser window that opens. During sign-in, choose whether the connection receives Read Only or Read & Write permissions, and designate the specific organizations and workspaces it can access. In any conversation, enable Fastio from the + menu under Connectors.
- For Coding Agents (Claude Code, Cursor, Gemini CLI): Configure the coding agent endpoint at `https://mcp.fast.io/mcp/code`. In Claude Code, run:

```bash
claude mcp add --transport http fast-io https://mcp.fast.io/mcp/code
```

Then run `/mcp` inside Claude Code to authenticate. Complete technical guidance is documented at `https://mcp.fast.io/docs`.

Once connected, Claude queries the workspace via MCP search actions, retrieves exact text excerpts, and answers queries with verified document citations while consuming only a few hundred prompt tokens.

## Architectural Patterns for Managing Large Files in Agentic Workspaces

Operating multi-gigabyte document collections alongside autonomous agents requires clear organizational boundaries. Applying modern workspace patterns prevents data collisions and maintains clear governance across human and machine workflows.

### 1. Structure Granular Workspaces Instead of Monolithic Directories

Avoid consolidating diverse enterprise functions into a single shared folder tree. In Fast.io, permissions are managed per organization, workspace, and share through member roles. There are no folder-level or file-level permissions; every workspace member accesses all files within that workspace according to their assigned role. Separating business divisions, legal matters, and project initiatives into dedicated workspaces prevents unauthorized data exposure and keeps agent tool contexts focused.

### 2. Coordinate Multi-Agent Collaboration with Versioning and Advisory Leases

When multiple human editors and software agents operate in a shared environment, write management prevents corruption:

- Full Version History: Every file in Fast.io maintains complete version history. If an automated script overwrites a document or a user rolls back an edit, prior revisions remain accessible, preventing irreversible data loss.
- Advisory File Locks: Autonomous agents executing automated tasks can acquire advisory leases through the Fast.io MCP server. Using `lock-acquire` and `lock-release` on the `storage_manage` tool, and `lock-status` on the `storage` tool, an agent signals to other collaborators that an asset is undergoing updates. The lock never blocks concurrent writes, but alerts other agents to prevent race conditions.
- Detailed Activity Log: A detailed activity log tracks modifications across the organization, including uploads, edits, file moves, deletions, role updates, and share creations. The log captures events executed by humans and AI agents. It does not record read-only events such as views or downloads.

### 3. Deliver Finished Assets Securely via Branded Shares

To distribute large assets to external stakeholders or ingest records without hitting file attachment caps:

- Branded Shares: Create branded [file shares](/product/sharing/) using Send, Receive, or Exchange configurations.
- Granular Security Controls: Configure durable or expiring share links with per-recipient access controls and optional download disabling. External partners can review and stream high-resolution media via HLS video streaming without creating an account.
- Cloud-to-Cloud Ingestion: Use Receive links to collect multi-gigabyte deliverables directly from external partners into your workspace, bypassing email size barriers.

### 4. Transparent Subscription Plans and Sizing

Monthly plans start with a 14-day free trial that requires a credit card; annual plans have no trial. Fast.io offers three subscription plans detailed on the [pricing page](/pricing/):

| Fast.io Plan | Monthly Billing | Annual Billing | Included Storage | Included Seats | Monthly Credits | Maximum Upload |
| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
| Starter | $9.99/mo | $99/yr | 250 GB | 3 seats | 100,000 | 25 GB |
| Business | $49.99/mo | $499/yr | 5 TB | 10 seats | 600,000 | 50 GB |
| Enterprise | $199.99/mo | $1,999/yr | 25 TB | 30 seats (up to 200) | 3,000,000 | 100 GB |

When organizational requirements exceed baseline plan allocations, capacity expands through transparent rates:

| Expansion Type | Rate | Billing Terms |
| :--- | :--- | :--- |
| Extra Storage | $0.015 per GB per month | Billed in currency |
| Extra Bandwidth | $0.04 per GB | Billed in currency |
| Extra AI Credits | $10 per 100,000 credits | Metered AI operations |

## Frequently asked questions

### What is the maximum file size you can upload to Box?

Box documents an individual file upload limit based on account tier, ranging from 250 MB on Free Personal accounts to 5 GB on Business, 15 GB on Business Plus, 50 GB on Enterprise, 150 GB on Enterprise Plus, and 500 GB on Enterprise Advanced. Transfers must also fit within available account storage allowances.

### What is the file size limit for Box free account?

Free personal Box accounts have a strict 250 MB individual file upload limit across personal folders, with 10 GB of total storage. Assets exceeding the 250 MB individual file upload limit across shared folders cannot be uploaded to a free account unless the destination directory belongs to an Enterprise subscription.

### Can I complete a 20 GB individual file upload to Box folders?

Yes, you can complete a 20 GB individual file upload to Box folders if your organization subscribes to an Enterprise, Enterprise Plus, or Enterprise Advanced plan, which support 50 GB, 150 GB, and 500 GB thresholds respectively. Standard Business plans enforce a 5 GB or 15 GB individual file upload limit across account plans.

### How do I increase my Box file size limit?

To increase your Box file size limit, upgrade your subscription plan in Account Settings or contact Box sales. Upgrading from Business (5 GB) to Business Plus (15 GB) or Enterprise tiers (50 GB to 150 GB) immediately raises the per-file ceiling across all folders owned by your account.

### How does shared folder ownership affect the Box file size limit?

In Box, file limits in shared folders are determined exclusively by the folder owner's subscription tier. If a collaborator on an Enterprise plan uploads into a directory owned by a free account holder, the transfer enforces the 250 MB individual file upload limit across shared folders. If a free user uploads into an Enterprise-owned directory, they receive the owner's higher limit.

### Why does an individual file upload to Box folders fail over 50 MB in API calls?

The Box Content API requires developers to use chunked sessions whenever an individual file upload to Box folders exceeds 50 MB. Direct POST requests to developer endpoints reject any individual file upload across shared folders exceeding 50 MB. Payload transfers over 50 MB require developers to dispatch chunked upload sessions across target folders.

### Why does Claude fail when uploading a large Box repository?

Anthropic caps Claude Project files at 30 MB each with total project content bounded by the context window. When users attempt to upload multi-gigabyte Box repositories, the volume of text saturates Claude's prompt capacity, causing high latency, token exhaustion, or upload rejections.

### How does Fast.io Cloud Sync connect Box to Claude without context window limits?

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 Intelligence Mode is enabled, files are indexed for hybrid search. Claude connects via MCP at `https://mcp.fast.io/mcp/tools` and searches the indexed workspace dynamically, retrieving only relevant passages with citations without overloading its context window.

## Sources

- [Box Support: Understand the Maximum File Size You Can Upload to Box](https://support.box.com/hc/en-us/articles/360043697314-Understand-the-Maximum-File-Size-You-Can-Upload-to-Box): Box documents an individual file upload limit across account plans, shared folders, mobile apps, and developer API sessions.
- [Claude Help Center: Upload files to Claude](https://support.claude.com/en/articles/8241126-upload-files-to-claude): Anthropic caps Claude Project files at 30 MB each with total project content 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.