Obsidian LiveSync: Self-Hosted Sync Without Paying for the Privilege

$10 a Month to Sync Markdown Files Is a Bit Rich, Honestly

Look, Obsidian is great software. Truly. The team deserves to eat. But at $10/month for sync, you’re paying more than you probably do for most SaaS tools just to move some .md files between devices. Files you already own. Files that live in a folder on your computer.

Here’s the thing: Obsidian has a plugin ecosystem, and one of those plugins — Self-hosted LiveSync — does everything the official sync does, runs on your own infrastructure, and costs you nothing beyond the electricity to run a Docker container. Let’s set it up.

What LiveSync Actually Is

LiveSync is a community plugin for Obsidian that syncs your vault using CouchDB as the backend. CouchDB is a document database with built-in replication — it’s genuinely well-suited for this use case. Your vault notes become CouchDB documents, and the plugin keeps every device in sync in near real-time.

Features you get:

End-to-end encryption (passphrase-based, client-side)
Conflict detection and resolution UI
Works across desktop and mobile (iOS and Android)
Selective sync and per-folder exclusions
Live sync or scheduled batch sync

What you’re giving up compared to official sync: Obsidian’s polish and the knowledge that someone else is paging at 3 AM if it breaks. That’s it.

Spinning Up CouchDB with Docker Compose

Your self-hosted backend is one Compose file away. Create a directory, drop this in:

# docker-compose.yml
version: "3.8"
services:
  couchdb:
    image: couchdb:3.3
    container_name: obsidian-couchdb
    restart: unless-stopped
    environment:
      COUCHDB_USER: admin
      COUCHDB_PASSWORD: changeme_use_a_real_password
    volumes:
      - ./couchdb-data:/opt/couchdb/data
      - ./couchdb-config:/opt/couchdb/etc/local.d
    ports:
      - "5984:5984"

docker compose up -d

Now visit http://your-server:5984/_utils — that’s the Fauxton admin UI. Log in with your credentials.

Create the database

You can do this through Fauxton or via curl:

curl -X PUT http://admin:yourpassword@localhost:5984/obsidian-vault \
  -H "Content-Type: application/json"

Name the database whatever you want — you’ll reference it in the plugin config.

CORS configuration (required)

CouchDB needs CORS enabled for the browser/desktop client to connect:

# Enable CORS
curl -X PUT http://admin:yourpassword@localhost:5984/_node/_local/_config/httpd/enable_cors \
  -d '"true"'

# Allow all origins (tighten this down in production)
curl -X PUT http://admin:yourpassword@localhost:5984/_node/_local/_config/cors/origins \
  -d '"*"'

curl -X PUT http://admin:yourpassword@localhost:5984/_node/_local/_config/cors/credentials \
  -d '"true"'

curl -X PUT http://admin:yourpassword@localhost:5984/_node/_local/_config/cors/methods \
  -d '"GET, PUT, POST, HEAD, DELETE"'

curl -X PUT http://admin:yourpassword@localhost:5984/_node/_local/_config/cors/headers \
  -d '"accept, authorization, content-type, origin, referer"'

Or add a local.ini in your couchdb-config volume:

[httpd]
enable_cors = true

[cors]
origins = *
credentials = true
methods = GET, PUT, POST, HEAD, DELETE
headers = accept, authorization, content-type, origin, referer

Putting It Behind a Reverse Proxy

Don’t expose CouchDB directly on port 5984 to the internet. Put it behind Caddy or Nginx with TLS. Here’s a quick Caddy snippet:

couch.yourdomain.com {
    reverse_proxy localhost:5984
}

Caddy handles cert renewal automatically. With Nginx you’ll need Certbot or similar. Either way: HTTPS is non-negotiable if you’re syncing from outside your home network.

Installing and Configuring the Plugin

In Obsidian, open Settings → Community plugins → Browse → search “Self-hosted LiveSync” → Install → Enable.

Go to the plugin settings. The setup wizard is actually decent, but here’s what matters:

Remote Database Settings:

URI: https://couch.yourdomain.com (your reverse proxy URL)
Username: admin
Password: your CouchDB password
Database name: obsidian-vault (whatever you named it)

Sync Settings:

Sync Mode: LiveSync for real-time, Periodic and on-open if you want less CPU churn
Batch size: 25 (default is fine for most vaults)

End-to-End Encryption:

Enable: yes, absolutely
Passphrase: use a long random string, store it somewhere safe (your Vaultwarden instance, perhaps)

This passphrase encrypts your notes before they hit CouchDB. The server never sees plaintext. If you lose the passphrase, you lose access to your data — same trade-off as every encryption scheme ever.

Click “Test database connection” — you should see green. Then “Check and fix” to initialize the database structure.

Conflict Handling: The Part Nobody Talks About

Edit the same note on two devices while offline, then come back online — you’ve got a conflict. CouchDB tracks both versions. LiveSync surfaces this in Obsidian as a notification.

When you open a conflicted note, the plugin shows you both versions and lets you choose which to keep or manually merge. It’s not pretty, but it works. The advice: keep sync mode as LiveSync rather than batch sync if you edit heavily across devices — fewer opportunities for conflicts to accumulate.

Performance with Large Vaults

Got 50,000 notes? (Respect, but also: why?) The initial sync will take a while — potentially hours for very large vaults. After that, incremental sync is fast.

Tweaks for big vaults:

Increase Batch size to 50-100
Enable Use transfer limit to avoid hammering CouchDB on sync
Consider excluding large attachment folders (images, PDFs) from LiveSync and handling them separately with Syncthing

Speaking of which…

The Syncthing Alternative

If you just want files synced without a database backend, Syncthing is another valid path. It syncs your vault folder directly, no plugin needed, P2P encrypted.

Downsides vs LiveSync:

No conflict resolution UI in Obsidian — you get note (conflict copy).md files
Mobile support requires the Möbius Sync app on iOS ($)
No encryption at rest on the sync server — just in transit

If your vault is simple and you don’t edit on mobile much, Syncthing is honestly less complexity. LiveSync shines when you’re actively editing across phone, tablet, and desktop.

Backup Strategy: Don’t Trust Sync as Backup

Sync is not backup. Say it with me. If you accidentally delete your entire vault, LiveSync will helpfully delete it everywhere else too.

Backup your CouchDB data:

# Dump CouchDB database to JSON
curl -X GET http://admin:yourpassword@localhost:5984/obsidian-vault/_all_docs?include_docs=true \
  > vault-backup-$(date +%Y%m%d).json

Or just back up the Docker volume at the filesystem level with your existing backup tool (Restic, Borg, whatever you’re using). The couchdb-data directory is the source of truth.

Also keep a plain filesystem backup of your vault folder on at least one device. Belt and suspenders.

The Verdict

Official Obsidian Sync makes sense if you want zero maintenance, support, and polish. It’s good software.

LiveSync makes sense if you’re already running a homelab, value data ownership, or simply refuse to pay a subscription for something you can host yourself in 20 minutes. The setup is a one-time investment. After that, it just runs.

The encryption is solid, the conflict resolution is workable, and CouchDB is genuinely reliable for this use case. Your notes, your server, your rules.

Your 2 AM self won’t be paged. And if they are, at least it’s your server failing, not someone else’s.