Google Drive: Multiple Accounts with rclone

What This Guide Achieves

Goal	Status
Access multiple Google Drive accounts on Linux	Done
Mount Google Drive as local folders (like Windows)	Done
GUI file browser for Google Drive	Done
Read and write access to all accounts	Done
Understand online-only vs cached vs fully offline files	Done
Reduce rclone browsing lag with VFS cache tuning	Done

Prerequisites

Any Ubuntu 24.04-based distro
Internet connection
A working web browser for Google OAuth authentication
rclone package (installed in the steps below)

The Problem (Windows User Perspective)

On Windows, you install “Google Drive for Desktop” and it mounts your Drive as a local drive letter. You can add multiple Google accounts and they all show up in File Explorer. On Linux, Google does not provide a native Drive client. There are several alternatives, each with trade-offs.

Your Options — Compared

Method	Cost	Offline Access	Multiple Accounts	GUI	Difficulty
GNOME Online Accounts (built-in)	Free	No, remote browsing only	Yes	Yes	Easy
rclone mount + VFS cache	Free	Only cached/opened files	Yes	File manager + optional GUI	Intermediate
rclone sync to local folders	Free	Yes, for synced folders	Yes	Local folders	Intermediate
Insync / overGrive	Paid	Yes	Yes	Yes	Easy

Option 1: GNOME Online Accounts (Quick Browse — No Sync)

This is already built into many GNOME-based Ubuntu distros, including the tested Zorin setup. Good for occasional file browsing, but files are not downloaded locally — you lose access when offline.

Open Settings → Online Accounts
Click Google → sign in with your first Gmail account
Repeat to add a second/third Google account
Open Files (Nautilus) → your Drives appear in the left sidebar

Limitation: This is basically a “read and browse” connection. Files are remote, not synced locally. GNOME Online Accounts can show multiple Google accounts in Files, but it does not give you a true offline folder. For heavy file work, large folders, or apps that dislike remote GVfs paths, rclone or a paid sync client is more predictable.

Option 2: rclone + Rclone UI (Recommended Free Mount)

This gives you the closest experience to a cloud drive client: local folder access, full read/write, multiple accounts, with a GUI frontend and system tray icon.

Step 1 — Install rclone

sudo apt update && sudo apt install rclone -y
rclone version  # verify installation

Step 2 — Create mount point folders

Decide where you want your Google Drive folders. For example, to put them at /media/mohsin/mmh/GoogleDrive/:

mkdir -p /media/mohsin/mmh/GoogleDrive/Main
mkdir -p /media/mohsin/mmh/GoogleDrive/Secondary
mkdir -p /media/mohsin/mmh/GoogleDrive/Third

Set ownership:

sudo chown -R $(whoami):$(whoami) /media/mohsin/mmh/GoogleDrive

Step 3 — Configure your first Google account

rclone config

Follow the interactive prompts:

n                  ← New remote
gdrive_main        ← Name (use something descriptive)
drive              ← Type: Google Drive
                   ← Client ID: leave blank (press Enter)
                   ← Client Secret: leave blank (press Enter)
1                  ← Scope: full access (read/write)
                   ← Root folder: leave blank (press Enter)
                   ← Service account: leave blank (press Enter)
n                  ← Advanced config? No
y                  ← Auto config? Yes

Your browser will open to Google’s login page. No password is stored by rclone — it uses OAuth2 (the same “Sign in with Google” mechanism websites use). Google gives rclone a secure token, not your password.

After signing in:

n                  ← Shared drive? No
y                  ← Confirm configuration
q                  ← Quit config

Step 4 — Repeat for additional accounts

Run rclone config again for each additional Google account. The prompts are identical — just use a different name each time:

rclone config
# n → New remote → name: gdrive_secondary → sign into second Google account
rclone config
# n → New remote → name: gdrive_third → sign into third Google account

After configuring, verify all remotes are registered:

rclone listremotes
# Expected: gdrive_main:, gdrive_secondary:, gdrive_third:

Step 5 — Create cache directories for each account

Rclone uses three types of data, all stored under one clean location:

/media/mohsin/mmh/rclone-cache/
├── vfs/         ← Mount cache (VFS disk buffers for file-on-demand)
│   ├── main/
│   ├── secondary/
│   └── third/
├── bisync/      ← Tracking metadata (not your files — internal state for two-way sync)
│   ├── main/
│   └── secondary/
└── offline/     ← Bisync output — your offline folders live here
    ├── main/
    └── secondary/

mkdir -p /media/mohsin/mmh/rclone-cache/vfs/main
mkdir -p /media/mohsin/mmh/rclone-cache/vfs/secondary
mkdir -p /media/mohsin/mmh/rclone-cache/vfs/third

Step 6 — Test mounts manually

rclone mount gdrive_main: /media/mohsin/mmh/GoogleDrive/Main --daemon --vfs-cache-mode full
rclone mount gdrive_secondary: /media/mohsin/mmh/GoogleDrive/Secondary --daemon --vfs-cache-mode full
rclone mount gdrive_third: /media/mohsin/mmh/GoogleDrive/Third --daemon --vfs-cache-mode full

Open your file manager — navigate to /media/mohsin/mmh/GoogleDrive/ and you should see all three accounts with your files.

The --vfs-cache-mode full flag enables local VFS caching. It does not make the whole Drive offline. Files are still online-first. A file becomes local only after rclone has read or written it, and the cache can expire or be cleaned. For real offline access, use the sync section later in this guide.

How rclone Compares to Dropbox, MEGA, and pCloud

Feature	Dropbox	MEGA	pCloud	rclone mount	rclone bisync
File-on-demand (stream on open)	No (full copy)	Yes (selective)	Yes (FUSE)	Yes	No (full copy)
Two-way sync	Yes	Yes	Yes	Yes (via mount)	Yes
Offline access	Yes (all files)	Only synced folders	Only cached files	Only cached files	Yes (synced folders)
Overlay icons in Nemo	Yes (nemo-dropbox)	Yes (nemo-megasync)	No (FUSE)	No (FUSE limitation)	No
Right-click menu in Nemo	Yes	Yes	No	No (FUSE limitation)	No
System tray with status	Yes	Yes	Yes	Via Rclone UI	Via Rclone UI
Custom sync directory	Symlink	Symlink or sync pairs	FUSE path	Any path (mount point)	Any path
Free tier	2 GB	20 GB	10 GB	15 GB per Google account	15 GB per account

The two honest gaps: Overlay icons (sync status badges) and right-click context menus are not possible with FUSE-based mounts. This is a filesystem limitation, not an rclone limitation. Nemo bookmark (Ctrl+D) is the practical workaround for sidebar access.

This distinction matters. If you browse a folder for the first time, rclone still has to ask Google Drive for the folder listing and metadata. Fast internet helps, but it does not remove API latency. After the first browse, cached listings make subsequent access fast.

Step 7 — Install Rclone UI (GUI + System Tray)

Rclone UI is an actively maintained, cross-platform GUI for rclone (2,000+ GitHub stars). It provides a visual file browser, system tray icon, and mount manager — much closer to the Dropbox/MEGA desktop experience.

Install the pre-built .deb package:

cd ~/Downloads
wget https://get.rcloneui.com/linux-deb -O rclone-ui.deb
sudo apt install ./rclone-ui.deb

After installation, Rclone UI appears in your app menu and system tray. It:

Shows all configured rclone remotes with a file browser
Manages mounts from the GUI (no terminal needed after setup)
Provides a tray icon for quick access to mount status
Supports mounting with VFS cache flags through its settings

Alternative — Flatpak: flatpak install flathub com.rcloneui.RcloneUI

Note: rclone (the CLI engine) must stay installed — Rclone UI is a GUI frontend that calls rclone behind the scenes.

The mount command gives you file-on-demand access — files download when you open them from Nemo, similar to how MEGA’s virtual drive and pCloud Drive work. Changes you make in Nemo propagate back to Google Drive automatically.

Simplified mount command (good defaults for most users):

rclone mount gdrive_main: /media/mohsin/mmh/GoogleDrive/Main \
  --daemon \
  --vfs-cache-mode full \
  --vfs-cache-max-age 48h \
  --dir-cache-time 72h

Flag	What it does
`--vfs-cache-mode full`	Downloads files to disk cache when you open them; writes go through the cache
`--vfs-cache-max-age 48h`	Keeps cached file data for 48 hours after last access
`--dir-cache-time 72h`	Remembers folder listings for 3 days (faster repeated browsing)

Performance note: First-time folder browsing may feel slower than Dropbox/MEGA because rclone fetches directory listings from Google’s API on demand. After the first browse, cached listings make subsequent access instant.

Auto-mount on login via systemd (reliable, auto-remounts on failure):

Create a systemd user service:

mkdir -p ~/.config/systemd/user
nano ~/.config/systemd/user/rclone-gdrive.service

[Unit]
Description=Mount Google Drive via rclone
After=network-online.target
Wants=network-online.target
RequiresMountsFor=/media/mohsin/mmh

[Service]
Type=forking
ExecStartPre=-/bin/fusermount -u /media/mohsin/mmh/GoogleDrive/Main
ExecStart=/usr/bin/rclone mount gdrive_main: /media/mohsin/mmh/GoogleDrive/Main --daemon --vfs-cache-mode full --vfs-cache-max-age 48h --dir-cache-time 72h --cache-dir /media/mohsin/mmh/rclone-cache/vfs/main
ExecStop=/bin/fusermount -u /media/mohsin/mmh/GoogleDrive/Main
Restart=on-failure
RestartSec=10

[Install]
WantedBy=default.target

Enable and start:

systemctl --user daemon-reload
systemctl --user enable --now rclone-gdrive.service
systemctl --user status rclone-gdrive

Step 9 — Adding More Accounts

Copy the service file for each additional account, changing only the remote name and mount path:

# Secondary account
cp ~/.config/systemd/user/rclone-gdrive.service ~/.config/systemd/user/rclone-gdrive-secondary.service
sed -i 's/gdrive_main:/gdrive_secondary:/' ~/.config/systemd/user/rclone-gdrive-secondary.service
sed -i 's|GoogleDrive/Main|GoogleDrive/Secondary|' ~/.config/systemd/user/rclone-gdrive-secondary.service
sed -i 's|rclone-cache/main|rclone-cache/secondary|' ~/.config/systemd/user/rclone-gdrive-secondary.service
sed -i 's|Mount Google Drive via rclone|Mount Google Drive Secondary via rclone|' ~/.config/systemd/user/rclone-gdrive-secondary.service

Enable and start:

systemctl --user daemon-reload
systemctl --user enable --now rclone-gdrive-secondary.service

Repeat the same pattern for gdrive_third — change secondary to third in the commands above.

Verify all mounts:

systemctl --user status rclone-gdrive rclone-gdrive-secondary --no-pager -n 0
ls /media/mohsin/mmh/GoogleDrive/Main | wc -l
ls /media/mohsin/mmh/GoogleDrive/Secondary | wc -l

Why systemd over a startup script:

Type=forking — rclone uses --daemon which forks to the background. This tells systemd to expect the fork so it doesn’t kill the mount thinking it crashed
RequiresMountsFor= — waits until the target partition is mounted before starting rclone (prevents “Transport endpoint is not connected” errors after reboot)
Auto-restart on failure — If the mount breaks after suspend or network drop, systemd restarts it within 10 seconds
Proper shutdown — ExecStop unmounts cleanly when you log out
--enable for persistence — Runs at every login without a .desktop file in autostart

Add Nemo sidebar bookmark for quick access:

Open Nemo → navigate to /media/mohsin/mmh/GoogleDrive/
Press Ctrl+D (or drag the folder to the left sidebar)
Your Google Drive folders now appear in Nemo’s sidebar like Dropbox and MEGA

Step 10 — Tuning VFS Cache for Heavy Use (Optional)

The simplified mount command above works well for most users. If you browse large folders frequently or work with big files, add these flags:

rclone mount gdrive_main: /media/mohsin/mmh/GoogleDrive/Main \
  --daemon \
  --vfs-cache-mode full \
  --vfs-cache-max-age 48h \
  --vfs-cache-max-size 10G \
  --cache-dir /media/mohsin/mmh/rclone-cache/vfs/main \
  --vfs-read-ahead 128M \
  --dir-cache-time 72h \
  --poll-interval 15s \
  --transfers 16 \
  --buffer-size 256M \
  --drive-chunk-size 128M

Extra Flag	Why It Helps
`--vfs-cache-max-size 10G`	Caps cache so it cannot grow forever (10 GB per account)
`--cache-dir /media/mohsin/mmh/rclone-cache/...`	Moves cache to your large data partition instead of filling `/home`
`--vfs-read-ahead 128M`	Reads ahead when streaming larger files
`--poll-interval 15s`	Checks Google Drive for remote changes every 15 seconds
`--transfers 16`	Allows more parallel download/upload operations
`--buffer-size 256M`	Larger memory buffer per open file (reduce to 64M if RAM is under pressure)

Create the cache directories:

mkdir -p /media/mohsin/mmh/rclone-cache/vfs/main
mkdir -p /media/mohsin/mmh/rclone-cache/vfs/secondary
mkdir -p /media/mohsin/mmh/rclone-cache/vfs/third

Resource note: --buffer-size 256M is per open file. With 16 transfers and a few open files, RAM use can add up. If your system feels heavy, dial things back to --buffer-size 64M --transfers 8.

If Mount Fails (Already Mounted)

fusermount -u /media/mohsin/mmh/GoogleDrive/Main

The systemd service includes this as ExecStartPre so you rarely need to run it manually.

Option 2B: True Two-Way Sync with `rclone bisync`

The mount gives you file-on-demand access (like MEGA’s virtual drive). For folders you want always available offline with two-way sync — like Dropbox sync pairs — use rclone bisync. Changes made locally upload to Google Drive; changes made in Google Drive download to your local copy. All bisync output lives under rclone-cache/offline/, keeping your partition clean.

Step 1 — Create offline + workdir directories

Decide which folders you want offline. For the tested setup, 4 folders across 2 accounts:

Account	Google Drive Folder	Offline Path	Workdir Path
gdrive_main	Higher Study	`offline/main/Higher Study`	`bisync/main/Higher Study`
gdrive_main	Documents	`offline/main/Documents`	`bisync/main/Documents`
gdrive_secondary	Data Analysis	`offline/secondary/Data Analysis`	`bisync/secondary/Data Analysis`
gdrive_secondary	Econ	`offline/secondary/Econ`	`bisync/secondary/Econ`

# Create offline output dirs (your files go here)
mkdir -p /media/mohsin/mmh/rclone-cache/offline/main/Higher\ Study
mkdir -p /media/mohsin/mmh/rclone-cache/offline/main/Documents
mkdir -p /media/mohsin/mmh/rclone-cache/offline/secondary/Data\ Analysis
mkdir -p /media/mohsin/mmh/rclone-cache/offline/secondary/Econ

# Create bisync workdirs (internal tracking — NOT your files)
mkdir -p /media/mohsin/mmh/rclone-cache/bisync/main/Higher\ Study
mkdir -p /media/mohsin/mmh/rclone-cache/bisync/main/Documents
mkdir -p /media/mohsin/mmh/rclone-cache/bisync/secondary/Data\ Analysis
mkdir -p /media/mohsin/mmh/rclone-cache/bisync/secondary/Econ

Step 2 — Initial download with `rclone copy`

Bisync’s --resync can be slow for large folders (it enumerates the remote over the API). Instead, do the initial download with rclone copy first — it’s faster and can resume:

rclone copy "gdrive_main:Higher Study" \
  "/media/mohsin/mmh/rclone-cache/offline/main/Higher Study" \
  --update --transfers 8

rclone copy "gdrive_main:Documents" \
  "/media/mohsin/mmh/rclone-cache/offline/main/Documents" \
  --update --transfers 8

rclone copy "gdrive_secondary:Data Analysis" \
  "/media/mohsin/mmh/rclone-cache/offline/secondary/Data Analysis" \
  --update --transfers 8

rclone copy "gdrive_secondary:Econ" \
  "/media/mohsin/mmh/rclone-cache/offline/secondary/Econ" \
  --update --transfers 8

Warning: Check folder size with rclone size "remote:foldername" before running rclone copy. The initial download fetches the entire folder — a 5 GB folder over mobile data can exhaust your data plan in minutes. Only run Step 2 on WiFi. Once the initial copy is done, the 10-minute bisync cron only transfers changed files (kilobytes, not gigabytes).

Step 3 — Initialize bisync tracking (one-time, with `--resync`)

Now that files are already downloaded, --resync only needs to compare and create tracking state:

rclone bisync "gdrive_main:Higher Study" "/media/mohsin/mmh/rclone-cache/offline/main/Higher Study" --resync --workdir "/media/mohsin/mmh/rclone-cache/bisync/main/Higher Study"
rclone bisync "gdrive_main:Documents" "/media/mohsin/mmh/rclone-cache/offline/main/Documents" --resync --workdir "/media/mohsin/mmh/rclone-cache/bisync/main/Documents"
rclone bisync "gdrive_secondary:Data Analysis" "/media/mohsin/mmh/rclone-cache/offline/secondary/Data Analysis" --resync --workdir "/media/mohsin/mmh/rclone-cache/bisync/secondary/Data Analysis"
rclone bisync "gdrive_secondary:Econ" "/media/mohsin/mmh/rclone-cache/offline/secondary/Econ" --resync --workdir "/media/mohsin/mmh/rclone-cache/bisync/secondary/Econ"

Flag	Purpose
`--workdir`	Where bisync stores tracking state (`.lst` files comparing modification times). Use a separate dir per folder.
`--resync`	Required on first run. Tells bisync to trust the remote as the baseline.

Critical: Remove --resync from all subsequent bisync runs. With --resync, bisync overwrites local changes with the remote state. Without it, bisync propagates changes in both directions — the two-way sync you want.

Step 4 — Wrapper script for cron

One script runs all bisync jobs. Cron calls the script — cleaner than 4 raw cron lines:

cat > ~/.local/bin/rclone-bisync-all.sh << 'EOF'
#!/bin/bash
exec 1>/tmp/rclone-bisync.log 2>&1
echo "=== $(date) ==="

rclone bisync "gdrive_main:Higher Study" "/media/mohsin/mmh/rclone-cache/offline/main/Higher Study" --workdir "/media/mohsin/mmh/rclone-cache/bisync/main/Higher Study"
rclone bisync "gdrive_main:Documents" "/media/mohsin/mmh/rclone-cache/offline/main/Documents" --workdir "/media/mohsin/mmh/rclone-cache/bisync/main/Documents"
rclone bisync "gdrive_secondary:Data Analysis" "/media/mohsin/mmh/rclone-cache/offline/secondary/Data Analysis" --workdir "/media/mohsin/mmh/rclone-cache/bisync/secondary/Data Analysis"
rclone bisync "gdrive_secondary:Econ" "/media/mohsin/mmh/rclone-cache/offline/secondary/Econ" --workdir "/media/mohsin/mmh/rclone-cache/bisync/secondary/Econ"

echo "=== done ==="
EOF
chmod +x ~/.local/bin/rclone-bisync-all.sh

Note: the exec 1>/tmp/rclone-bisync.log 2>&1 line redirects all output to a log file. Check it anytime with tail /tmp/rclone-bisync.log.

Step 5 — Schedule with cron

crontab -e

Add:

*/10 * * * * /home/mohsin/.local/bin/rclone-bisync-all.sh

This runs every 10 minutes. Google Drive has effectively unlimited API calls — 4 folders × 6 runs/hour = 24 calls/hour is far below any limit. You can reduce to */5 (5 min) or increase to */30 (30 min) depending on how quickly you need changes to propagate.

To add or remove a folder later: edit the wrapper script, not cron.

Where to access your files (Nemo)

Open Nemo → navigate to /media/mohsin/mmh/rclone-cache/offline/ → press Ctrl+D to bookmark. Your offline folders appear in the sidebar alongside Dropbox and MEGA.

What bisync does NOT handle

Conflicts — If the same file changes on both sides between syncs, bisync flags it. Resolve manually.
Lock files — If a bisync run is interrupted (Ctrl+C, timeout), lock files remain in the workdir. Remove them before retrying: rm /media/mohsin/mmh/rclone-cache/bisync/*/*/*.lck
Large initial downloads — Use rclone copy first (Step 2), then bisync. This is faster and avoids API timeout on large folders.

Option 3: Insync (Paid — Easiest)

If you want a Windows-like experience without any terminal work:

Go to https://www.insynchq.com/downloads
Download the .deb file for Ubuntu-based
Install: sudo dpkg -i ~/Downloads/insync*.deb
Open Insync from your app menu
Sign into each Google account through the GUI

Insync costs ~$30 per account (one-time purchase). It sits in your system tray, shows sync status on files, and supports drag-and-drop — the closest thing to Windows Google Drive on Linux.

Other Paid Sync Clients

Another common option is overGrive, a paid Google Drive client for Linux. The general tradeoff is the same as Insync: easier GUI setup and local sync, but you rely on a third-party paid client.

For this guide, rclone remains the documented tested path because it is free, scriptable, supports multiple accounts, and can be tuned or synced exactly where you want.

What Didn’t Work (and Why)

Approach Tried	Why It Failed
GNOME Online Accounts for full sync	Only streams files — no offline access, can’t open in apps reliably
Expecting `--vfs-cache-mode full` to make all files offline	It only caches files rclone actually reads or writes. Unopened files remain remote.
Using `--allow-non-empty` as the normal fix for “directory already mounted”	It hides stale mount problems. Unmount first, then remount cleanly.
Using `rclone sync` for two-way sync	`rclone sync` is one-directional (source → dest). Use `rclone bisync` for true two-way sync.
Running rclone config from a non-bash shell	Some prompts behave differently in non-bash shells

Authentication — How It Works

rclone uses OAuth2 for Google Drive authentication:

Question	Answer
Does rclone see your password?	No, never
Where do you log in?	Google’s own website in your browser
What gets saved?	A secure token (like a key card), stored in `~/.config/rclone/rclone.conf`
Does the token expire?	Rarely — Google refreshes it automatically

Verification

# List configured remotes
rclone listremotes
# Expected: gdrive_main: gdrive_secondary: gdrive_third:

# Check a remote is accessible
rclone ls gdrive_main: --max-depth 1

# Verify mount points
ls /media/mohsin/mmh/GoogleDrive/Main
ls /media/mohsin/mmh/GoogleDrive/Secondary
ls /media/mohsin/mmh/GoogleDrive/Third

# Verify cache folders
du -sh /media/mohsin/mmh/rclone-cache/* 2>/dev/null

Troubleshooting

Symptom	Cause	Fix
Browser doesn’t open during `rclone config`	No default browser set	Run `xdg-settings set default-web-browser firefox.desktop`
Mount fails with FUSE error	libfuse2 not installed	`sudo apt install libfuse2`
Files not appearing after mount	Cache needs time to populate	Wait a minute, then check again
”Transport endpoint is not connected”	rclone mount crashed	`fusermount -u /media/mohsin/mmh/GoogleDrive/Main` then remount
`directory already mounted` error	The mount point is still active from an earlier run	`fusermount -u /media/mohsin/mmh/GoogleDrive/Main` then rerun the systemd service
Browsing folders is still slow the first time	rclone has to fetch directory listings from Google Drive	Wait for cache to populate, or use `rclone bisync` to pre-copy important folders
Cached files use too much disk	Cache cap is too high or several accounts are active	Reduce `--vfs-cache-max-size` or delete `/media/mohsin/mmh/rclone-cache/*` after unmounting
Need files while fully offline	Mount cache is not a full offline copy	Use `rclone bisync` for those folders
bisync reports conflicts	Same file changed on both sides since last sync	Resolve manually; avoid editing the same file on both sides between sync intervals

Unmounting and Complete Removal

# Stop systemd services
systemctl --user disable --now rclone-gdrive.service

# Unmount all drives
fusermount -u /media/mohsin/mmh/GoogleDrive/Main 2>/dev/null
fusermount -u /media/mohsin/mmh/GoogleDrive/Secondary 2>/dev/null
fusermount -u /media/mohsin/mmh/GoogleDrive/Third 2>/dev/null

# Remove rclone config (deletes all saved tokens)
rm ~/.config/rclone/rclone.conf

# Remove rclone
sudo apt remove rclone

# Remove Rclone UI
sudo apt remove rclone-ui

# Remove mount directories
rm -rf /media/mohsin/mmh/GoogleDrive

# Remove systemd user service files
rm ~/.config/systemd/user/rclone-gdrive*.service
systemctl --user daemon-reload

# Remove VFS cache folders
rm -rf /media/mohsin/mmh/rclone-cache

# Remove synced offline copies if you created them
# rm -rf /media/mohsin/mmh/GoogleDrive/Sync

Dropbox: Custom Install Directory — Headless Dropbox with custom location
Filesystem Hierarchy — Understanding mount points and file locations
Common Issues — FAQ for common problems