Self-Hosting Seafile: High-Performance File Sync (Nextcloud Alternative)

Nextcloud does everything. That’s its greatest strength and its biggest weakness.

If you’ve ever watched Nextcloud grind to a halt syncing 50,000 files, or spent a weekend debugging a broken upgrade, you already know what I mean. Seafile takes the opposite approach: do file sync extraordinarily well, and leave everything else to other tools.

Seafile is an open-source file hosting platform built on a custom storage engine inspired by Git’s data model. Files are split into blocks, deduplicated, and delta-synced — which makes it dramatically faster than WebDAV-based alternatives for large file collections. It’s been around since 2012, is written in C and Python, and is battle-tested at universities and enterprises with millions of files.

Seafile vs Alternatives

Choose Seafile when you need reliable, fast file sync for large libraries. Choose Nextcloud when you want an all-in-one platform (calendar, contacts, email, etc.). Choose Syncthing when you want serverless P2P sync.

Prerequisites

• Docker and Docker Compose installed
• A domain name pointed at your server (for HTTPS)
• Reverse proxy (Caddy, Nginx, or Traefik) — see our reverse proxy comparison
• At least 1GB RAM (2GB+ recommended for online editing)
• Storage space for your files

Docker Compose Setup

Seafile’s official Docker image bundles everything cleanly. Create your project directory:

mkdir -p ~/seafile && cd ~/seafile

Create docker-compose.yml:

services:
  seafile-mysql:
    image: mariadb:11
    container_name: seafile-mysql
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_LOG_CONSOLE: "true"
      MARIADB_AUTO_UPGRADE: "1"
    volumes:
      - mysql-data:/var/lib/mysql
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
      interval: 20s
      retries: 5

  memcached:
    image: memcached:1.6-alpine
    container_name: seafile-memcached
    entrypoint: memcached -m 256
    restart: unless-stopped

  seafile:
    image: seafileltd/seafile-mc:12
    container_name: seafile
    ports:
      - "127.0.0.1:8080:80"
    volumes:
      - seafile-data:/shared
    environment:
      DB_HOST: seafile-mysql
      DB_ROOT_PASSWD: ${DB_ROOT_PASSWORD}
      SEAFILE_ADMIN_EMAIL: ${ADMIN_EMAIL}
      SEAFILE_ADMIN_PASSWORD: ${ADMIN_PASSWORD}
      SEAFILE_SERVER_HOSTNAME: ${SEAFILE_DOMAIN}
      SEAFILE_SERVER_LETSENCRYPT: "false"  # Using external reverse proxy
      TIME_ZONE: America/New_York
    depends_on:
      seafile-mysql:
        condition: service_healthy
      memcached:
        condition: service_started
    restart: unless-stopped

volumes:
  mysql-data:
  seafile-data:

Create your .env file:

DB_ROOT_PASSWORD=your-strong-database-password-here
ADMIN_EMAIL=[email protected]
ADMIN_PASSWORD=your-strong-admin-password
SEAFILE_DOMAIN=seafile.yourdomain.com

Start it up:

docker compose up -d

First boot takes a minute or two while Seafile initializes its databases. Check progress with docker compose logs -f seafile.

Initial Configuration

Once running, access Seahub (the web interface) at http://your-server:8080 and log in with your admin credentials.

Key Settings (Admin Panel)

Navigate to System Admin → Settings:

• SERVICE_URL: https://seafile.yourdomain.com — critical for file links and sharing
• FILE_SERVER_ROOT: https://seafile.yourdomain.com/seafhttp — needed for uploads/downloads through the reverse proxy
• ENABLE_SIGNUP: Set to False unless you want public registration
• USER_DEFAULT_QUOTA: Set per-user storage limits (e.g., 10 for 10GB)

Seafile Configuration Files

For deeper tuning, edit the config files inside the container volume:

# Find your config directory
docker exec seafile ls /shared/seafile/conf/

Key files:

• seahub_settings.py — Web interface settings
• seafile.conf — Core server settings
• ccnet.conf — Network settings

Understanding Libraries

Seafile organizes files into libraries (think of them as top-level sync folders). Each library:

• Has its own sync state and versioning history
• Can be selectively synced to desktop clients
• Can be individually shared with specific users or groups
• Supports optional client-side encryption (zero-knowledge)

This is fundamentally different from Nextcloud’s single-root approach. You might have libraries for “Work Documents”, “Photos 2026”, “Shared Family”, and “Encrypted Tax Records” — each synced independently.

Creating an Encrypted Library

For sensitive files, create a client-side encrypted library:

1. Click New Library → Encrypted Library
2. Set an encryption password (server never sees it)
3. Files are encrypted before leaving the client

The server stores only encrypted blocks. Even a database breach reveals nothing. The tradeoff: encrypted libraries can’t use server-side features like full-text search or online preview.

File Sharing

Seafile offers flexible sharing:

• Share to users: Grant read-only or read-write access to specific Seafile users
• Share to groups: Create groups for team access
• Share links: Generate public download links with optional password and expiry
• Upload links: Let external users upload to a specific folder without an account

Desktop and Mobile Sync

Desktop Client

Download the Seafile client for Windows, macOS, or Linux from seafile.com/download.

Configure it:

1. Add your server URL: https://seafile.yourdomain.com
2. Log in with your credentials
3. Select which libraries to sync and where to store them locally

The sync client uses block-level delta sync — after the initial download, only changed portions of files transfer. A small edit to a 500MB Excel file sends kilobytes, not the whole file.

Mobile Apps

• iOS: Seafile app on the App Store
• Android: Seafile app on Google Play or F-Droid

Mobile apps support auto-upload for camera photos (a popular Nextcloud alternative use case), offline access for pinned files, and share-to-Seafile from other apps.

Online Editing with SeaDoc

Seafile 12 includes SeaDoc, a built-in collaborative document editor. For full office document editing, integrate OnlyOffice or Collabora:

OnlyOffice Integration

Add to your docker-compose.yml:

  onlyoffice:
    image: onlyoffice/documentserver:latest
    container_name: seafile-onlyoffice
    environment:
      JWT_SECRET: your-onlyoffice-secret
    ports:
      - "127.0.0.1:8088:80"
    restart: unless-stopped

Configure in seahub_settings.py:

ENABLE_ONLYOFFICE = True
ONLYOFFICE_APIJS_URL = 'https://onlyoffice.yourdomain.com/web-apps/apps/api/documents/api.js'
ONLYOFFICE_FILE_EXTENSION = ('doc', 'docx', 'ppt', 'pptx', 'xls', 'xlsx', 'odt', 'fodt', 'odp', 'fodp', 'ods', 'fods', 'csv')
ONLYOFFICE_EDIT_FILE_EXTENSION = ('docx', 'pptx', 'xlsx')
ONLYOFFICE_JWT_SECRET = 'your-onlyoffice-secret'

Restart Seafile after changes:

docker compose restart seafile

Reverse Proxy Configuration

Caddy

Nginx

server {
    listen 443 ssl http2;
    server_name seafile.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/seafile.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/seafile.yourdomain.com/privkey.pem;

    client_max_body_size 0;
    proxy_read_timeout 1200s;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /seafhttp {
        rewrite ^/seafhttp(.*)$ $1 break;
        proxy_pass http://127.0.0.1:8082;
        proxy_set_header Host $http_host;
        proxy_request_buffering off;
        proxy_connect_timeout 36000s;
        proxy_read_timeout 36000s;
        proxy_send_timeout 36000s;
        send_timeout 36000s;
    }
}

The /seafhttp location handles file uploads and downloads through the Seafile fileserver directly, bypassing Seahub for better performance on large transfers.

Backup and Restore

Seafile stores data in two places: the MySQL database (metadata) and the data volume (file blocks). Back up both:

#!/bin/bash
# seafile-backup.sh
BACKUP_DIR="/backups/seafile/$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"

# Database backup
docker exec seafile-mysql mysqldump -uroot \
  -p"$DB_ROOT_PASSWORD" \
  --all-databases --single-transaction \
  > "$BACKUP_DIR/databases.sql"

# Seafile data backup
docker run --rm \
  -v seafile_seafile-data:/data:ro \
  -v "$BACKUP_DIR":/backup \
  alpine tar czf /backup/seafile-data.tar.gz -C /data .

# Retain 14 days
find /backups/seafile -maxdepth 1 -mtime +14 -exec rm -rf {} +

echo "Backup completed: $BACKUP_DIR"

Garbage Collection

Seafile’s block storage accumulates orphaned blocks over time. Run garbage collection periodically:

# Stop Seafile first (GC needs exclusive access)
docker compose stop seafile
docker exec seafile /opt/seafile/seafile-server-latest/seaf-gc.sh
docker compose start seafile

Schedule this weekly during low-usage hours.

Troubleshooting

Can’t upload large files: Ensure your reverse proxy has no body size limit (client_max_body_size 0 for Nginx) and increase timeout values. Seafile’s fileserver handles chunked uploads, but the proxy must not interfere.

Sync client shows “server not connected”: Verify SERVICE_URL and FILE_SERVER_ROOT in admin settings match your actual domain. Both must use https:// when behind a reverse proxy.

Slow initial sync: This is normal for large libraries. Seafile downloads all blocks on first sync. Subsequent syncs are fast due to delta sync. Consider syncing large libraries overnight.

“Internal Server Error” on web interface: Check Seahub logs: docker exec seafile cat /shared/seafile/logs/seahub.log. Common causes: misconfigured database connection, wrong SERVICE_URL, or memcached not running.

Encrypted library won’t open: The password is never stored server-side. If the client doesn’t have it cached, you’ll need to re-enter it. There’s no password recovery — this is by design.

Database connection errors after upgrade: Run docker exec seafile-mysql mariadb-upgrade -uroot -p"$DB_ROOT_PASSWORD" and restart both containers.

Power User Tips

Full-text search: Enable Elasticsearch integration for searching inside documents. Add an Elasticsearch container and configure seafevents.conf — essential for large deployments.

WebDAV access: Seafile includes a WebDAV endpoint at /seafdav for clients that need traditional file access. Enable it in seafdav.conf. Useful for Linux file managers and legacy apps.

Two-factor authentication: Enable TOTP 2FA in seahub_settings.py with ENABLE_TWO_FACTOR_AUTH = True. Supports per-user enforcement for admin accounts.

SSO integration: Seafile supports SAML and OAuth for single sign-on. Pair it with Authentik or Authelia for centralized auth.

S3 backend: For massive deployments, configure Seafile to store blocks in S3-compatible storage (AWS S3, MinIO, Backblaze B2) instead of local disk. Edit seafile.conf to switch the storage backend.

Seaf-CLI: The command-line client is perfect for headless servers. Sync libraries without a GUI: seaf-cli sync -l <library-id> -s https://seafile.yourdomain.com -d /path/to/local -u [email protected].

Library API: Seafile’s REST API is comprehensive. Automate library creation, sharing, and file management: curl -H "Authorization: Token <api-token>" https://seafile.yourdomain.com/api2/repos/.

Performance tuning: In seafile.conf, increase worker threads for high-concurrency: [fileserver] → max_upload_size, max_download_dir_size, and worker_threads. For seahub_settings.py, configure FILE_ENCODING_TRY_LIST for non-UTF8 file names.

Migration from Nextcloud: Export files from Nextcloud and upload to Seafile libraries. There’s no automated migration tool, but the directory structure maps cleanly — each Nextcloud folder becomes a Seafile library. Metadata (shares, tags) needs manual recreation.

Wrapping Up

Seafile won’t replace Nextcloud if you rely on its calendar, contacts, or app ecosystem. But if your primary need is fast, reliable file sync with a clean web interface, Seafile does that job better than anything else in the self-hosted space. The block-level delta sync alone makes it worth considering for anyone frustrated with WebDAV-based sync performance.

Start with the community edition, add OnlyOffice if you need document editing, and enjoy file sync that actually works the way you’d expect it to.

Related Guides

• Docker Volume Management: Backups, Migration, and Best Practices
• Caddy: The Zero-Config HTTPS Reverse Proxy
• Traefik vs Caddy vs Nginx Proxy Manager
• Running Authentik vs Authelia: SSO Comparison 2026
• Self-Hosting Kopia: Modern Backup Solution
• Linux Server Hardening Checklist