# How to Mount OneDrive on Windows with Rclone and WinFsp

Rclone mount OneDrive on Windows uses the WinFsp user-mode file system proxy to expose remote Microsoft OneDrive folders as a standard local drive letter with VFS disk caching. Without full VFS cache buffering and directory cache tuning, Windows Explorer thumbnail scans and random writes trigger I/O deadlocks and Graph API rate limits. Running mounts via NSSM provides persistent background service execution.

Source: https://fast.io/resources/rclone-mount-onedrive-windows/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-10-11

## How Rclone and WinFsp Expose OneDrive as a Windows File System

Mounting Microsoft OneDrive as a physical drive letter on Windows fails immediately when software attempts in-place file mutations without an underlying user-mode file system driver. Unlike Linux operating systems that include the Filesystem in Userspace (FUSE) kernel interface by default, Windows relies on a proprietary Installable File System architecture. Cloud storage tools cannot attach directly to the Windows I/O subsystem without a specialized translation bridge.

Rclone mount OneDrive on Windows uses the WinFsp user-mode file system proxy to expose remote Microsoft OneDrive folders as a standard local drive letter with VFS disk caching. [WinFsp](https://winfsp.dev) operates as a bridge between the Windows NT kernel and user-space binaries. When Windows Explorer, a local script, or an automation tool accesses a file on the mounted drive, the request passes through the WinFsp kernel driver, transitions into user space, and reaches Rclone. Rclone then converts standard Win32 filesystem calls into HTTPS calls directed at the Microsoft Graph API.

```
+-------------------------------------------------------------------------+
|                  Windows Applications, Explorer, and Scripts            |
|                  (Win32 File APIs: CreateFileW, ReadFile, WriteFile)    |
+-------------------------------------------------------------------------+
                                     |
                               (Kernel I/O)
                                     |
+-------------------------------------------------------------------------+
|                          WinFsp Kernel Driver                           |
|                       (winfsp-x64.sys / FspFsctl)                       |
+-------------------------------------------------------------------------+
                                     |
                               (IPC / Proxy)
                                     |
+-------------------------------------------------------------------------+
|                        Rclone User-Space Process                        |
|             (VFS Cache Layer + Sparse Disk Buffers + Rate Pacer)        |
+-------------------------------------------------------------------------+
                                     |
                         (HTTPS / OAuth 2.0 Tokens)
                                     |
+-------------------------------------------------------------------------+
|                       Microsoft Graph API Endpoint                      |
|                      (https://graph.microsoft.com)                      |
+-------------------------------------------------------------------------+
                                     |
                   +-----------------+-----------------+
                   |                                   |
+-----------------------------------+ +-----------------------------------+
|     Personal Microsoft OneDrive   | |    OneDrive for Business / Office |
|         (Consumer Identity)       | |        (SharePoint Tenant)        |
+-----------------------------------+ +-----------------------------------+
```

### WinFsp Installation and Privilege Boundaries

Before running mount operations on Windows, you must install the WinFsp runtime package. Rclone does not bundle WinFsp directly because the driver must register with the Windows Service Control Manager and install low-level system services.

1. Download the latest stable WinFsp MSI installer package from the official WinFsp release repository.
2. Run the installer and confirm that the "Core" component and the "Developer" headers are selected. Complete the installation with administrative privileges.
3. Rebooting Windows is optional, but restarting the system guarantees that the WinFsp kernel driver (`winfsp-x64.sys`) registers with the Windows driver store.

A common operational hurdle on Windows involves User Account Control (UAC) privilege separation. Windows isolates drive letter mappings by logon session ID. If you open PowerShell as an Administrator and execute a mount command, the resulting drive letter belongs exclusively to the elevated administrative session. Standard user sessions, including your regular Windows Explorer desktop, will not display or access the drive letter. To ensure your standard desktop applications can interact with the mounted OneDrive folder, execute the mount commands from a standard, non-elevated PowerShell console.

## How to Configure OneDrive and Mount a Local Drive Letter

Connecting Rclone to Microsoft OneDrive requires setting up an authenticated remote through OAuth 2.0. Rclone supports both consumer Microsoft accounts and enterprise OneDrive for Business accounts hosted on Microsoft 365 or SharePoint tenants.

### Step 1: Run Rclone Config

Open PowerShell and start the interactive configuration utility:

```powershell
rclone config
```

Follow the prompts to configure the remote:
1. Type `n` to create a new remote. Name the connection `onedrive`.
2. Scroll through the storage provider list and choose `onedrive` (Microsoft OneDrive).
3. Leave the `client_id` and `client_secret` blank to use Rclone default credentials, or supply your own Azure App Registration credentials for higher API request quotas.
4. Select your account region (typically `global`).
5. When asked to edit advanced configuration, select `n`.
6. For auto config, select `y`. Rclone opens your default web browser to complete the Microsoft OAuth 2.0 sign-in.
7. Sign in with your Microsoft account and grant read and write consent to the application.
8. Back in PowerShell, select your drive type: choose `1` for personal OneDrive or `2` for OneDrive for Business and SharePoint. Confirm the configuration and save the entry.

Verify that your remote communicates with the Microsoft Graph API by listing the root directory:

```powershell
rclone lsd onedrive:
```

### Step 2: Mount OneDrive as a Local Drive Letter

To expose your remote files as a dedicated drive letter such as `O:`, execute the following PowerShell command. According to the [Rclone mount documentation](https://rclone.org/commands/rclone_mount/), many applications fail on unbuffered rclone mounts because without VFS cache modes the system can only write files sequentially.

```powershell
rclone mount onedrive: O: `
  --vfs-cache-mode full `
  --vfs-cache-max-size 20G `
  --vfs-cache-max-age 24h `
  --dir-cache-time 72h `
  --vfs-read-chunk-size 64M `
  --vfs-read-chunk-size-limit 512M `
  --buffer-size 32M `
  --network-mode `
  --volname "OneDrive"
```

### Operational Mechanics of the Mount Flags

Understanding each flag prevents runtime disk exhaustions and connection drops:

- `--vfs-cache-mode full`: Full VFS cache mode prevents process deadlocks when Windows software requests random write access. Microsoft Graph does not permit arbitrary byte-offset modifications over HTTP. In `full` mode, Rclone stages files as sparse local disk allocations, allowing random writes, database locks, and truncate calls to execute locally before staging uploads back to OneDrive.
- `--vfs-cache-max-size 20G`: Caps the maximum disk footprint used by cached files in the local AppData folder. Once the cache exceeds this threshold, Rclone evicts the oldest clean files.
- `--vfs-cache-max-age 24h`: Purges local cache objects that have not been accessed within a 24-hour window.
- `--dir-cache-time 72h`: Caches remote directory metadata in RAM. Because directory structures change infrequently compared to individual file edits, longer cache windows eliminate repetitive remote folder listing calls.
- `--vfs-read-chunk-size 64M` and `--vfs-read-chunk-size-limit 512M`: Directs Rclone to fetch files in expanding chunk sizes rather than streaming single massive objects. If an application only reads a header, Rclone downloads only the initial chunk.
- `--network-mode`: Informs WinFsp to register the drive letter as a network share rather than a fixed local hard disk. This tells Windows to relax local volume indexing behaviors.

## Why Windows Explorer Freezes on Cloud Mounts and How to Fix It

A persistent point of friction with cloud file mounts on Windows is system unresponsiveness inside File Explorer. When you open a folder on a mapped drive, File Explorer does not merely display file names. The Windows shell immediately spawns parallel worker threads to read file headers, inspect embedded metadata, and generate visual preview thumbnails for images, PDFs, and media files.

Windows Explorer thumbnail generation causes high API call volumes on unbuffered cloud mounts. For every media file in a folder, Explorer attempts to read specific byte segments to extract image previews. If a directory contains hundreds of files, Explorer issues hundreds of simultaneous read requests. As outlined in the [Microsoft Graph throttling guidance](https://learn.microsoft.com/en-us/graph/throttling), Microsoft Graph returns HTTP status code 429 when high API call volumes exceed tenant throttling thresholds.

When Microsoft Graph throttles a connection, it instructs the client to wait. File Explorer threads pause execution while waiting for Rclone to return file data, causing the entire File Explorer window to freeze, display the "Not Responding" title bar, and lock the Windows taskbar.

### Step 1: Disable Windows Explorer Automatic Thumbnail Generation

You can prevent thumbnail-related API storms by configuring Windows Explorer to display standard static file icons instead of extracting previews over the network:

1. Open File Explorer, click the three dots menu in the command bar, and select **Options**.
2. Switch to the **View** tab in the Folder Options window.
3. Check the option: **Always show icons, never thumbnails**.
4. Uncheck the option: **Show preview handlers in preview pane**.
5. Click **Apply to Folders**, then click **OK**.

For system administrators deploying configurations across corporate workstations, the same setting can be applied through PowerShell by writing to the Windows Registry:

```powershell
Set-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced" `
  -Name "IconsOnly" -Value 1
```

### Step 2: Tune Rclone Pacing and Metadata Flags

In addition to adjusting Windows Explorer settings, you can add metadata flags to the Rclone mount command to reduce request volumes:

```powershell
rclone mount onedrive: O: `
  --vfs-cache-mode full `
  --vfs-cache-max-size 20G `
  --dir-cache-time 72h `
  --no-checksum `
  --no-modtime `
  --tpslimit 10 `
  --tpslimit-burst 10 `
  --network-mode `
  --volname "OneDrive Mount"
```

- `--no-checksum`: Suppresses checksum verification during initial directory reading. Calculating or comparing remote hashes forces extra API lookups.
- `--no-modtime`: Stops Rclone from writing back updated modification timestamps on close operations, eliminating redundant HTTP calls.
- `--tpslimit 10`: Caps outgoing requests to 10 transactions per second, keeping traffic well within Microsoft Graph threshold boundaries.

## Steps to Run Rclone Mount as a Persistent Windows Service with NSSM

Running `rclone mount` in an interactive PowerShell window is fragile. If you close the terminal window, log off, or restart the system, the drive letter unmounts immediately. Standard Windows Scheduled Tasks often fail to restart cleanly when a laptop disconnects from Wi-Fi.

The standard industry approach for persistent background execution on Windows is [NSSM](https://nssm.cc/) (Non-Sucking Service Manager). NSSM wraps standard command-line executables as native Windows Services, providing automatic recovery, clean startup on boot, and background lifecycle management.

### NSSM Service Management and Service Account Caveats

Existing setup guides frequently omit a critical operational constraint: Windows Service accounts. By default, Windows services run under the `LocalSystem` security context in Session 0.

Running Rclone under `LocalSystem` introduces two critical failures:
1. **Missing Configuration:** The `LocalSystem` account does not share your user environment. It cannot find your user configuration file and will crash on launch unless an explicit `--config` flag points to an accessible path.
2. **Invisible Drive Letters:** Windows isolates drive letters by logon session. A drive letter (such as `O:`) mounted in Session 0 by `LocalSystem` is completely invisible to interactive user desktop sessions in Session 1.

To resolve this limitation, configure the NSSM service to log on under your specific Windows user account credentials, or specify the exact path to your configuration file while mounting to a dedicated directory junction instead of a drive letter.

### Step 1: Install and Configure the Service with NSSM

1. Download NSSM from its official project site and copy the 64-bit binary to a permanent directory, such as `C:\Program Files\rclone/nssm.exe`.
2. Open PowerShell with Administrator privileges.
3. Run the NSSM service installer:

```powershell
nssm install RcloneOneDrive
```

The NSSM configuration interface will appear:

- **Application Tab:**
  - *Path:* `C:\Program Files\rclone\rclone.exe`
  - *Startup directory:* `C:\Program Files\rclone`
  - *Arguments:* `mount onedrive: O: --config "C:\Users\username\.config\rclone\rclone.conf" --vfs-cache-mode full --vfs-cache-max-size 20G --dir-cache-time 72h --network-mode --volname "OneDrive"`
- **Log on Tab:**
  - Select **This account** and enter your Windows username and password. This guarantees the mounted drive letter appears in your user session and inherits appropriate permissions.
- **Exit actions Tab:**
  - Ensure *Restart* is set to `Restart application` with an *AppRestartDelay* of 5000 milliseconds to prevent aggressive restart loops if your internet connection drops.

Click **Install service** to complete registration.

### Step 2: Start and Manage the Service

Start the newly created service using PowerShell:

```powershell
nssm start RcloneOneDrive
```

To verify the service status:

```powershell
Get-Service -Name RcloneOneDrive
```

If you need to adjust parameters later, launch the graphical editor:

```powershell
nssm edit RcloneOneDrive
```

To stop and remove the service cleanly when updating binaries:

```powershell
nssm stop RcloneOneDrive
nssm remove RcloneOneDrive confirm
```

## Why Native Sync Conflicts Occur and How Workspaces Scale Agent Access

Running an Rclone mount alongside the native Windows OneDrive desktop sync client on the exact same folders introduces immediate operational conflicts. The native Microsoft OneDrive client uses the Windows Cloud Filter API to manage its Files On-Demand state, tracking hydration, dehydration, and local file stubs.

When both the native sync client and an Rclone mount target the same directory tree, the two file engines conflict:
1. **Competing Sync Engines:** The native client and Rclone employ independent caching and upload logic. When an application writes to an Rclone mount, Rclone commits changes to the remote Microsoft Graph endpoint. The native sync client detects a remote update while simultaneously seeing a modified file locally, frequently producing duplicate files named with the computer hostname appended.
2. **File Lock Contention:** If an application opens a file on the Rclone mount with write locks, the native OneDrive client fails when attempting to read the file for cloud backup, resulting in sync errors.
3. **Cache Inconsistency:** The local Rclone VFS cache and the native OneDrive cache store redundant copies of identical files, doubling local disk utilization.

To prevent sync conflicts, choose one operational path:
- If you use the native OneDrive sync client for everyday desktop folders, configure Rclone to mount only distinct subfolders or dedicated archive libraries that are excluded from native client sync settings.
- If you require a direct drive letter mount across your entire OneDrive repository, pause or sign out of the native OneDrive client.

### The Storage Latency Bottleneck for AI Agents

While a local Rclone mount works well for human interactive browsing in File Explorer, autonomous AI agents and coding tools (such as Claude Code, Cursor, Cline, or custom automation scripts) encounter performance bottlenecks when interacting with cloud files through local filesystem mounts.

Autonomous agents frequently execute deep recursive directory walks, grep scans, and structural repository indexing. When an agent scans an Rclone mount on Windows:
- Every directory listing generates synchronous WinFsp IPC calls and Graph API queries.
- Reading code files forces Rclone to download blocks into the local VFS cache, consuming bandwidth and introducing latency pauses.
- If an agent generates large volumes of intermediate edits, local disk buffering and delayed VFS writebacks can cause timing mismatches.

### The Fastio Alternative: Intelligent Workspaces and Remote MCP

Teams building workflows around autonomous AI agents can bypass the instability of local Windows file system mounts by pairing their existing Microsoft OneDrive storage with an intelligent workspace.

In this architecture, your existing storage remains the primary corporate source of truth:
1. **Scheduled Cloud Sync:** [Fastio Cloud Sync](/product/cloud-sync/) connects directly to your existing Microsoft OneDrive or SharePoint document library. Folders synchronize into a [Fastio workspace](/product/workspaces/) one-way or two-way, running on a schedule or on demand. Synchronization operates in the cloud without requiring a continuous local daemon process or local disk storage.
2. **Workspace Intelligence:** Fastio automatically indexes incoming files using Intelligence Mode, combining full-text indexing and semantic search into a unified search layer.
3. **Remote Model Context Protocol (MCP) Tooling:** Instead of forcing an agent to parse whole directories through a local Windows drive letter mount, the agent connects directly to the remote Fastio MCP server. Coding agents in IDEs or terminals (such as Claude Code, Cursor, or Cline) connect using the Streamable HTTP endpoint at `https://mcp.fast.io/mcp/code`. General conversational apps connect at `https://mcp.fast.io/mcp/tools`. Learn more about deployment architecture on the [storage for agents](/storage-for-agents/) page.
4. **Targeted Search Retrieval:** The agent executes targeted semantic and metadata queries across the workspace index, retrieving only the precise excerpts needed to complete its task rather than streaming multi-gigabyte folders over network mounts.

In performance evaluations measuring cloud storage connectors for autonomous agents, the connector comparison published at [/benchmarks/](/benchmarks/) measured Fastio as the fastest and the lowest cost of the providers tested.

Fastio provides Starter, Business, and Enterprise plans, with monthly subscriptions starting with a 14-day free trial that requires a credit card. Review complete plan specifications and credit allowances on the [pricing page](/pricing/).

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

## Frequently asked questions

### How do I mount OneDrive as a drive letter on Windows with rclone?

To mount OneDrive as a drive letter, install WinFsp, configure your remote using rclone config, and execute the rclone mount command in PowerShell: rclone mount onedrive: O: --vfs-cache-mode full. The --vfs-cache-mode full flag is necessary on Windows to enable proper file caching and allow desktop applications to perform random write operations.

### Why does Windows Explorer freeze when opening an rclone OneDrive mount?

Windows Explorer freezes because it automatically launches background threads to generate thumbnail previews and extract metadata for every file in the directory. On unbuffered cloud mounts, this generates hundreds of concurrent read requests, causing Microsoft Graph API 429 throttling and thread deadlocks. Disabling Explorer thumbnails and configuring rclone with directory caching and request pacing resolves the issue.

### Can AI agents read files from a Windows rclone mount?

Yes, AI agents can read files from an rclone Windows mount, but recursive repository walks and heavy file inspections suffer from high latency and local disk cache overhead. A more efficient pattern for AI agents is connecting directly to an intelligent workspace via the Model Context Protocol (MCP), querying indexed files semantically instead of mounting remote folders as local drives.

### Why does rclone require WinFsp to mount drives on Windows?

Windows lacks a native in-kernel FUSE subsystem like Linux. WinFsp provides a Windows File System Proxy driver and user-mode library that intercepts standard Win32 file operations from the NT kernel and passes them to user-space applications like Rclone, which translates them into remote cloud API requests.

### How do I prevent conflicts between rclone mount and the native OneDrive sync client?

Avoid pointing rclone mount and the native OneDrive desktop client at the same local or remote directory. If both tools manage identical folders simultaneously, competing sync algorithms and file locks produce duplicate files with computer name suffixes. Use rclone only for un-synced directories or pause the native client while rclone is active.

## Sources

- [Rclone Documentation: rclone mount](https://rclone.org/commands/rclone_mount/): Many applications fail on unbuffered rclone mounts because without VFS cache modes the system can only write files sequentially.
- [Microsoft Learn: Microsoft Graph throttling guidance](https://learn.microsoft.com/en-us/graph/throttling): Microsoft Graph returns HTTP status code 429 when high API call volumes exceed tenant throttling thresholds.

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