SharePoint File Size Limit: Upload Limits, Sync Constraints, and Best Practices

As of September 2026, Microsoft documents an official 250 GB individual upload limit for SharePoint Online and Microsoft 365, yet teams routinely encounter upload failures on files that measure only a fraction of that capacity. The SharePoint file size limit is the maximum individual file size supported in SharePoint Online and Microsoft 365 libraries, officially set at 250 GB. While this ceiling represents a major technical upgrade from legacy thresholds, treating it as an unconditional allowance causes operational friction.

In practice, the 250 GB ceiling is bounded by client software, protocol restrictions, and library structures:

• Browser upload limits: Standard web browsers drop unchunked HTTP sessions, causing large multi-gigabyte transfers to fail frequently on standard office connections.
• Sync app constraints: The OneDrive sync client struggles with high processor load and database lockups when tracking repositories that hold hundreds of thousands of files and folders.
• File path length limits: The complete decoded URL path from the tenant domain to the final file extension cannot exceed 400 characters.
• List attachment caps: Individual files attached to SharePoint list items remain restricted to modest database limits.

The 250 GB ceiling applies across SharePoint document libraries, Microsoft Teams files tabs, OneDrive for Business personal stores, and Viva Engage attachments. Every one of these endpoints rests on the identical SharePoint Online storage substrate as detailed in the official SharePoint limits documentation. However, the channel you select to transfer the asset determines whether your transfer succeeds or terminates midway.

Understanding how Microsoft measures these limits is important for storage planning. SharePoint calculates storage allocations in binary gigabytes (where one gigabyte equals 2^30 bytes). When calculating tenant consumption, SharePoint tallies not just the active file, but every recorded major version. A single large disk image modified repeatedly multiplies consumption against your organization's pooled SharePoint storage quota unless version trimming policies intervene.

SharePoint Online supports up to 250 GB per file upload across document libraries, Teams files, and OneDrive folders, though browser uploads over 10 GB frequently time out without dedicated sync tools. This discrepancy between theoretical capacity and daily reality stems from browser process architecture, HTTP session handling, and reverse-proxy timeouts.

When you drag and drop a massive video file into the SharePoint web interface, your browser does not treat the transfer like a resilient background daemon. Modern browsers run each tab within an isolated process memory sandbox. When handling massive uploads via standard multipart HTTP POST or large binary streaming, the browser buffers chunks in local system memory. If the browser tab exhausts its memory allocation, crashes, or goes into sleep mode due to background tab throttling, the connection severs instantly.

Network layer timeouts represent an even greater hazard:

• Single-connection fragility: Standard browser transfers lack block-level transaction rollback. If a transient network glitch drops your TCP connection near the end of a long transfer, standard web browsers cannot resume from the last received byte. The session resets, forcing you to begin again from byte zero.
• Gateway and proxy timeouts: Corporate firewalls, enterprise VPNs, and cloud edge proxies routinely terminate idle or prolonged TCP connections after a few minutes of continuous streaming. Because a massive upload maintains an open socket for extended periods on typical outbound connections, intermediate network devices frequently terminate the session.
• Tenant bandwidth throttling: Microsoft 365 monitors tenant-wide resource usage. When an engineering or creative group pushes numerous concurrent massive files, SharePoint triggers HTTP 429 (Too Many Requests) or HTTP 503 responses. While desktop tools parse the incoming Retry-After header and back off smoothly, web browser scripts frequently register a generic connection failure.

If your workflow requires team members to upload massive assets directly through a web browser, relying on the native SharePoint web interface leads to ongoing ticket escalations. The browser is optimal for documents, spreadsheets, and small slide decks, but unsuitable for raw footage, database backups, or virtual disk images.

To circumvent browser timeouts, IT teams routinely instruct staff to install the OneDrive desktop sync app (OneDrive.exe on Windows or OneDrive for Mac). The desktop client uses background block-level chunking and local filesystem monitors to push large files to SharePoint. However, relying on the sync client introduces an architectural bottleneck: the local file catalog limit.

As of September 2026, Microsoft recommends syncing no more than 300,000 total items across all libraries in the OneDrive sync client to avoid performance degradation. This item ceiling is not a hard block on tenant storage, but a practical limit on the client device's sync engine as documented in Microsoft's OneDrive sync restrictions.

Every synced file and folder requires an entry in the local SQLite database maintained by the OneDrive client. When an employee connects multiple SharePoint document libraries containing hundreds of thousands of files, the local sync client must continuously reconcile filesystem events against cloud change tokens.

This produces several documented failure modes:

• The infinite processing loop: The sync client displays a status of "Processing changes" for hours or days. The background process consumes heavy processor capacity simply calculating file hashes and comparing delta tokens.
• Differential sync limitations: While OneDrive supports differential sync for Microsoft Office documents and select file types, binary files like compressed archives, raw camera clips, CAD models, and disk images must upload in their entirety whenever modified. Editing a single byte of metadata inside a massive container file causes a full re-upload of the entire asset.
• Local disk cache exhaustion: Even when Files On-Demand is enabled to keep files online-only, the operating system must allocate local disk space for hydrated cache stubs and staging buffers during active uploads. Pushing massive archives requires substantial free local storage space on the primary drive.

When libraries approach heavy item volumes, desktop synchronization becomes fragile. Renaming a parent folder can generate numerous sync conflicts, locking user workstations and overwhelming office upload bandwidth.

Share and manage massive assets without transfer stalls

Move beyond rigid sync limits and fragile browser uploads. Fast.io provides persistent workspaces with chunked upload sessions, granular permissions, and streaming previews for large team assets. Every organization starts with a 14-day free trial, which requires a credit card.

Start 14-Day Trial

Beyond raw byte size and item volume, SharePoint enforces structural constraints that cause transfers to fail with ambiguous errors. The most prevalent of these hidden ceilings is the path length restriction.

The total decoded file path length in SharePoint cannot exceed 400 characters, creating hidden limits on deep directory hierarchies. This restriction encompasses the complete web URL, including the protocol, tenant subdomain, site collection name, document library name, all nested subfolders, and the file name itself.

Consider how quickly a nested corporate directory consumes this allowance:

https://globalenterprise.sharepoint.com/sites/ProductDevelopmentDivision/Shared%20Documents/Engineering_Architecture_Design_Prototypes/Hardware_Specifications_And_Component_Schematics/Quarterly_Review_Assets/Mechanical_CAD_Assembly_Renderings_Final_Rev4.step

While the URL string shown above might appear manageable on a desktop monitor, SharePoint evaluates the decoded string against the 400-character ceiling. If directory names contain spaces, punctuation, or non-ASCII characters, URL encoding expands each character into three symbols (such as %20 for a space or %2F for a forward slash). When employees upload deep folder structures via drag-and-drop or sync clients, paths exceeding 400 characters fail instantly. On Windows endpoints, this issue is exacerbated by the local 260-character MAX_PATH limitation, which blocks users from opening or syncing files even if SharePoint stores them successfully.

Archive handling represents another operational constraint:

• Multi-file download restrictions: When users select multiple files in the SharePoint browser interface and click "Download," SharePoint dynamically compiles a compressed ZIP container. Microsoft strictly caps autogenerated ZIP archives when users download multiple items simultaneously. Attempting to batch-download a folder containing large project assets triggers an error or truncates the archive.
• In-browser archive extraction restrictions: SharePoint cannot unpack massive compressed archives directly within cloud storage. If an external partner sends an extensive ZIP file, an employee must download the full archive locally, extract the contents on a local drive, and upload the thousands of individual nested files back to SharePoint.
• Media preview ceilings: While SharePoint provides inline streaming for standard web video formats, high-bitrate production files (such as Apple ProRes, Avid DNxHR, or raw camera formats) exceed the transcoding capabilities of the built-in media preview engine. Team members must download the full master file merely to review its contents.

Organizations managing massive datasets require predictable architectures that avoid browser drops and desktop sync thrashing. Standardizing your file distribution strategy around proven engineering patterns ensures files reach colleagues and clients without disruption.

1. Partition Large Repositories Across Hub Sites

To maintain performance, avoid creating monolithic document libraries that store excessive files under a single root. Instead, adopt a modular architecture:

• Create discrete site collections for separate departments or distinct projects rather than nesting folders within a single master site.
• Maintain manageable file counts per individual document library to preserve granular permission inheritance and avoid view threshold warnings.
• Use SharePoint metadata columns rather than deep ten-level folder hierarchies. Flat metadata structures eliminate the 400-character path limit hazard entirely.

2. Automate Programmatic Uploads via Microsoft Graph API

When transferring extensive files into Microsoft 365, bypass both the web browser and the OneDrive sync client. The Microsoft Graph API provides a dedicated createUploadSession endpoint designed for resilient, chunked file ingestion.

The following PowerShell script demonstrates how to initiate a chunked upload session for an extensive file:

<# Initialize an upload session for a large file in SharePoint via Microsoft Graph #>
$SiteId = "yourtenant.sharepoint.com,site-guid,web-guid"
$DriveId = "b!drive-guid-here"
$TargetFolder = "root:/ProductionAssets"
$FileName = "QuarterlyArchive_Master.tar.gz"

$Uri = "https://graph.microsoft.com/v1.0/sites/$SiteId/drives/$DriveId/$TargetFolder/$FileName`:/createUploadSession"

$Session = Invoke-RestMethod -Method Post -Uri $Uri -Headers @{
    "Authorization" = "Bearer $AccessToken"
    "Content-Type"  = "application/json"
} -Body '{"item": {"@microsoft.graph.conflictBehavior": "rename"}}'

<# The response returns an uploadUrl where data can be posted in discrete fragments #>
Write-Output "Upload session active at: $($Session.uploadUrl)"

Using upload sessions allows custom scripts to transmit data in discrete fragments. If a connection drops, your script queries the upload URL for missing byte ranges and resumes without restarting the transfer from the beginning.

3. Deploy Cloud Workspaces Built for Large File Collaboration

To establish an effective OneDrive alternative, Fast.io provides shared workspaces designed specifically for team asset management:

• High-capacity chunked transfers: Large files upload through resilient chunked sessions, eliminating browser tab crashes and session drops.
• Built-in video streaming: Uploaded video files support HLS streaming, allowing team members and external partners to scrub through high-resolution footage in a browser without downloading the full master file.
• Branded distribution portals: Through branded file sharing, teams can create durable or expiring shares (Send, Receive, or Exchange) with per-recipient access permissions, avoiding multi-file archive download limits.
• Cloud import without local bandwidth: Pull massive assets directly from Google Drive, OneDrive, Dropbox, or external URLs straight into your workspace without consuming local disk space or office bandwidth.
• Built-in file version history: Full version history tracks every iteration without the sync conflicts that plague desktop client engines.

Every organization starts with a 14-day free trial, which requires a credit card. Paid subscription plans scale with your storage and operational needs, as detailed on the Fast.io pricing page: