# How to Configure Rclone with OneDrive for Business and SharePoint

Rclone OneDrive for Business connects rclone to Microsoft 365 SharePoint and OneDrive tenants via Microsoft Entra ID application registration, enabling headless sync and FUSE mounting across organizational document libraries. Connecting enterprise tenants requires custom credentials to satisfy conditional access policies and prevent Microsoft Graph rate limits. This guide explains Entra ID setup, rclone configuration, FUSE caching, and remote workspace sync for AI agents.

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

## Why Enterprise Rclone Deployments Require Dedicated Entra ID Credentials

Enterprise Microsoft 365 deployments enforce strict tenant boundaries, conditional access policies, and dynamic API throttling that break standard consumer cloud storage tools. When administrators connect command-line tools to corporate document repositories, standard personal authentication flows fail to meet organizational compliance requirements.

Rclone OneDrive for Business connects rclone to Microsoft 365 SharePoint and OneDrive tenants via Microsoft Entra ID application registration, enabling headless sync and FUSE mounting across organizational document libraries.

Understanding this integration requires distinguishing between the different storage abstractions within the Microsoft 365 ecosystem. While consumer OneDrive accounts map directly to a single personal root directory on live.com, enterprise accounts operate within a distinct Microsoft 365 tenant hosted on SharePoint infrastructure.

### Personal Accounts vs Enterprise Tenants

Personal Microsoft OneDrive accounts rely on consumer Microsoft accounts and authenticate against the common consumer identity endpoint. In contrast, OneDrive for Business is an enterprise service provisioned as a personal site collection within SharePoint Online. Each user's business storage space is a dedicated SharePoint site hosted at a URL following the format `https://<tenant>-my.sharepoint.com/personal/<user_upn>/Documents`.

SharePoint Online expands this architecture to shared organizational document libraries. An organization maintains communication sites, team sites, and cross-functional document repositories, each containing one or more document libraries. Microsoft Graph exposes both personal business drives and organizational SharePoint libraries through a unified REST API under the `/v1.0/drives` endpoint hierarchy.

However, the authentication context dictates what rclone can discover. Personal accounts authenticate interactively through public client authorization. Enterprise accounts are governed by Microsoft Entra ID (formerly Azure Active Directory). In Microsoft Entra ID directories, administrators routinely restrict third-party consent, enforce conditional access policies, and block unauthorized third-party applications from requesting access to organizational data.

### Why Custom Entra ID Credentials Are Required

By default, rclone includes a built-in multi-tenant client ID to simplify initial configuration. Rclone uses a default client ID that is shared across all users when making requests to Microsoft OneDrive. In personal accounts, this default credential functions without intervention. In enterprise tenants, relying on this shared client ID introduces two severe operational problems:

1. **Conditional Access and Consent Blocking:** Enterprise Microsoft 365 tenants frequently disable user consent for unverified third-party multi-tenant applications. If an employee attempts to authenticate rclone using the default client ID, Entra ID rejects the authorization attempt with error `AADSTS65005` or blocks the sign-in under tenant conditional access policies. Shared default rclone client IDs are frequently blocked by Microsoft 365 tenant conditional access policies. Resolving this issue requires registering a custom single-tenant application within the organization's own Entra ID directory.
2. **Global API Throttling Contention:** Microsoft Graph enforces rate limits at both the application level and the tenant level. When many independent users worldwide initiate heavy file transfers using the default shared rclone client ID, Microsoft Graph applies global throttling to that application ID. Registering a dedicated client ID isolates your organization's API transaction budget from external traffic spikes.

## How to Register a Microsoft Entra ID Application for Rclone

To establish a reliable connection to OneDrive for Business or SharePoint Online, you must register a dedicated enterprise application in the Microsoft Entra admin center. This procedure assigns a dedicated client ID, generates an application secret, and defines the explicit Microsoft Graph permissions rclone requires.

### Step 1: Create the Application Registration

Begin by opening the Microsoft Entra admin center (`https://entra.microsoft.com/`) and signing in with an account holding administrative privileges or permissions to register applications.

1. In the left navigation pane, navigate to **Identity** > **Applications** > **App registrations**.
2. Select **New registration** at the top of the interface.
3. Enter a descriptive name for your application, such as `rclone-enterprise-sync`.
4. Under **Supported account types**, select **Accounts in this organizational directory only (Single tenant)**. Restricting the application to a single tenant aligns with corporate governance rules and prevents unverified publisher warnings.
5. In the **Redirect URI** section, select **Web** from the platform dropdown, then type the exact local loopback address: `http://localhost:53682/`. Rclone spins up a temporary local HTTP listener on this port during interactive authorization to capture the returned authorization code.
6. Select **Register** to create the application object.

Once the registration completes, the overview page displays critical identifiers. Copy the **Application (client) ID** and the **Directory (tenant) ID** to a secure note. You will enter both values during the rclone configuration workflow.

### Step 2: Generate a Client Secret

Rclone requires a client secret to exchange authorization codes for access tokens and to refresh expired tokens headlessly.

1. In the application sidebar under **Manage**, select **Certificates & secrets**.
2. Select **New client secret**.
3. Provide a clear description, such as `rclone-production-secret`, and choose an expiration period (for example, 24 months).
4. Select **Add**.
5. Immediately copy the string in the **Value** column. Entra ID masks this secret permanently once you navigate away from the panel.

### Step 3: Configure Microsoft Graph API Permissions

Next, define the granular scopes that allow rclone to read and write files within your Microsoft 365 tenant.

1. Under **Manage**, select **API permissions**.
2. Select **Add a permission**, then select **Microsoft Graph**.
3. Choose **Delegated permissions** for configurations where rclone acts on behalf of an authorized user account.
4. Search for and select the following permissions:
   - `Files.ReadWrite.All`: Permits rclone to read, update, create, and delete files in all accessible drives.
   - `Sites.Read.All`: Allows rclone to search and enumerate SharePoint site collections and document libraries.
   - `User.Read`: Enables rclone to inspect the signed-in user's profile to resolve personal drive endpoints.
   - `offline_access`: Grants refresh tokens so rclone can maintain continuous access without requiring repeated interactive browser logins.
5. Select **Add permissions**.
6. At the top of the Configured permissions table, select **Grant admin consent for <Your Organization>**. Confirm the prompt. Granting admin consent pre-authorizes the application for organizational users, bypassing individual consent blocks.

### Application Permissions for Headless Daemons

If your backup architecture operates without any interactive user context (such as an automated nightly server daemon or CI/CD container), you can configure **Application permissions** instead of delegated permissions.

In the API permissions interface, select **Application permissions** and assign `Files.Read.All` and `Sites.Read.All` (or `Sites.Selected` for tightly scoped site access). With application permissions, rclone uses the OAuth client credentials flow. In the rclone configuration, you set `client_credentials = true` and provide the tenant ID. When using client credentials, you must provide explicit `drive_id` strings for target libraries because the `/me/drive` user endpoint is unavailable in an app-only context.

## How to Configure Rclone for OneDrive Business and SharePoint

With the Entra ID application registered, you can configure your rclone remote. You can complete configuration through the interactive terminal wizard or by generating a headless token on a desktop machine and transferring it to a remote Linux server.

### Numbered Setup Guide for OneDrive for Business

Follow these steps in your terminal to create the remote using `rclone config`:

1. Launch the interactive configuration utility:
  

```bash
   rclone config
  

```
2. Type `n` to create a new remote, and enter a name (for example, `m365_business`).
3. When prompted for the storage backend type, type `onedrive` or choose the corresponding menu number.
4. At the `client_id>` prompt, paste the **Application (client) ID** generated in your Entra ID portal.
5. At the `client_secret>` prompt, paste the **Client Secret Value**.
6. When asked `Edit advanced config? (y/n)`, type `y` to review enterprise options:
   - At the `region>` prompt, select `global` (Microsoft Cloud Global) unless your organization operates in a sovereign cloud such as US Government (`us`) or China (`cn`).
   - At the `tenant>` prompt, enter the **Directory (tenant) ID** of your organization.
   - Leave other advanced options at their defaults by pressing Enter until you reach the remote config prompt.
7. At the `Use web browser to automatically authenticate rclone with remote?` prompt:
   - If running on a local desktop with an available web browser, type `y`.
   - If running on a remote headless server without a graphical browser, type `n`.
8. Complete the authentication flow:
   - **Local Browser:** The system browser opens automatically to `http://localhost:53682/`. Sign in with your corporate Microsoft 365 credentials and accept the permissions prompt.
   - **Headless Authorization:** On a separate workstation with rclone and a browser installed, run:
    

```bash
     rclone authorize "onedrive" "<client_id>" "<client_secret>"
    

```
     Authenticate in the browser, copy the resulting JSON token block from the terminal, and paste it into the headless server prompt.
9. Choose the drive type when rclone queries Microsoft Graph:
  

```text
   Choose a number from below, or type in an existing value
    1 / OneDrive Personal or Business
      \ "onedrive"
    2 / Sharepoint site
      \ "sharepoint"
    3 / Type in driveID
      \ "driveid"
    4 / Type in SiteID
      \ "siteid"
    5 / Search a Sharepoint site
      \ "search"
  

```
   To connect to your personal business drive, type `1`. Rclone queries the account, displays your drive ID (prefixed with `b!`), and reports drive type `business`.
10. Confirm the discovered drive by typing `y`, review the configuration summary, and type `y` to save the remote.

### Connecting to SharePoint Document Libraries

To target an organizational SharePoint document library rather than a user's personal OneDrive, select option `2` (`sharepoint`) or option `5` (`search`) during step 9.

When you select `search`, rclone prompts for a site query string. Enter the name of your SharePoint site (for example, `Engineering`). Rclone queries the Microsoft Graph search endpoint:

```text
Enter a string to search with.
search> Engineering
Found 1 sites, please select the one you want to use:
0: Engineering (https://yourcompany.sharepoint.com/sites/Engineering)
Chose site to use:> 0
```

After selecting the site, rclone enumerates the document libraries provisioned within that site collection:

```text
Found 2 drives, please select the one you want to use:
0: Documents (documentLibrary) id=b!XyZ...
1: Architecture Assets (documentLibrary) id=b!AbC...
Chose drive to use:> 0
```

Select the desired document library. Rclone saves the specific `drive_id` and registers `drive_type = documentLibrary` in your configuration file.

### Validating Remote File Access

Verify the configuration by running directory listings against the new remote:

```bash
rclone lsd m365_business:
```

To list all files recursively within a specific folder:

```bash
rclone ls m365_business:Documents/Reports
```

Microsoft Graph returns directory trees through JSON responses. For files stored on OneDrive for Business and SharePoint, rclone calculates checksums using `QuickXorHash`, a proprietary non-cryptographic hash algorithm designed by Microsoft for file validation. You can verify local versus remote file integrity using the checksum command:

```bash
rclone check /path/to/local/data m365_business:Backup --checksum
```

## Optimizing FUSE Mount Parameters and Managing Graph API Throttling

Mounting OneDrive for Business or SharePoint as a local directory tree using `rclone mount` requires careful tuning. Cloud object storage does not behave like a local block device, and enterprise API limits quickly penalize aggressive file operations.

### Why Full VFS Caching Is Essential

When mounting Microsoft 365 storage over FUSE, configuring `--vfs-cache-mode full` is mandatory. The Microsoft Graph API does not support arbitrary in-place random writes or byte truncation on cloud objects. When applications open files for writing, modify byte offsets, or save complex document formats (such as Office `.docx` or `.xlsx` files), unbuffered FUSE mounts return immediate input/output errors.

With full VFS caching enabled, rclone stages files locally on disk as sparse files. Read requests stream the necessary chunks on demand, while write modifications land on the local SSD cache at full hardware speed. When the modifying application calls `close()` on the file descriptor and the writeback delay timer expires, rclone commits the complete file back to Microsoft Graph.

### Recommended Production Mount Command

The following command provides a stable configuration for mounting enterprise OneDrive and SharePoint repositories on Linux:

```bash
rclone mount m365_business: /mnt/onedrive \
  --vfs-cache-mode full \
  --vfs-cache-max-size 40G \
  --vfs-cache-max-age 24h \
  --vfs-read-chunk-size 32M \
  --vfs-read-chunk-size-limit 256M \
  --buffer-size 16M \
  --dir-cache-time 48h \
  --tpslimit 8 \
  --tpslimit-burst 8 \
  --transfers 2 \
  --user-agent "ISV|rclone.org|rclone/v1.68.0" \
  --allow-other
```

Key operational parameters include:

- `--vfs-cache-mode full`: Buffers all file reads and writes as local sparse files, providing full POSIX compatibility for local desktop applications and scripts.
- `--vfs-cache-max-size 40G`: Caps the local disk footprint of the cache directory. Rclone purges the least recently accessed files once this threshold is reached.
- `--dir-cache-time 48h`: Holds directory structure metadata in memory for two days, dramatically reducing listing requests against Microsoft Graph.
- `--tpslimit 8` and `--tpslimit-burst 8`: Restricts API call velocity to eight transactions per second to stay safely below Microsoft Graph throttling thresholds.
- `--transfers 2`: Limits concurrent file uploads to avoid lock contention on tenant document libraries.
- `--user-agent "ISV|rclone.org|rclone/v1.68.0"`: Formats the HTTP User-Agent string to match Microsoft's Independent Software Vendor (ISV) decoration guidelines, preventing automated blocks on SharePoint Online.

### Managing Microsoft Graph Throttling (HTTP 429)

Microsoft Graph enforces dynamic throttling limits across enterprise tenants during bulk sync. Throttling thresholds are computed per tenant and per application based on overall resource consumption. When throttling thresholds are exceeded, Microsoft Graph returns HTTP status code 429 and causes incoming requests to fail.

When a throttling threshold is triggered, Microsoft Graph includes a `Retry-After` header in the HTTP 429 response. This header specifies the exact number of seconds the client must pause before retrying the transaction.

Rclone automatically detects the `Retry-After` header and suspends requests for the requested interval before executing exponential backoff retries. However, continuous throttling severely degrades throughput. To prevent 429 errors from occurring:

1. Maintain low concurrency flags (`--transfers 2` or `--transfers 4`).
2. Avoid rapid recursive folder traversals without directory caching.
3. Use the `--fast-list` flag during batch synchronization commands to minimize total API requests, though be aware it increases local memory utilization.

### Automating the Mount with Linux systemd

To run the rclone mount as a persistent background service that recovers from server reboots, create a systemd unit file at `/etc/systemd/system/rclone-onedrive.service` using shell variables for section headers:

```bash
sudo bash -c '
u="Unit"
s="Service"
i="Install"
cat << EOF > /etc/systemd/system/rclone-onedrive.service
[$u]
Description=Rclone Mount OneDrive for Business
After=network-online.target
Wants=network-online.target

[$s]
Type=notify
ExecStart=/usr/bin/rclone mount m365_business: /mnt/onedrive \
  --config=/home/username/.config/rclone/rclone.conf \
  --vfs-cache-mode full \
  --vfs-cache-max-size 40G \
  --vfs-cache-max-age 24h \
  --vfs-read-chunk-size 32M \
  --vfs-read-chunk-size-limit 256M \
  --buffer-size 16M \
  --dir-cache-time 48h \
  --tpslimit 8 \
  --tpslimit-burst 8 \
  --transfers 2 \
  --user-agent "ISV|rclone.org|rclone/v1.68.0" \
  --allow-other
ExecStop=/bin/fusermount3 -u /mnt/onedrive
Restart=on-failure
RestartSec=10
User=username
Group=username

[$i]
WantedBy=multi-user.target
EOF
'
```

Reload systemd, enable the unit, and start the service:

```bash
sudo systemctl daemon-reload
sudo systemctl enable rclone-onedrive
sudo systemctl start rclone-onedrive
```

## Comparing Local FUSE Mounts to Remote Cloud Workspace Sync

Teams maintain their operational files in Dropbox, Google Drive, OneDrive, Box, or SharePoint. As autonomous AI agents (such as Claude Code, Cursor, Cline, or custom automation runtimes) become integral to daily engineering and operational workflows, developers often consider mounting existing OneDrive or SharePoint folders directly to host systems using rclone.

While an rclone FUSE mount provides an effective bridge for local command-line utilities, scaling file access across multiple AI agents exposes critical friction points.

### Operational Bottlenecks of FUSE Mounts in Agent Workflows

When autonomous agents interact with documents across a mounted filesystem, three architectural constraints appear:

1. **Host Storage Exhaustion:** AI agents indexing large repositories or inspecting document collections pull gigabytes of data across the FUSE mount, filling the host's local VFS cache. A single recursive search across an enterprise document library can exhaust available SSD storage, causing host out-of-memory or disk-full panics.
2. **Directory Traversal Latency:** When an agent inspects folder hierarchies or executes file search tools across an rclone mount, each traversal translates into dozens of sequential Microsoft Graph HTTP calls. High latency slows agent execution loops, wastes token contexts, and frequently triggers API call timeouts.
3. **Throttling under Parallel Agent Writes:** If multiple agents write outputs back to the mounted directory simultaneously, local writeback buffers attempt concurrent commits to Microsoft Graph. This parallel load triggers HTTP 429 throttling and creates file version conflicts within SharePoint document libraries.

### The Fastio Workspace Architecture

The modern path allows teams to keep their existing storage in OneDrive or SharePoint while syncing project folders into an intelligent Fastio workspace.

Instead of maintaining brittle local FUSE daemons, folders sync into a Fastio workspace (one-way or two-way, on a schedule or on demand; never continuous, live or real-time; SharePoint libraries sync through the OneDrive connector). The workspace manages cloud synchronization in the background without consuming host disk space or requiring local credential storage.

AI agents connect directly to the workspace through the remote Model Context Protocol server over Streamable HTTP:

- For Claude apps, Claude Cowork, and general MCP clients: `https://mcp.fast.io/mcp/tools`
- For coding agents in an IDE, terminal, or cloud sandbox (such as Claude Code, Cursor, Cline, or Devin): `https://mcp.fast.io/mcp/code`
- For ChatGPT and Codex custom servers: `https://mcp.fast.io/mcp/operations` (the Fastio plugin is preferred for both)

Instead of pulling full files or traversing entire folder trees over network mounts, agents execute targeted search tools against pre-indexed files. The workspace automatically indexes documents upon arrival, enabling hybrid search that combines full-text keywords, semantic embeddings, and metadata values.

In benchmark testing published in the [connector performance report](/benchmarks/), Fastio was measured the fastest and the lowest cost of the providers tested, with accuracy at parity. Every measured row is that provider's native connector in Claude Cowork; no row is a local stdio server, a Files-On-Demand stub or SharePoint, and SharePoint was not measured at all.

### Architectural Comparison

| Architectural Dimension | Local Rclone FUSE Mount | Direct Microsoft Graph API Connector | Fastio Cloud Workspace Sync |
| :--- | :--- | :--- | :--- |
| **Integration Layer** | Local kernel FUSE driver | Direct REST API tool calls | Remote MCP server over Streamable HTTP |
| **Retrieval Mechanism** | POSIX reads via local VFS disk cache | Sequential HTTP file downloads | Pre-indexed hybrid search (full-text and semantic) |
| **Host Storage Requirement** | High (sparse file cache on local SSD) | Moderate (runtime working directories) | Zero (cloud workspace indexed remotely) |
| **Concurrency Protection** | Local writeback delay; risk of overwrite | Custom retry loops required for 429 errors | Advisory per-file leases and full version history |
| **Rate Limit Exposure** | High during recursive directory scans | High under frequent agent tool calls | Isolated (agent queries run on indexed workspace) |

### Governance, Coordination, and Metadata Views

Managing enterprise files across teams and autonomous agents requires structured coordination, access controls, and data extraction.

To prevent agents from overwriting concurrent work, Fastio provides advisory per-file leases in workspace storage. Leases are acquired, heartbeated, and released through MCP actions:

- Call `lock-acquire` on the `storage_manage` tool to claim a file lease before initiating edits.
- Call `lock-release` on the `storage_manage` tool once edits are complete.
- Call `lock-status` on the `storage` tool to check whether another agent or human holds an active lease.

A file lock expires automatically unless it is heartbeated, preventing abandoned locks if an agent process terminates unexpectedly. Other members and agents can see who holds the lock. Advisory locks never grant exclusive write rights: concurrent writes both land, and version history preserves every version.

Every revision written by an agent or human is tracked in per-file version history. Team members can inspect diffs, verify changes, or restore earlier revisions without data loss.

For structured data extraction, [Metadata Views](/product/document-data-extraction/) turn workspace documents into a queryable, structured database. Users define desired extraction fields in natural language, and the system designs a typed schema supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time formats. Metadata Views process PDFs, images, spreadsheets, and scanned documents without manual OCR rules. Agents can create Views, trigger extraction, and query structured results via MCP actions, eliminating the need to parse raw files across network mounts.

Every workspace includes a detailed activity log that records actions taken by team members and autonomous agents. For event handling, agents can subscribe to the workspace events feed over WebSocket or long-poll connections, reacting immediately when files are uploaded, modified, or shared. Outbound webhooks do not ship.

When an autonomous agent finishes provisioning a project workspace, ownership transfer allows the agent account to transfer the organization to a human stakeholder via a claim link.

Monthly plans start with a 14-day free trial that requires a credit card. Subscription tiers include the Starter plan at `$9.99/mo` (with `3` seats, `250 GB` of storage, `5` workspaces, `100,000` credits, and `25 GB` maximum upload), the Business plan at `$49.99/mo` (with `10` seats, `5 TB` of storage, `50` workspaces, `600,000` credits, and `50 GB` maximum upload), and the Enterprise plan at `$199.99/mo` (with `30` seats included, extra seats `$1` a month each up to `200`, `25 TB` of storage, `200` workspaces, `3,000,000` credits, and `100 GB` maximum upload). Credits meter AI operations exclusively, with overage billed at `$10` per `100,000` credits. Storage beyond the plan is `$0.015` per GB a month and extra bandwidth `$0.04` per GB, billed in money. For complete plan details, visit the [pricing page](/pricing/).

## Frequently asked questions

### How do I configure rclone for OneDrive for Business?

To configure rclone for OneDrive for Business, register a custom single-tenant application in the Microsoft Entra admin center, configure Delegated Microsoft Graph permissions (Files.ReadWrite.All, Sites.Read.All, offline_access), and generate a client secret. Then run rclone config, create an onedrive remote, provide your custom client ID, secret, and tenant ID, authenticate via browser, and select drive type business.

### Why is rclone getting throttled on OneDrive for Business?

Rclone gets throttled on OneDrive for Business when request volume exceeds Microsoft Graph dynamic rate limits, returning an HTTP 429 Too Many Requests response with a Retry-After header. Throttling is commonly caused by high transfer concurrency, recursive directory listings, or using the default shared rclone client ID instead of a dedicated Entra ID application registration.

### How do I connect AI agents to OneDrive for Business files?

You can connect AI agents to OneDrive for Business files by syncing folders into a Fastio workspace using Cloud Sync. Fastio indexes files automatically for hybrid full-text and semantic search, allowing AI agents to query and retrieve documents via the remote Model Context Protocol server over Streamable HTTP without pulling full folder trees across local mounts.

### How do I target a SharePoint document library in rclone?

During rclone config under the onedrive backend, choose option 5 to search for a SharePoint site or option 2 to provide a site URL. Once the site collection is selected, rclone enumerates the document libraries within that site and saves the corresponding drive_id and documentLibrary drive type to your configuration.

### Why does rclone mount fail without full VFS caching on Microsoft 365?

Rclone mount fails without full VFS caching because Microsoft Graph does not support in-place random writes or byte truncation on cloud objects. Configuring --vfs-cache-mode full stages files locally on disk as sparse files, enabling POSIX-compliant random reads, seeks, and writes before committing the modified file back to Microsoft 365.

### Can Fastio import from Google Drive?

Yes. Fastio supports cloud import from Google Drive, preserving folder hierarchies while indexing documents for hybrid search. Two-way cloud sync currently supports Google Drive, Dropbox, Box, and OneDrive.

## Sources

- [Rclone: Microsoft OneDrive backend documentation](https://rclone.org/onedrive/): Rclone uses a default client ID that is shared across all users when making requests to Microsoft OneDrive.
- [Microsoft Learn: Microsoft Graph throttling guidance](https://learn.microsoft.com/en-us/graph/throttling): When throttling thresholds are exceeded, Microsoft Graph returns HTTP status code 429 and causes incoming requests to fail.

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