Nextcloud vs ownCloud vs Seafile: Which One Fits?

You need self-hosted file sync and share, and the shortlist keeps coming back to Nextcloud, ownCloud and Seafile. From the outside they look interchangeable, but they differ in storage model, resource footprint and how far they reach beyond plain file sync. This tutorial compares them on the points that change your operations work, and shows a Docker test setup for each.

What is the difference between ownCloud and Nextcloud?

ownCloud and Nextcloud share a common PHP codebase up to the 2016 fork, but Nextcloud kept extending that PHP server into a full groupware suite, while ownCloud rewrote its server from scratch as Infinite Scale (oCIS) in Go.

That rewrite is the decisive fact for anyone evaluating today. ownCloud Server 10.x, the PHP line, is in maintenance and no longer the product ownCloud develops against. Infinite Scale is a single static binary under the Apache-2.0 license, needs no PHP and no relational database, and replaces the classic home directory with Spaces, a shared-project construct with its own quota and members. ownCloud has been part of Kiteworks since November 2023, which is worth noting if long-term vendor independence is part of your decision.

Nextcloud went the other direction. The server stays PHP under AGPLv3, and each release adds application surface: Talk, Groupware, Office integration, Flow, Assistant. Nextcloud 31 (released March 2025) runs on PHP 8.1 to 8.4, with 8.3 recommended.

Seafile is not part of that family at all. It is an independent project written in C and Go with a Django frontend, and it stores files as blocks rather than as files, which is where its performance profile comes from.

Architecture at a glance

The database row tells you most of what you need to know about operating each one. Nextcloud puts every file, share and activity entry into a relational database, so database tuning and backup consistency are part of the job. oCIS keeps metadata next to the blobs in extended attributes, which removes a component but also removes the familiar mysqldump recovery path. Seafile needs MariaDB for accounts, libraries and share links, while the file content lives in its own object store.

Prerequisites

• A Linux host with Docker Engine 24.0 or newer and the Compose plugin
• At least 4 GB RAM and 20 GB free disk space to run all three side by side
• A user in the docker group or sudo rights
• Ports 80, 8080 and 9200 free on the host

Run the comparison on disposable infrastructure rather than on a machine you care about. A scalable Cloud-VM with 4 vCPUs is enough for a realistic sync test with a few gigabytes of data, and you can discard it once the decision is made.

Which one handles many small files best?

Seafile handles large numbers of small files best, because it splits every file into content-defined blocks of roughly 1 MB average size and tracks them in a Git-like commit model instead of one database row plus one inode per file.

The practical consequence shows up during the first sync of a source tree or a photo library. Nextcloud writes one oc_filecache row per file and per directory, and a rescan (occ files:scan) walks that table; on a library with a few hundred thousand entries this becomes the dominant cost. Seafile transfers block lists, deduplicates identical blocks across users and libraries, and does not touch the database per file. oCIS sits in between: no central metadata database, but still one blob plus metadata per file version.

The trade-off is direct filesystem access. In Nextcloud, /var/www/html/data/<user>/files/ contains exactly the files the user sees, so rsync, tar and any backup agent work on them unchanged. In Seafile, the block store is opaque; you restore through Seafile or not at all. Weigh that against the sync speed before choosing.

Upload chunking also differs. Nextcloud uses chunked uploads with a default chunk size of 10 MiB, configurable through max_chunk_size in config/config.php. Seafile negotiates block lists and only sends blocks the server does not already have, which makes repeated syncs of large, slightly modified files noticeably cheaper.

Deploy a test instance of each

The following configurations are for evaluation on a throwaway host. None of them terminates TLS properly, so do not expose them to the internet.

Nextcloud

The official image ships with SQLite for a first start, which is fine for a functional test but not for a load test:

$ docker volume create nextcloud-data
$ docker run -d --name nextcloud -p 8080:80 \
  -v nextcloud-data:/var/www/html \
  nextcloud:apache

Open http://<your-host>:8080 and complete the setup wizard. For anything beyond a smoke test, select PostgreSQL or MariaDB in the wizard and add a Redis container for file locking.

ownCloud Infinite Scale

oCIS requires an explicit init step that generates the machine secrets before the server starts:

$ docker volume create ocis-config
$ docker volume create ocis-data
$ docker run --rm -v ocis-config:/etc/ocis \
  -e OCIS_INSECURE=true \
  -e IDM_ADMIN_PASSWORD='<admin-password>' \
  owncloud/ocis:latest init
$ docker run -d --name ocis -p 9200:9200 \
  -e OCIS_URL=https://<your-host>:9200 \
  -e OCIS_INSECURE=true \
  -e PROXY_HTTP_ADDR=0.0.0.0:9200 \
  -v ocis-config:/etc/ocis -v ocis-data:/var/lib/ocis \
  owncloud/ocis:latest

Without IDM_ADMIN_PASSWORD, init runs interactively and prints a generated admin password once. The service answers on HTTPS with a self-signed certificate; log in as admin.

Seafile

Seafile 12.0 dropped SQLite support on the server, so MariaDB is mandatory. Save this as /opt/seafile/docker-compose.yml:

services:
  db:
    image: mariadb:10.11
    environment:
      - MYSQL_ROOT_PASSWORD=<db-root-password>
      - MYSQL_LOG_CONSOLE=true
    volumes:
      - /opt/seafile-mysql/db:/var/lib/mysql
  memcached:
    image: memcached:1.6
    entrypoint: memcached -m 256
  seafile:
    image: seafileltd/seafile-mc:12.0-latest
    ports:
      - "80:80"
    volumes:
      - /opt/seafile-data:/shared
    environment:
      - DB_HOST=db
      - DB_ROOT_PASSWD=<db-root-password>
      - SEAFILE_ADMIN_EMAIL=admin@<your-domain>
      - SEAFILE_ADMIN_PASSWORD=<admin-password>
      - SEAFILE_SERVER_HOSTNAME=<your-domain>
    depends_on:
      - db
      - memcached

Start it:

$ cd /opt/seafile
$ docker compose up -d

The first start initialises the database and can take one to two minutes before the web UI answers.

Verify each instance

Each server exposes a status endpoint. Check all three before you start comparing clients:

$ curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8080/status.php
200
$ curl -sk https://localhost:9200/status.php | head -c 120
{"installed":true,"maintenance":false,"needsDbUpgrade":false,"productname":"Infinite Scale"
$ curl -s http://localhost/api2/ping/
"pong"

For Nextcloud, the authoritative check is occ, which also reports the exact version:

$ docker exec -u www-data nextcloud php occ status
  - installed: true
  - version: 31.0.5.1
  - versionstring: 31.0.5
  - edition:
  - maintenance: false

Feature coverage beyond file sync

Seafile's encrypted libraries are the clearest differentiator on the security side: the passphrase never reaches the server, and neither does the plaintext. The cost is that server-side features such as online editing, search and thumbnails do not work inside an encrypted library.

Migration paths

Moving between these platforms is a data migration, not an upgrade. The single exception is ownCloud Server 10 to Nextcloud, which Nextcloud documents as an in-place path: you must land on a supported version pair, replace the code directory and run occ upgrade, keeping the database and data directory in place.

Everything else is a copy. rclone speaks WebDAV for Nextcloud and oCIS and has a native seafile backend, which makes it the pragmatic tool for a one-off move:

$ rclone config
$ rclone copy nextcloud:/ seafile:my-library \
  --transfers 8 --checkers 16 --progress

Share links, comments, tags and app data do not survive this. Plan the migration around file content and user accounts, and treat metadata as something you recreate.

Troubleshooting

Nextcloud reports "Access through untrusted domain". The hostname you used is not in trusted_domains. Add it without editing the file by hand:

$ docker exec -u www-data nextcloud php occ config:system:set trusted_domains 1 --value=<your-domain>

ocis init aborts with an existing configuration. The ocis-config volume already contains ocis.yaml from an earlier run. Either remove the volume with docker volume rm ocis-config or pass --force-overwrite to init. Overwriting invalidates the previously issued secrets, so existing clients must log in again.

Seafile uploads fail with a network error behind a reverse proxy. The upload goes to seafhttp, not to the web frontend. Check that SERVICE_URL and FILE_SERVER_ROOT in /opt/seafile-data/seafile/conf/seahub_settings.py match the external URL, and that your proxy forwards /seafhttp with client_max_body_size 0.

Which one should you choose?

Choose Nextcloud when you want one installation to cover files, calendar, contacts, mail and chat; choose Seafile when sync throughput on large file counts matters more than feature breadth; choose ownCloud Infinite Scale when you want a lean file service with no PHP and no database to operate.

graph TD
  A["Self-hosted file sync required"] --> B{"Groupware, chat and calendar in the same app?"}
  B -- yes --> C["Nextcloud"]
  B -- no --> D{"Hundreds of thousands of small files?"}
  D -- yes --> E["Seafile"]
  D -- no --> F{"Plain filesystem access to stored data needed?"}
  F -- yes --> C
  F -- no --> G["ownCloud Infinite Scale"]

Two constraints override the diagram. If your backup strategy depends on reading the data directory with standard tools, Seafile is out. If you cannot accept an AGPLv3 obligation in your distribution model, oCIS under Apache-2.0 is the only option of the three.

Wrap-up

Run all three on the same host for an afternoon, sync a realistic dataset with the desktop client, and measure the first full sync and a second incremental one. That single test separates the three faster than any feature table, because the storage model is what you will live with. Once you have picked one, size the production host from the observed data volume and file count, not from the number of users.

Read next

• Back Up and Restore Nextcloud: Data, Database, Config
• Install Nextcloud All-in-One with Docker
• Install Nextcloud on Ubuntu 24.04 with nginx
• Mount Nextcloud via WebDAV on Linux, Windows and macOS
• Run Nextcloud with Docker Compose
• Set Up Nextcloud Office: Collabora or OnlyOffice
• Updating Nextcloud: Web Updater, occ and a Rollback Plan
• What Is Nextcloud? Architecture, Components and Use Cases
• Which Server for Nextcloud? Sizing RAM, CPU and Storage