Website profiles · Technology insights · Alternatives

duplicity.gitlab.io

No paid content found
Visit website
Profile views 13 Outbound visits 5 Normal
duplicity Full homepage screenshot

At a glance

Category
Resources & Utilities
Language
English
Paid-content signal
No paid content foundObserved
Registered
2012
Hosting
Google LLCInferred
HTTPS certificate trusted
PassedObserved
Last updated

Website review

This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.

What is duplicity?

Duplicity is a command-line backup tool that combines two ideas: it stores backups as encrypted tar-format volumes, and it uses the rsync algorithm (via librsync) so that each run records only the parts of files that changed since the last backup. The archives are encrypted and/or signed with GnuPG, which means the server holding your backups cannot read or silently alter them. Backups can go to a local filesystem or to a remote file server.

What that means in practice

  • Bandwidth- and space-efficient incrementals. If you change a few bytes in a large file, duplicity doesn't re-upload the whole file; it records a delta. This matters most for large, slowly changing files such as databases dumps, disk images or mailbox archives.
  • Untrusted storage is acceptable. Because encryption happens before upload, you can use commodity object storage or a shared server without handing over readable data.
  • Tar-format volumes. The output is a set of archive volumes rather than a proprietary repository format, which some people find easier to reason about and move around.
  • Deleted files, Unix permissions, directories, symlinks, FIFOs and device files are supported; hard links are not. If your data relies heavily on hard links (some mail spools, some build trees, some photo libraries), that is a real limitation to plan around.

Typical users

A sysadmin backing up a server to object storage over ssh or S3-style protocols; a developer keeping an encrypted offsite copy of a home directory; a small organisation wanting restorable, encrypted archives without running its own backup server. The project describes itself as mature and in use for large personal and corporate backups, while noting that bugs can still exist—so treat it as production-capable but test your restores.

Where it sits among alternatives

Approach Strength Trade-off
Duplicity Encrypted, bandwidth-efficient incrementals to many backends Command-line oriented; no hard links; restore workflow takes learning
Plain rsync to a server Simple, fast, familiar Server sees plaintext; no archive history
rdiff-backup Similar delta approach, keeps a mirror plus reverse deltas Not the same encryption model; different repository layout
tar + gpg scripts Fully transparent, no dependencies beyond tar/gpg You build and maintain the incremental logic yourself

A concrete starting scenario

Suppose you run a small web server and want an encrypted copy in cheap object storage. You would install duplicity, create a GnuPG key, and run a full backup to the remote target, then schedule incremental runs. The first run is the slow one; later runs upload only changed blocks. The critical step is practising a restore to a scratch directory before you need it, since a backup you have never restored is an assumption rather than a fact.

Next step

Read the official documentation and requirements pages to confirm which backends and protocol helpers your system needs, then run one full backup and one restore of a small test directory. The project is at duplicity; its GitLab project hosts the bug tracker and source, and the manual covers backend-specific setup.

How does duplicity's incremental backup work with the rsync algorithm?

Duplicity combines two mechanisms: it uses the rsync algorithm to find what changed, then stores the result as encrypted tar-format volumes on a local or remote server. The rsync side is what keeps each incremental archive small — it records only the parts of files that differ from the previous backup rather than re-uploading whole files.

That matters most when you back up large, slowly changing files (mail stores, virtual disk images, database dumps). A pure "copy everything changed" tool re-sends the entire file when a few bytes change; duplicity's use of librsync lets it transmit only the changed portions. The trade-off is that building and comparing signatures costs local CPU and temporary space, and restoring requires walking the chain of incremental archives rather than reading one self-contained snapshot.

H3 What this looks like in practice

  • First run: a full backup, written as encrypted tar volumes and uploaded.
  • Later runs: duplicity computes librsync signatures/deltas, produces a new incremental volume set, and uploads just that.
  • Server side: the storage provider only ever sees encrypted, signed archives, so it cannot read or silently alter your data — encryption and signing are handled locally via GnuPG.
  • Restore: you need the full chain (or the relevant sequence of volumes) to reconstruct a given point in time.

H3 Practical decision criteria

  • Choose duplicity if you want encryption-by-default, bandwidth-efficient incrementals, and flexibility in where archives land — the project lists many supported backends, including Amazon S3, Backblaze B2, Google Drive, Microsoft OneDrive, rclone, rsync, ssh/scp, WebDAV and local filesystems.
  • Look elsewhere if you need hard-link preservation (duplicity supports deleted files, permissions, directories, symlinks, fifos and device files, but not hard links) or if you want every backup to be a standalone, instantly mountable snapshot.
  • Watch the upgrade path: the project warns that mixing a distribution-packaged install with the tarball version can put files in different locations, so purge one before installing the other.

A concrete next step: run a full backup, then change a single large file slightly and run again — compare the bytes uploaded on the second run against the file's size. That single test tells you whether the rsync-based incrementals are delivering the savings your data profile needs. You can check current release details and supported backends at duplicity.

Which cloud storage services can duplicity back up to?

Duplicity's own documentation lists a broad set of backends it says have been written for it: Amazon S3, Backblaze B2, Dropbox, FTP, GIO, Google Docs, Google Drive, HSI, Hubic, IMAP, the local filesystem, Mega.co, Microsoft Azure, Microsoft OneDrive, par2, Rackspace Cloudfiles, rclone, rsync, Skylabel, ssh/scp, SwiftStack, Tahoe-LAFS and WebDAV. So if your question is "can it reach my storage?", the practical answer is that most mainstream object stores, consumer file-sync services, and plain server transports are covered, and rclone widens that further because rclone itself fronts many providers.

A useful way to think about the list is by the kind of destination rather than by brand:

  • Object storage: Amazon S3, Backblaze B2, Rackspace Cloudfiles, SwiftStack, Microsoft Azure, Google Docs/Drive-style stores.
  • Consumer sync services: Dropbox, Google Drive, Microsoft OneDrive, Mega.co, Hubic.
  • Plain server transports: ssh/scp, rsync, FTP, WebDAV, local filesystem.
  • Indirect or specialist routes: rclone (which can proxy to providers duplicity has no native backend for), Tahoe-LAFS, IMAP, par2 for redundancy, GIO for mounted locations.

Two caveats matter when choosing. First, the page says many protocols "in theory" could be supported and then lists those "so far" written — that is a statement about backends existing, not a guarantee that every one is equally maintained or equally fast. Second, duplicity encrypts and signs archives with GnuPG before upload, so the storage provider never needs to be trusted with plaintext; that is the main reason to pick duplicity over a provider's own sync client.

As a next step, decide based on how you will restore, not just how you will upload. If you want a provider-agnostic escape hatch, an rclone or ssh/scp target keeps your data in ordinary files you can retrieve without duplicity. If you want the cheapest cold storage, an object store backend fits, but test a restore from a small directory before committing a large backup set. The project's documentation and FAQ pages are the place to confirm the current backend list, since it changes over time.

How do I install and set up duplicity for the first time?

Duplicity is a command-line backup tool that creates encrypted, incremental tar archives and uploads them to local or remote storage. Because it uses librsync, it only records changed parts of files after the first full backup; because it uses GnuPG, the server holding your backups cannot read or alter them. First-time setup therefore has two parts: get the software installed, then create a GPG key and a backup target before you run your first job.

Install it

Pick the method that matches how you manage software on the machine:

  • Distribution package — fastest route on most Linux systems, and the version is maintained alongside your OS. The project warns that if you later move between a distribution package and the tarball/snap build, you should remove or purge the distribution version first, because the two may install in different locations and produce confusing results.
  • Snap — the project documents sudo snap install duplicity --classic for the stable build, with an --edge variant for the latest builds. This is useful when your distribution's version is old.
  • Tarball — the current release is 3.2.1. Use this if you want the newest code or need to build against specific libraries.

Whichever you choose, verify the install by running duplicity --version, then check duplicity --help to confirm which backends your build actually includes. Backend support varies by build and by the Python libraries present.

Prepare the two things duplicity needs

A GnuPG key. Duplicity encrypts and/or signs archives with GnuPG, so create or select a key pair before backing up. If you encrypt to a passphrase-less key you lose protection; if you encrypt to a key whose private key you lose, you lose the backups. Decide now whether you are encrypting to a key you hold (you can restore anywhere) or to a recipient key (safer if the backup host is untrusted but you must keep the private key safe).

A destination. Duplicity supports many protocols, including local filesystem, ssh/scp, rsync, ftp, WebDAV, IMAP, Amazon S3, Backblaze B2, Dropbox, Google Drive, Microsoft Azure and OneDrive, Rackspace Cloudfiles, rclone, Tahoe-LAFS and others. For a first run, a local directory or an ssh target is the least fiddly because credentials are already handled by your system. Remote object stores require you to supply credentials and often a bucket name.

Run a first backup

The shape of the command is: source directory, then destination URL.

duplicity /home/me/Documents scp://user@host//srv/backups/docs

The first run is a full backup. Subsequent runs are incremental and only store changed parts of files. Duplicity records full Unix permissions, directories, symbolic links, fifos and device files, and handles deleted files, but it does not support hard links — worth knowing before you point it at a tree that relies on them.

Set PASSPHRASE in the environment (or use --encrypt-key / --sign-key) so the job can run unattended. Then test a restore immediately, before you trust the setup:

duplicity restore scp://user@host//srv/backups/docs /tmp/restore-test

A backup you have never restored is a guess, not a backup.

Make it repeatable

Once the manual run works, put it in cron or a systemd timer. Keep a retention policy (--full-if-older-than plus remove-older-than) so the archive chain does not grow forever, and store the passphrase somewhere you can reach when the machine you are backing up is gone. For background on the algorithm and the file format, the project's own documentation and FAQ are the primary references: duplicity. If you want to compare approaches before committing, rdiff-backup is a related tool with a different model for keeping history.

A practical decision rule: use a local or ssh destination for your first setup because it removes credential variables, then switch to object storage once restores are proven.

What are the limitations of duplicity, such as hard links or file permissions?

Duplicity handles most Unix metadata well but deliberately skips hard links. Its own documentation states it supports deleted files, full Unix permissions, directories, symbolic links, fifos and device files — but not hard links. In practice, a hard-linked set of files is stored as separate copies, which wastes space and breaks the link relationship on restore.

Two other trade-offs follow from its design:

  • Archive format, not a browsable mirror. Backups are encrypted tar-format volumes, so restoring means running duplicity rather than simply copying files back from the server.
  • Server-side trust is limited by GnuPG. Archives can be encrypted and/or signed so the storage provider cannot read or silently alter them — but if you lose the passphrase, the backup is effectively gone.
  • Incremental chains. Because it uses librsync, only changed parts of files are recorded, which is space-efficient but makes long chains more sensitive to corruption or missing volumes.

Practical decision guide

Need Duplicity fit
Preserve permissions, symlinks, fifos, device files Yes
Preserve hard links No
Encrypted, bandwidth-efficient offsite backup Yes, core strength
Restore by browsing files directly on the server No — use the duplicity client
Very large numbers of hard-linked files (e.g. some mail or VM stores) Poor fit; consider another tool

Example

A sysadmin backing up /etc, /home and a web root to object storage gets permissions and symlinks restored correctly. If /home contains hard-linked maildir files or deduplicated build trees, those links become independent copies, inflating storage and changing behaviour after restore.

Next step

List your hard-linked files first (find /path -samefile or find /path -links +1) and estimate their size. If the total is small, duplicity's encryption and incremental efficiency usually outweigh the hard-link gap; if it is large, choose a backup tool that preserves hard links and keep duplicity for the rest. The project's FAQ and documentation at duplicity cover restore procedures and supported backends in more detail.

How can I restore files from a duplicity backup?

Restoring from a duplicity backup means pointing the duplicity command at the same backend location and telling it which files and which point in time you want back. Duplicity stores encrypted tar-format volumes, so the restore process also needs the GnuPG key or passphrase that was used when the backup was made.

The page describes duplicity as producing encrypted tar-format volumes and uploading them to a remote or local file server, using librsync so incremental archives record only changed parts of files. It also lists many supported backends, including local filesystem, ssh/scp, rsync, Amazon S3, Backblaze B2, Google Drive, Microsoft OneDrive, WebDAV, and rclone. That matters for restore because the first argument you supply is the source URL — the same kind of URL you used for backup.

What a restore looks like in practice

A typical restore command follows this shape:

duplicity restore <source-url> <target-directory>

For example, if you backed up to a local mounted drive, the source URL might be file:///mnt/backup, and the target might be /home/you/restored. If you used a remote backend, the URL will look different depending on the protocol, but the principle is the same: duplicity reads the archive volumes from that location and reconstructs the files into the target directory.

To restore a specific point in time rather than the latest state, use the time options. Duplicity supports restoring as of a given date, for example with --time or -t followed by a date, or by using --restore-time. This is useful when a file was deleted or corrupted after a later backup, and you need the version from before the damage.

To restore only certain files or directories, add --path-to-restore or pass a file pattern. Duplicity can also list what is in the archive before restoring, which is a sensible first step if you are unsure of paths or dates. The page notes that duplicity currently supports deleted files, full unix permissions, directories, symbolic links, fifos, and device files, but not hard links — so a restore will bring back symlinks and permissions, but hard-link relationships will not be preserved as hard links.

A practical decision path

If you are restoring after accidental deletion, start by listing the archive contents and available backup times, then restore the smallest path you need into a temporary directory. Copy the recovered files into place only after you have confirmed they are the right versions. This avoids overwriting newer work with an older snapshot.

If you are restoring an entire system, restore to a separate location first, check ownership and permissions, and then move or sync the data into production. Because duplicity preserves unix permissions and special files, restoring directly over a live system can change permissions on files that are currently in use.

If the backup is encrypted and you do not have the passphrase or private key, the restore cannot proceed. The page is explicit that GnuPG is used to encrypt and/or sign the archives, which protects them from spying or modification by the server — but it also means the key is required to read them.

Where to check details

The duplicity project site at duplicity includes documentation, a FAQ, and the current release information. The page also points to a mailing list for questions and a GitLab project for bug reports. If your restore fails because of a version mismatch, note the page's warning about mixing distribution packages and tarball installs: remove or purge the distribution version before switching, since the two may install in different locations and produce confusing results.

For a concrete next step, run a listing command against your backup URL before restoring anything. That confirms the archive is reachable, the passphrase works, and the date you want is actually present — all before you write files to disk.

Related questions

More questions →
What is duplicity.gitlab.io?
Unknown.
Does duplicity.gitlab.io offer paid content?
Unknown.
What languages does duplicity.gitlab.io support?
Primary language: English.
How can I visit duplicity.gitlab.io?
Use the Visit website link to open the website in a new tab.
What are some alternatives to duplicity.gitlab.io?
Related websites include zperiod.app, zoneless.tools, zerobounce.net, zen.unit.ms, zamzar.com, yt5s.com. Compare their features and pricing for your needs.

Website Overview

Limited stack disclosure and few obvious backend markers suggest a more restrained public footprint. That reduces easy fingerprinting clues but is not proof of overall security. An established domain and managed infrastructure suggest continuity of operations and may support dependable delivery, although neither guarantees service quality.

Domain and Registration

Registered in 2012, this domain has about 14 years of history. That suggests continuity, although ownership and purpose may have changed. Transfer-protection status is present, helping reduce the risk of unauthorized domain transfers. The registrar is Gandi SAS, a widely used domain service provider. The domain uses the common .io extension, which is not an independent safety signal.

DNS and Email

The observed email authentication setup is incomplete: SPF is missing. The lowest TTL is 60 seconds, supporting rapid record changes at the cost of more frequent lookups. Nameservers are provided by Cloudflare, indicating managed DNS hosting. MX records point to the Mailgun email service. CAA records restrict which certificate authorities are authorized to issue certificates.

TLS and Certificates

The certificate issuer is GlobalSign nv-sa, a commercial certificate authority. The certificate uses an RSA 2048-bit public key, offering broad client compatibility. The server supplied a complete certificate chain. No organization name is present in the certificate; the available fields are consistent with domain validation. The certificate is valid for about 394 days in total, with 132 days remaining.

HTTP and Browser Security

The response lacks these common security headers: HSTS, CSP, X-Content-Type-Options, Referrer-Policy, clickjacking protection. No X-Powered-By header was found, reducing one common source of backend fingerprinting information. No obvious internal addresses or debug information were found in the headers. No explicit CDN or WAF marker was found in the response headers. No CORS permission header was found, so browsers normally restrict cross-origin script access.

Technology Stack Analysis

No obvious technology stack is exposed. This may reflect restrained information disclosure, although the underlying technologies remain unknown.

Search and Social Sharing

No homepage meta description was detected, leaving snippet selection more dependent on page text. No viewport meta tag was detected, which may affect mobile layout behavior. The canonical URL points to another host: https://duplicity.us/. Search engines may consolidate indexing signals there. No Open Graph metadata was detected, so social previews may depend on platform inference. The title has 47 characters, within a common display range.

Hosting and Email

DNSCloudflare
HostingGoogle LLC
EmailMailgun
Approximate IP geolocation (inferred; a CDN or proxy may differ from the origin server) United States flagNorth Charleston, South Carolina, United States Inferred 35.185.44.232

Registration details

RDAP / WHOIS

RegistrarGandi SAS
Registered2012-08-22
Expires2027-08-22
Domain statusclientTransferProhibited https://icann.org/epp#clientTransferProhibited
Nameserversmaxim.ns.cloudflare.com、nia.ns.cloudflare.com
DNSSECunsigned

DNS records

DNS

TypeNameValueTTLPriority
Aduplicity.gitlab.io35.185.44.232300—
AAAAduplicity.gitlab.io2600:1901:0:7b8a::300—
MXgitlab.iomxa.mailgun.org30010
MXgitlab.iomxb.mailgun.org30010
NSgitlab.iomaxim.ns.cloudflare.com86400—
NSgitlab.ionia.ns.cloudflare.com86400—
TXTgitlab.io_globalsign-domain-verification=4azHJ7gL04Dr8r2VR0txu7OrWg7uZpU6v7LOHVP1b360—
TXTgitlab.io_globalsign-domain-verification=pZoAzSCaowUllt7Bx5ug4ZHpnHBzvETtlWKa0AousJ60—
CAAgitlab.io0 iodef "mailto:[email protected]"300—
CAAgitlab.io0 issue "comodoca.com"300—
CAAgitlab.io0 issue "digicert.com; cansignhttpexchanges=yes"300—
CAAgitlab.io0 issue "globalsign.com"300—
CAAgitlab.io0 issue "letsencrypt.org"300—
CAAgitlab.io0 issue "pki.goog; cansignhttpexchanges=yes"300—
CAAgitlab.io0 issue "sectigo.com"300—
CAAgitlab.io0 issue "ssl.com"300—
CAAgitlab.io0 issuewild "comodoca.com"300—
CAAgitlab.io0 issuewild "digicert.com; cansignhttpexchanges=yes"300—
CAAgitlab.io0 issuewild "globalsign.com"300—
CAAgitlab.io0 issuewild "letsencrypt.org"300—
CAAgitlab.io0 issuewild "pki.goog; cansignhttpexchanges=yes"300—
CAAgitlab.io0 issuewild "ssl.com"300—
DMARC_dmarc.gitlab.iov=DMARC1; p=none; pct=100; rua=mailto:[email protected];300—

TLS and certificates

TLS / SSL

AssessmentNormal configuration
Supported protocolsTLSv1.2、TLSv1.3
Negotiated protocolTLSv1.3
Certificate subject*.gitlab.io
IssuerGlobalSign nv-sa
Valid until2027-02-15T07:59 · Remaining when checked: 132 days
Verification detailsCertificate trust: Passed · Hostname match: Passed

HTTP response headers

HTTP

HeaderValue
content-typetext/html; charset=utf-8
cache-controlmax-age=600
permissions-policyinterest-cohort=()

Identified technologies

Technology stack: Unknown

Pages, Search and Sharing

Meta descriptionNot detected
Canonical URLhttps://duplicity.us/
LanguageEnglish (default)
Twitter CardNot detected

Unknown

Unknown

No sitemaps found

User reviews (0)

  • No reviews yet.