WebDAV File Size Limit: Client Constraints, Windows Registry, and Server Caps

The WebDAV file size limit on Windows clients defaults to 50MB (50,000,000 bytes) due to the WebClient service FileSizeLimitInBytes registry key, returning Error 0x800700DF when transferring larger files. When a user or automated script attempts to copy, download, or save a file larger than 50MB over a mapped WebDAV network drive, Windows File Explorer halts the operation and reports: "Error 0x800700DF: The file size exceeds the limit allowed and cannot be saved."

As documented in Microsoft WebDAV guidance, the default file size limit for WebDAV in Windows is set to 50MB. Rather than an issue with remote storage capacity or network bandwidth, Windows enforces a 50MB client-side limit on WebDAV uploads. The operating system applies this restriction through the WebClient service (webclnt.dll) and its kernel-mode WebDAV Mini-Redirector driver (mrxdav.sys).

Microsoft introduced this 50MB default restriction in Windows XP Service Pack 2 and Windows Server 2003 as a security measure against Denial of Service attacks. The WebDAV Mini-Redirector processes file operations synchronously through local memory buffers. Without a strict threshold, downloading or uploading multi-gigabyte files across unbuffered WebDAV sessions could consume all available system non-paged pool memory, leading to desktop freezes and system-wide instability.

When an application requests a file from a WebDAV share mapped to a drive letter (such as Z:), Windows does not stream the file directly from the remote HTTP endpoint to the requesting software. The WebClient service first downloads the entire file into a hidden local cache directory located at %SystemDrive%\Windows\ServiceProfiles\LocalService\AppData\Local\Temp\TfsStore\Tfs_DAV. Only after the entire payload completes downloading and passes the file size check does Windows release the file to the local application. If the remote file header declares a Content-Length greater than 50,000,000 bytes, the WebClient service terminates the transaction immediately before writing data to disk.

This buffering architecture causes severe friction for teams working with video files, virtual machine disk images, database backups, and AI dataset archives. While local file systems like NTFS support multi-terabyte files, the WebDAV network redirector treats files above 50MB as hostile payloads unless an administrator explicitly reconfigures the Windows Registry.

• NFS File Size Limit: Protocol Versions, Mount Constraints, and Distributed WorkflowsThe NFS file size limit varies by protocol version: legacy NFSv2 is capped at 2 GB by 32-bit signed offsets, while...
• exFAT File Size Limit: Theoretical Ceilings, Practical Limits, and CompatibilityThe exFAT file size limit reaches 16 exbibytes theoretically, removing the restrictive 4 GB barrier imposed by FAT32....
• File Size Reducer Tools vs Cloud Workspaces for Large FilesA file size reducer compresses digital files by stripping metadata, downsampling media resolution, or re-encoding...
• Outlook Attachment Size Limit: Exchange Thresholds and Sending Large FilesThe Outlook attachment size limit is 20 MB for free Outlook.com accounts and defaults to 25 MB for Microsoft 365...
• How to Debug AI Agent File Access IssuesFile access errors are a leading cause of agent failures. These turn automated workflows into broken pipelines. This...
• AWS Bedrock File Size Limits: Document Constraints in Knowledge Bases and Converse APIAWS Bedrock Knowledge Bases enforces a 50 MB per-document limit for file ingestion, while the Bedrock Converse API caps...

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

Administrators can resolve Error 0x800700DF by increasing the FileSizeLimitInBytes registry value up to the maximum 32-bit limit of 4,294,967,295 bytes (4GB). This modification adjusts the WebClient service configuration to permit large file transfers across all mapped WebDAV shares on the local machine.

The configuration requires local administrative privileges and editing the Windows Registry.

Step-by-Step Registry Editor Configuration

To raise the WebDAV file size limit manually using the Windows Registry Editor:

1. Press the Windows Key + R to launch the Run dialog, type regedit, and press Enter (confirm the User Account Control prompt).
2. Navigate to the WebClient service parameters registry key:

    HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WebClient\Parameters
   

3. Locate the value named FileSizeLimitInBytes in the right-hand details pane. If the value does not exist, right-click an empty area in the pane, select New > DWORD (32-bit) Value, and name it FileSizeLimitInBytes.
4. Double-click FileSizeLimitInBytes to open the Value Editor.
5. Under Base, select the Decimal radio button. This step is critical; entering decimal numbers while Hexadecimal is selected corrupts the target size.
6. In the Value data field, enter 4294967295. In Windows WebClient parameters, this sets the WebDAV transfer threshold limit to 4,294,967,295 bytes (4GB minus 1 byte).
7. Click OK to commit the change.
8. Restart the WebClient service or reboot the workstation to apply the new registry value.

Hexadecimal Versus Decimal Base Configuration

A common point of failure when editing this registry key is misunderstanding the Base selection. Windows Registry Editor defaults to Hexadecimal input for DWORD values.

• Decimal Base: To set a 4GB WebDAV transfer limit in Windows, select the Decimal base and enter the registry DWORD value 4294967295. To set a 500MB WebDAV transfer limit in Windows, enter decimal value 524288000. To restore the default 50MB WebDAV file transfer limit in Windows, enter decimal value 50000000.
• Hexadecimal Base: In Windows Registry Editor, setting a 4GB WebDAV transfer limit in Hexadecimal requires entering ffffffff, whereas the default 50MB limit is 02faf080.

Entering 4294967295 while Hexadecimal remains selected will trigger an input error because the string exceeds the 32-bit hexadecimal format. Entering 40000000 while Hexadecimal is selected configures the Windows WebDAV registry parameter to 1,073,741,824 bytes (1GB), rather than the intended file size limit.

net stop webclient
net start webclient

Restart-Service -Name WebClient -Force

$RegistryPath = "HKLM:\SYSTEM\CurrentControlSet\Services\WebClient\Parameters"
$ValueName    = "FileSizeLimitInBytes"
$MaxValue     = [uint32]::MaxValue

if (Test-Path $RegistryPath) {
    Set-ItemProperty -Path $RegistryPath -Name $ValueName -Value $MaxValue -Type DWord
    Write-Host "Successfully updated $ValueName to $MaxValue bytes." -ForegroundColor Green
    Restart-Service -Name WebClient -Force
    Write-Host "WebClient service restarted successfully." -ForegroundColor Green
} else {
    Write-Error "Registry path $RegistryPath does not exist on this machine."
}

Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Services\WebClient\Parameters" -Name "SendTimeoutInSec" -Value 1800 -Type DWord
Restart-Service -Name WebClient -Force

While setting FileSizeLimitInBytes to 4294967295 permits 4GB file operations, Windows cannot transfer a file larger than 4GB over its native WebClient redirector under any circumstances. This 4GB boundary is not an arbitrary configuration default; it is a hard architectural limit of the 32-bit Windows WebDAV Mini-Redirector driver (mrxdav.sys).

In the Windows Registry, the FileSizeLimitInBytes key is stored as a REG_DWORD for WebDAV file transfers. A standard DWORD is an unsigned 32-bit integer. The maximum integer value that can be represented by 32 bits is 2^32 - 1, which equals exactly 4,294,967,295 bytes (4,095.999 MB).

Attempts by administrators to bypass this ceiling by creating a 64-bit REG_QWORD named FileSizeLimitInBytes fail. The internal functions of mrxdav.sys explicitly query the registry for a 32-bit DWORD. When presented with a QWORD or an unexpected data type, the driver ignores the entry and falls back to its compiled default of 50,000,000 bytes.

Why File Explorer Fails on 5GB Files

When an application or user copies a 5GB file (such as a database snapshot or ISO image) to a WebDAV drive on Windows 10 or Windows 11, the operating system fails at the redirector boundary:

1. Driver Size Validation: The WebDAV Mini-Redirector intercepts the Win32 file creation request (CreateFile with GENERIC_WRITE).
2. Integer Overflow in Header Assembly: When preparing the HTTP PUT request, the WebClient service evaluates the file length. Because the internal byte counter in Windows WebClient is an unsigned 32-bit DWORD, files exceeding 4GB cause an arithmetic overflow against the FileSizeLimitInBytes registry limit.
3. Immediate Rejection: Windows halts the operation with Error 0x800700DF or reports ERROR_FILE_SYSTEM_LIMITATION before sending a single network packet to the remote WebDAV server.

Protocol Specification Versus Windows Implementation

It is important to distinguish the WebDAV protocol standard from Microsoft's client implementation. The underlying WebDAV protocol specification (defined in IETF RFC 4918 as an extension to HTTP version 1.1) places no 4GB limit on file transfers for WebDAV clients. WebDAV relies on HTTP methods (PUT, GET, PROPFIND), which support 64-bit Content-Length headers capable of describing exabyte-scale transfers.

The 4GB ceiling is an artifact of Microsoft WebClient architecture for Windows WebDAV file transfers. Modern standalone WebDAV clients, such as Cyberduck, WinSCP, or Mountain Duck, bypass the Windows WebClient service and mrxdav.sys entirely. These third-party tools implement their own HTTP network engines with full 64-bit integer support, allowing them to upload and download files of arbitrary sizes to WebDAV servers that permit them.

Eliminate WebDAV File Size Bottlenecks in Agent Workspaces

Move beyond 50MB redirector caps and 4GB limits with Fastio shared workspaces. Connect agents via the Model Context Protocol (see https://mcp.fast.io/docs) and manage files up to 100 GB on Enterprise with built-in indexing. Monthly plans start with a 14-day free trial that requires a credit card.

Start 14-Day Trial

Fixing client registry values resolves only half of the WebDAV transfer equation. A file transfer will still abort if the target WebDAV server enforces lower request limits. When an upload fails with HTTP status codes such as 413 Request Entity Too Large, 404.13 Not Found, or 500 Internal Server Error, the bottleneck is server-side.

Production WebDAV servers require explicit tuning to accept transfers approaching or exceeding multi-gigabyte thresholds.

Microsoft Internet Information Services (IIS)

Microsoft IIS hosts WebDAV publishing natively, but it includes two independent request-filtering mechanisms that restrict payload sizes by default:

• Request Filtering (maxAllowedContentLength): By default, IIS restricts request content to 30,000,000 bytes (approximately 28.6MB). Requests exceeding this size fail with HTTP Error 404.13 - Not Found: The request filtering module is configured to deny a request that exceeds the request content length.
• ASPNET Request Length (maxRequestLength): If Windows WebDAV transfers are routed through an ASPNET pipeline, the server configuration defaults to a 4MB request limit (maxRequestLength="4096").

To raise the IIS limit to 4GB in web.config:

<configuration>
  <system.webServer>
    <security>
      <requestFiltering>
        <requestLimits maxAllowedContentLength="4294967295" />
      </requestFiltering>
    </security>
  </system.webServer>
  <system.web>
    <httpRuntime maxRequestLength="4194304" executionTimeout="3600" />
  </system.web>
</configuration>

Nginx WebDAV Configuration

Nginx is commonly deployed as a reverse proxy or native WebDAV file server using the ngx_http_dav_module. By default, Nginx enforces an exceptionally conservative limit:

• Default client_max_body_size: 1m (1 megabyte). For Nginx WebDAV endpoints, any upload larger than a 1MB limit immediately returns an HTTP 413 error status unless administrators reconfigure server caps.

To support large file uploads in Nginx, configure client_max_body_size inside your server or location block:

server {
    listen 443 ssl;
    server_name storage.internal.net;
    location /webdav/ {
        root /data/storage;
        dav_methods PUT DELETE MKCOL COPY MOVE;
        create_full_put_path on;
        dav_access group:rw all:r;
        client_max_body_size 0;
        proxy_request_buffering off;
        proxy_read_timeout 3600s;
        proxy_send_timeout 3600s;
        client_body_timeout 3600s;
    }
}

Setting client_max_body_size 0; disables body size verification, allowing the server to accept files of any size permitted by filesystem disk space.

Apache HTTP Server

Apache handles WebDAV through the mod_dav and mod_dav_fs modules.

• LimitRequestBody Directive: In Apache HTTP Server releases, the LimitRequestBody directive governs WebDAV file transfer sizes, often set by Linux distributions to a 1GB limit.
• Configuration: To adjust the cap in httpd.conf or your virtual host file:

    <Directory "/var/www/webdav">
        Dav On
        LimitRequestBody 4294967295
        Timeout 3600
    </Directory>
   

Nextcloud and ownCloud Architecture

Platforms like Nextcloud and ownCloud use WebDAV (remote.php/dav/files/USER/) as their primary storage access protocol. While Nextcloud's web interface and desktop sync clients handle files reaching 16TB by splitting WebDAV data into 10MB chunks, native Windows WebClient users bypass this chunking system and hit default transfer limits.

When you mount Nextcloud via Windows File Explorer using https://cloud.company.com/remote.php/dav/files/username/, Windows sends monolithic PUT requests. These raw requests hit PHP runtime limits:

• upload_max_filesize in php.ini
• post_max_size in php.ini
• memory_limit in php.ini

If upload_max_filesize is set to 512MB in php.ini, a Windows WebClient upload of a 1GB file will fail at the Nextcloud server boundary, even if Windows has been configured for 4GB transfers.

Teams managing automated pipelines, developer agents, and shared corpora frequently outgrow WebDAV. While modifying the Windows Registry solves desktop file transfer issues at the 4GB mark, WebDAV remains fragile for multi-agent systems and large-scale data operations.

The protocol lacks native chunked upload resumption on desktop clients, offers no intelligent document indexing, and forces applications to handle raw byte streaming across synchronous network mounts. When AI agents like Claude Code, Cursor, Codex, or custom automation bots need to ingest or persist large files, mounting WebDAV shares introduces frequent network drops, unhandled lock contentions, and file size ceilings.

Replacing Fragile WebDAV Mounts with Fastio Intelligent Workspaces

Fastio provides a modern, collaborative alternative to legacy WebDAV infrastructure with shared workspaces for agentic teams. The platform combines high-capacity cloud storage with native AI indexing and multi-agent coordination.

• Substantial File Size Ceilings: Fastio supports large single-file transfers that exceed WebDAV limits, scaling upload capacities across tiers.
• Built-in Intelligence Mode: Rather than requiring agents to stream and parse multi-gigabyte files locally, workspaces auto-index files on arrival. This enables hybrid Search across full-text, semantic meaning, and structured metadata values. Agents query documents directly with citations instead of exhausting local context windows.
• Advisory File Locks: For concurrent human and agent operations, Fastio provides advisory per-file leases in workspace storage. Locks are acquired and released through MCP actions (lock-acquire and lock-release on the storage_manage tool, with lock-status on the storage tool) for coordinating writers, while version history preserves every revision.
• Detailed Activity Log: Workspaces track changes to files, permissions, and shares in a detailed activity log, recording uploads, edits, moves, and deletions without logging passive reads or downloads.
• Cloud Sync and Import: Teams can import files directly from Google Drive, Dropbox, Box, and OneDrive, or from any public URL without consuming local bandwidth. Scheduled or on-demand Cloud Sync is available for Google Drive, Dropbox, Box, and OneDrive (one-way or two-way).

Model Context Protocol Integration for Agents

Fastio connects directly to AI agents via the Model Context Protocol (MCP) using Streamable HTTP. See the Fastio MCP setup guide for client instructions. Instead of configuring operating system network mounts, agents connect through remote endpoints:

• https://mcp.fast.io/mcp/tools for Claude desktop, mobile, web, and general client applications.
• https://mcp.fast.io/mcp/code for coding agents such as Claude Code, Cursor, Cline, and terminal environments.
• https://mcp.fast.io/mcp/operations for custom ChatGPT and Codex configurations.

Agents authenticate directly via OAuth or scoped Bearer API keys, enabling them to inspect directory contents, manage files, read document summaries, and query workspace intelligence without encountering Windows redirector caps or 50MB registry errors.

The following table outlines available organization plans and capacities:

Monthly plans start with a 14-day free trial that requires a credit card, providing a production-ready foundation for high-capacity file collaboration. Review available options on the pricing page or explore storage for agents.