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

The Windows WebDAV client imposes a default 50MB file size limit that triggers Error 0x800700DF during large transfers. Modifying the FileSizeLimitInBytes registry key raises this client ceiling to 4GB, the maximum supported by the underlying 32-bit Windows redirector. Overcoming transfer bottlenecks requires aligning client registry values with server limits across IIS, Nginx, and Apache, or adopting modern API-driven workspaces for automated pipelines.

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

## Why the Windows 50MB WebDAV Ceiling Triggers Error 0x800700DF

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](https://learn.microsoft.com/en-us/answers/questions/2260796/does-inbuilt-webdav-client-support-file-upload-upt), 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.

### Symptoms of Hitting the WebClient Threshold

The 50MB limit manifests in several distinct ways depending on whether the transfer is an upload or a download. Recognizing these symptoms helps distinguish client-side WebDAV constraints from server-side rejections:

*   **File Explorer Copy Abort:** Dragging a 75MB file into a mapped WebDAV drive displays a progress dialog that stalls at the start of the transfer bar before displaying Error 0x800700DF.
*   **Application Save Failures:** Opening a document directly from a WebDAV share in an editing tool works smoothly, but saving modifications back to the server fails if the revised file size exceeds 50MB.
*   **Silent Download Terminations:** Command-line utilities like `cmd.exe` or standard PowerShell file copy cmdlets (`Copy-Item`) report `System.IO.IOException: The file size exceeds the limit allowed and cannot be saved.`
*   **Zero-Byte Truncation:** Certain automated sync agents encounter unexpected file truncations where the file is created on the target server with metadata but zero bytes of content.

## How to Modify FileSizeLimitInBytes to Raise the Limit to 4GB

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:
   

```text
    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.

### Restarting the WebClient Service

Changes to `FileSizeLimitInBytes` do not take effect dynamically. The WebClient service caches its parameters at startup. You must restart the service to load the new registry data.

Open an administrator Command Prompt (Run as Administrator) and run:
```cmd
net stop webclient
net start webclient
```

Alternatively, run the equivalent command in an PowerShell terminal run as administrator:
```powershell
Restart-Service -Name WebClient -Force
```

If the WebClient service fails to start or reports that it is disabled, check `services.msc`, locate **WebClient**, set its **Startup type** to **Automatic**, and click **Start**.

### Automating the Fix with PowerShell

For enterprise IT teams and automated environments, configuring endpoints through PowerShell eliminates manual Registry Editor errors. The following script configures the maximum 4GB limit and restarts the WebClient service:

```powershell
$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."
}
```

This script can be pushed via Microsoft Intune, Group Policy Objects (GPO), or deployment task sequences to standardize WebDAV capabilities across a fleet.

### Adjusting SendTimeoutInSec to Prevent Transfer Timeouts

Increasing file size allowances often reveals a secondary constraint: transfer timeouts. By default, the WebClient service terminates any HTTP request that does not complete within 60 seconds. When transferring a 3GB file over a Windows WebDAV drive, the default 60-second client timeout is insufficient.

In the same registry subkey (`HKLM\SYSTEM\CurrentControlSet\Services\WebClient\Parameters`), locate or create the DWORD value **`SendTimeoutInSec`**.

*   **Default Value:** `60` seconds (Decimal).
*   **Recommended Value:** `1800` seconds (30 minutes) or `3600` seconds (1 hour).

To set the timeout to 30 minutes in PowerShell:
```powershell
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Services\WebClient\Parameters" -Name "SendTimeoutInSec" -Value 1800 -Type DWord
Restart-Service -Name WebClient -Force
```

Increasing `SendTimeoutInSec` prevents Windows from aborting legitimate multi-gigabyte transfers midway through the network stream.

## Why 32-Bit Redirector Architecture Imposes a 4GB Hard Limit

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.

### Comparison of WebDAV Client Limits

The following table compares default transfer capacities and maximum theoretical limits across client implementations:

| Client Implementation | Default File Limit | Maximum File Limit | Mechanism |
| :--- | :--- | :--- | :--- |
| Windows WebClient (Default) | 50 MB | 50 MB | Registry default (`FileSizeLimitInBytes`) |
| Windows WebClient (Modified) | 50 MB | 4 GB | 32-bit DWORD limit (`4294967295`) |
| macOS Finder (Native WebDAV) | Unlimited (Server cap) | 2 TB+ (64-bit HTTP engine) | Native Darwin WebDAVFS |
| Linux davfs2 | Unlimited (Server cap) | Unlimited (64-bit file offsets) | Kernel VFS redirector module |
| Dedicated Tools (Cyberduck/WinSCP) | Unlimited (Server cap) | Unlimited (Chunked HTTP engine) | Proprietary application-level HTTP stack |

For environments restricted to native Windows WebClient drive mapping, 4GB remains the unbreakable WebDAV file transfer limit.

## How Server Caps in IIS, Apache, Nginx, and Nextcloud Restrict Transfers

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`:
```xml
<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:
```nginx
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:
   

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

```

### Nextcloud and ownCloud Architecture

Platforms like [Nextcloud](/alternatives/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.

### WebDAV Server Default Versus Tuned Limits

The following table summarizes default and maximum configurations across popular WebDAV server stacks:

| Server Platform | Default Upload Limit | Configuration Parameter | Max Supported Limit |
| :--- | :--- | :--- | :--- |
| Microsoft IIS 10 | 28.6 MB (30,000,000 bytes) | `maxAllowedContentLength` | 4 GB (`4294967295`) |
| Nginx | 1 MB (`1m`) | `client_max_body_size` | Unlimited (`0`) |
| Apache HTTP Server | 1 GB or Unlimited | `LimitRequestBody` | 2 GB to Unlimited |
| Nextcloud / ownCloud | 2 MB (Default PHP) | `upload_max_filesize` / `post_max_size` | 16 TB (Requires Chunking) |

Aligning server parameters with client registry settings is mandatory to prevent intermediate proxy drops.

## Modern File Pipelines and MCP Workspaces for Agentic Workflows

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](/product/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](https://mcp.fast.io/docs) 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:

| Plan | Price | Included Storage and Workspaces | Monthly Credits | Maximum Upload |
| :--- | :--- | :--- | :--- | :--- |
| Starter | $9.99/mo | 3 seats, 250 GB, 5 workspaces | 100,000 credits | 25 GB upload |
| Business | $49.99/mo | 10 seats, 5 TB, 50 workspaces | 600,000 credits | 50 GB upload |
| Enterprise | $199.99/mo | 30 seats included, 25 TB, 200 workspaces | 3,000,000 credits | 100 GB upload |

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](/pricing/) or explore [storage for agents](/storage-for-agents/).

### WebDAV Versus Intelligent Agent Workspaces

The operational differences between legacy WebDAV network mounts and modern intelligent workspaces highlight why data engineering teams are transitioning away from WebDAV:

*   **Transfer Architecture:** WebDAV relies on synchronous single-stream HTTP PUT operations that choke on network latency. Modern workspaces use chunked, multi-part uploads with automatic resumption.
*   **File Intelligence:** WebDAV is passive storage; it cannot parse, inspect, or summarize files. Fastio indexes content automatically for RAG and natural-language querying.
*   **Concurrency Management:** WebDAV file locking relies on RFC 4918 server locks that often leave orphaned locks after network disconnects. Fastio provides advisory leases with heartbeats and per-file version history.
*   **Access Control:** WebDAV exposes directory structures over basic HTTP authentication. Fastio governs access through granular organization, workspace, and share-level permissions.

## Frequently asked questions

### Why does WebDAV have a 50MB file limit on Windows?

Windows enforces a default 50MB limit through the WebClient service FileSizeLimitInBytes registry key to prevent memory exhaustion and Denial of Service conditions. Because the legacy Windows WebDAV Mini-Redirector buffers entire files in memory during synchronous transfers, the 50MB cap was implemented as a protective threshold.

### How do I fix Error 0x800700DF in WebDAV?

To resolve Error 0x800700DF, open regedit, navigate to HKLM\SYSTEM\CurrentControlSet\Services\WebClient\Parameters, double-click FileSizeLimitInBytes, select Decimal, and enter 4294967295. After saving, restart the WebClient service by executing net stop webclient followed by net start webclient in an administrator command prompt.

### Can WebDAV transfer files larger than 4GB on Windows?

The native Windows WebClient service cannot transfer files larger than 4GB because FileSizeLimitInBytes is limited to a 32-bit unsigned integer (DWORD), which maxes out at 4,294,967,295 bytes. To transfer files larger than 4GB over WebDAV on Windows, you must use third-party clients like Cyberduck or WinSCP, which bypass the Windows WebClient redirector.

### What is the difference between FileSizeLimitInBytes and FileAttributesLimitInBytes?

FileSizeLimitInBytes defines the maximum file payload size allowed during file read and write operations. FileAttributesLimitInBytes controls the maximum memory allocated for directory metadata and attribute collections (defaulting to 1,000,000 bytes). If a WebDAV directory contains thousands of files, FileAttributesLimitInBytes may also need to be increased to prevent enumeration errors.

### Why do WebDAV file transfers time out after increasing the file size limit?

The WebClient service enforces a default 60-second request timeout via the SendTimeoutInSec registry key. When transferring multi-gigabyte files, network latency often causes transfers to exceed 60 seconds. Raising SendTimeoutInSec to 1800 (30 minutes) or 3600 (1 hour) prevents Windows from dropping the connection prematurely.

### How do server-side limits in IIS, Apache, and Nginx interact with the Windows WebDAV client?

WebDAV transfers require both the client and the server to permit the file size. If Windows is configured for 4GB transfers but Nginx has client_max_body_size set to 1m, or IIS has maxAllowedContentLength set to 30MB, the server will reject the transfer with HTTP 413 or HTTP 404.13 before accepting the data.

## Sources

- [Microsoft Learn](https://learn.microsoft.com/en-us/answers/questions/2260796/does-inbuilt-webdav-client-support-file-upload-upt): According to Microsoft technical guidance for WebDAV file transfers, the default Windows WebClient FileSizeLimitInBytes limit is 50MB, but editing registry DWORD values raises the maximum threshold to 4GB across File Explorer drives.
- [Jevid](https://jevid.com/blog/webdav-file-size-limit-windows-raise/): As documented in network file transfer benchmarks, Windows enforces a 50MB client-side limit on WebDAV uploads, causing Error 0x800700DF unless administrators reconfigure registry parameters or server caps.

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