Join the community

[!WARNING] Zerobyte is still in version 0.x.x and is subject to major changes from version to version. I am developing the core features and collecting feedback. Please open issues for bugs or feature requests.

Introduction

Zerobyte is a backup automation tool that helps you save your data across multiple storage backends. Built on top of Restic, it provides an modern web interface to schedule, manage, and monitor encrypted backups of your remote storage.

Documentation

The official documentation website is available at zerobyte.app.

It contains up-to-date setup guides, configuration reference, and usage documentation for running Zerobyte in production.

Features

• Automated backups with encryption, compression, and retention policies, powered by Restic
• Flexible scheduling for automated backup jobs with fine-grained retention policies
• End-to-end encryption will ensure your data is always protected
• Multi-protocol support for backup from NFS, SMB, WebDAV, SFTP, or local directories

Installation

In order to run Zerobyte, you need to have Docker and Docker Compose installed on your server. Then, you can use the provided compose.yaml file to start the application.

services:
  zerobyte:
    image: ghcr.io/nicotsx/zerobyte:v0.43
    container_name: zerobyte
    restart: unless-stopped
    cap_add:
      - SYS_ADMIN
    ports:
      - "4096:4096"
    devices:
      - /dev/fuse:/dev/fuse
    environment:
      - TZ=Europe/Zurich # Set your timezone here
      - BASE_URL=http://localhost:4096 # URL you will use to access Zerobyte
      - APP_SECRET=94bad46...c66e25d5c2b # Generate your own secret with `openssl rand -hex 32`
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /var/lib/zerobyte:/var/lib/zerobyte

[!WARNING] It is highly discouraged to run Zerobyte on a server that is accessible from the internet (VPS or home server with port forwarding). If you do, make sure to change the port mapping to "127.0.0.1:4096:4096" and use a secure tunnel (SSH tunnel, Cloudflare Tunnel, etc.) with authentication.

[!WARNING] Do not try to point /var/lib/zerobyte to a network share. You will face permission issues and strong performance degradation.

[!NOTE] TrueNAS Users: The host path /var/lib is ephemeral on TrueNAS and will be reset during system upgrades. Instead of using /var/lib/zerobyte:/var/lib/zerobyte, create a dedicated ZFS dataset (e.g., tank/docker/zerobyte) and mount it instead:

volumes:
  - /etc/localtime:/etc/localtime:ro
  - /mnt/tank/docker/zerobyte:/var/lib/zerobyte

This ensures your configuration, encryption keys, and database persist across TrueNAS upgrades.

Then, run the following command to start Zerobyte:

docker compose up -d

Once the container is running, you can access the web interface at http://<your-server-ip>:4096.

Configuration

Zerobyte can be customized using environment variables. Below are the available options:

Environment variables

Performance tuning

If backups use too much CPU, set GOMAXPROCS on the Zerobyte container and restart it:

environment:
  - GOMAXPROCS=2

This limits the Go scheduler used by Restic child processes. Existing operations are not changed; the new value applies to Restic processes started after the container restart.

Other useful Restic tuning options:

• Set repository compression to off to reduce CPU usage, or auto for the usual balance. max can save more space but uses more CPU.
• Use repository upload/download limits to avoid saturating network links.
• Use backup schedule Custom restic parameters for advanced per-job flags such as --read-concurrency 1, --exclude-larger-than 10G, or --no-scan.

See the full guide: Performance tuning.

Webhook and notification network policy

Backup webhooks and outbound notification destinations that can target arbitrary network hosts are restricted by WEBHOOK_ALLOWED_ORIGINS.

The allowlist matches exact origins only: scheme, host, and port must match. Paths are ignored, so https://hooks.example.com/backups allows any path on https://hooks.example.com, but it does not allow http://hooks.example.com, https://hooks.example.com:8443, or https://other.example.com.

This policy applies to:

• backup pre/post webhook URLs
• Generic HTTP notification URLs
• Gotify server URLs
• self-hosted ntfy server URLs
• custom Shoutrrr URLs that point at generic HTTP or SMTP network targets

The public ntfy.sh service and fixed-provider notification services such as Slack, Discord, Pushover, and Telegram do not need WEBHOOK_ALLOWED_ORIGINS.

Backup webhooks do not follow redirects. Add the final destination origin to WEBHOOK_ALLOWED_ORIGINS and configure that final URL directly.

Webhook headers are stored as plain text and must use one Key: Value header per line. WEBHOOK_TIMEOUT controls backup pre/post webhook request timeouts; notification delivery uses the underlying provider sender behavior.

Provisioned resources

Zerobyte can sync operator-managed repositories and volumes from a JSON file at startup. This is useful when you want credentials or connection details to live in deployment-time configuration instead of being entered through the UI.

Provisioned resources:

• appear in the normal repositories and volumes screens
• can resolve credential fields from environment variables or /run/secrets/* during startup sync

The complete provisioning documentation is available at zerobyte.app/docs/guides/provisioning.

See examples/provisioned-resources/README.md for a full example.

Simplified setup (no remote mounts)

If you only need to back up locally-mounted folders and don't require remote share mounting capabilities, you can remove the SYS_ADMIN capability and FUSE device from your compose.yaml:

services:
  zerobyte:
    image: ghcr.io/nicotsx/zerobyte:v0.43
    container_name: zerobyte
    restart: unless-stopped
    ports:
      - "4096:4096"
    environment:
      - TZ=Europe/Zurich # Set your timezone here
      - BASE_URL=http://localhost:4096 # Change this to your actual URL (use https:// for secure cookies)
      - APP_SECRET=94bad46...c66e25d5c2b # Generate your own secret with `openssl rand -hex 32`
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /var/lib/zerobyte:/var/lib/zerobyte
      - /path/to/your/directory:/mydata

Trade-offs:

• ✅ Improved security by reducing container capabilities
• ✅ Support for local directories as backup sources
• ✅ Support all repository types, local and remote (S3, GCS, Azure, rclone)
• ❌ Cannot mount NFS, SMB, WebDAV, or SFTP shares directly from Zerobyte

If you need remote mount capabilities, keep the original configuration with cap_add: SYS_ADMIN and devices: /dev/fuse:/dev/fuse.

Examples

See examples/README.md for runnable, copy/paste-friendly examples.

Adding your first volume

Zerobyte supports multiple volume backends including NFS, SMB, WebDAV, SFTP, and local directories. A volume represents the source data you want to back up and monitor.

To add your first volume, navigate to the "Volumes" section in the web interface and click on "Create volume". Fill in the required details such as volume name, type, and connection settings.

If you want to backup a local directory on the same host where Zerobyte is running, you'll first need to mount that directory into the Zerobyte container. You can do this by adding a volume mapping in your compose.yaml file. For example, to mount /path/to/your/directory from the host to /mydata in the container, you would add the following line under the volumes section:

services:
  zerobyte:
    image: ghcr.io/nicotsx/zerobyte:v0.43
    container_name: zerobyte
    restart: unless-stopped
    cap_add:
      - SYS_ADMIN
    ports:
      - "4096:4096"
    devices:
      - /dev/fuse:/dev/fuse
    environment:
      - TZ=Europe/Zurich
      - BASE_URL=http://localhost:4096 # URL you will use to access Zerobyte
      - APP_SECRET=94bad46...c66e25d5c2b # Generate your own secret with `openssl rand -hex 32`
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /var/lib/zerobyte:/var/lib/zerobyte
+     - /path/to/your/directory:/mydata

After updating the compose.yaml file, restart the Zerobyte container to apply the changes:

docker compose down
docker compose up -d

Now, when adding a new volume in the Zerobyte web interface, you can select "Directory" as the volume type and search for your mounted path (e.g., /mydata) as the source path.

Creating a repository

A repository is where your backups will be securely stored encrypted. Zerobyte supports multiple storage backends for your backup repositories:

• Local directories: Store backups on local disk subfolders in /var/lib/zerobyte/repositories/ or any other (mounted) path
• S3-compatible storage: Amazon S3, MinIO, Wasabi, DigitalOcean Spaces, etc.
• Google Cloud Storage: Google's cloud storage service
• Azure Blob Storage: Microsoft Azure storage
• rclone remotes: 40+ cloud storage providers via rclone (see below)

Repositories are optimized for storage efficiency and data integrity, leveraging Restic's deduplication and encryption features.

To create a repository, navigate to the "Repositories" section in the web interface and click on "Create repository". Fill in the required details such as repository name, type, and connection settings.

Using rclone for cloud storage

Zerobyte can use rclone to support 40+ cloud storage providers including Google Drive, Dropbox, OneDrive, Box, pCloud, Mega, and many more. This gives you the flexibility to store your backups on virtually any cloud storage service.

Setup instructions:

1. Install rclone on your host system (if not already installed):

   curl https://rclone.org/install.sh | sudo bash
   

2. Configure your cloud storage remote using rclone's interactive config:

   rclone config
   

   Follow the prompts to set up your cloud storage provider. For OAuth providers (Google Drive, Dropbox, etc.), rclone will guide you through the authentication flow.

3. Verify your remote is configured:

   rclone listremotes
   

4. Mount the rclone config into the Zerobyte container by updating your compose.yaml:

   services:
     zerobyte:
       image: ghcr.io/nicotsx/zerobyte:v0.43
       container_name: zerobyte
       restart: unless-stopped
       cap_add:
         - SYS_ADMIN
       ports:
         - "4096:4096"
       devices:
         - /dev/fuse:/dev/fuse
       environment:
         - TZ=Europe/Zurich
         - BASE_URL=http://localhost:4096 # URL you will use to access Zerobyte
       volumes:
         - /etc/localtime:/etc/localtime:ro
         - /var/lib/zerobyte:/var/lib/zerobyte
   +     - ~/.config/rclone:/root/.config/rclone:ro
   

   Note for non-root users: If your container runs as a different user (e.g., TrueNAS apps), mount your config to the appropriate location and set RCLONE_CONFIG_DIR:

   environment:
     - RCLONE_CONFIG_DIR=/home/appuser/.config/rclone
   volumes:
     - ~/.config/rclone:/home/appuser/.config/rclone:ro
   

5. Restart the Zerobyte container:

   docker compose down
   docker compose up -d
   

6. Create a repository in Zerobyte:

   • Select "rclone" as the repository type
   • Choose your configured remote from the dropdown
   • Specify the path within your remote (e.g., backups/zerobyte)

For a complete list of supported providers, see the rclone documentation.

Your first backup job

Once you have added a volume and created a repository, you can create your first backup job. A backup job defines the schedule and parameters for backing up a specific volume to a designated repository.

When creating a backup job, you can specify the following settings:

• Schedule: Define how often the backup should run (e.g., daily, weekly)
• Retention Policy: Set rules for how long backups should be retained (e.g., keep daily backups for 7 days, weekly backups for 4 weeks)
• Paths: Specify which files or directories to include in the backup

After configuring the backup job, save it and Zerobyte will automatically execute the backup according to the defined schedule. You can monitor the progress and status of your backup jobs in the "Backups" section of the web interface.

Restoring data

Zerobyte allows you to easily restore your data from backups. To restore data, navigate to the "Backups" section and select the backup job from which you want to restore data. You can then choose a specific backup snapshot and select the files or directories you wish to restore. The data you select will be restored to their original location.

Authentication

Zerobyte uses better-auth for authentication and session management. The authentication system automatically adapts to your deployment scenario:

Users and roles

Zerobyte does not currently provide fine-grained RBAC for backup operations. Authenticated organization members are trusted operators for repositories, volumes, backup schedules, restores, and notification destinations in their organization.

Organization roles mainly restrict organization-management and instance-management actions. For example, normal members cannot manage members, SSO settings, invitations, registration, or global users, but they can still operate backup resources. Only add users to an organization if you are comfortable with them using the storage, volume, and notification capabilities configured for the instance.

Cookie security

• IP Address/HTTP access: Set BASE_URL=http://192.168.1.50:4096 (or your IP). Cookies will use Secure: false, allowing immediate login without SSL.
• Domain/HTTPS access: Set BASE_URL=https://zerobyte.example.com. Cookies will automatically use Secure: true for protected sessions.

Reverse proxy setup

If you're running Zerobyte behind a reverse proxy (Nginx, Traefik, Caddy, etc.):

1. Set BASE_URL to your HTTPS domain (e.g., https://zerobyte.example.com)
2. The app will automatically enable secure cookies based on the https:// prefix
3. Ensure your proxy passes the X-Forwarded-Proto header

Important notes

• The BASE_URL must start with https:// for secure cookies to be enabled
• Local IP addresses (e.g., http://192.168.x.x) are not treated as secure contexts by browsers, so secure cookies are disabled automatically
• TRUSTED_ORIGINS only allows additional origins for auth-related requests. It does not disable secure cookies or make authenticated HTTP access work when BASE_URL is HTTPS.
• If BASE_URL is HTTPS, browsers will only send Zerobyte's auth cookies over HTTPS. Plain HTTP access may still show the login page, but authenticated flows will fail because no session cookie is available.

Troubleshooting

For troubleshooting common issues, please refer to the TROUBLESHOOTING.md file.

Third-party software

This project includes the following third-party software components:

Restic

Zerobyte includes Restic for backup functionality.

• License: BSD 2-Clause License
• Copyright: Copyright (c) 2014, Alexander Neumann alexander@bumpern.de
• Status: Included unchanged
• License Text: See LICENSES/BSD-2-Clause-Restic.txt

For a complete list of third-party software licenses and attributions, please refer to the NOTICES.md file.

Contributing

Contributions by anyone are welcome! If you find a bug or have a feature request, please open an issue on GitHub. If you want to contribute code, feel free to fork the repository and submit a pull request. We require that all contributors sign a Contributor License Agreement (CLA) before we can accept your contributions. This is to protect both you and the project. Please see the CONTRIBUTING.md file for more details.

Development (no Docker)

With Bun and Portless installed, you can run Zerobyte locally during development without Docker:

bun install
bun run dev

For local development, create a .env.local file at the repo root and override the Docker paths:

# Example
ZEROBYTE_DATABASE_URL=./data/zerobyte.db
APP_SECRET=your_app_secret_here
RESTIC_PASS_FILE=./data/restic.pass
RESTIC_CACHE_DIR=./data/restic/cache
ZEROBYTE_REPOSITORIES_DIR=./data/repositories
ZEROBYTE_VOLUMES_DIR=./data/volumes
BASE_URL=https://*.localhost

Notes:

• Remote mount backends (NFS/SMB/WebDAV/SFTP) rely on Linux mount tooling and CAP_SYS_ADMIN; on macOS they are expected to be unavailable.
• To actually run backups/repository checks, install restic on your machine (e.g., via Homebrew). If restic is not installed, the app still starts but backup operations will fail with a clear error.