How to back up your videos on Linux

Videos are the heaviest things most of us keep on a computer. Not emotionally (though… also yes), but in pure gigabytes-per-minute. One “quick” weekend trip can turn into 200GB of 4K footage, three drone clips you’ll never edit, and a folder called final_final_REAL_final that would make any filmmaker cry.

The good news: Linux gives you ridiculously powerful backup optionsfrom simple external-drive copies to encrypted, deduplicated snapshot systems that could survive a small meteor strike. The trick is picking a method that’s realistic for your life, not just impressive on a forum thread.

This guide walks you through multiple ways to back up your videos on Linux (local, off-site, and cloud), with specific commands, practical retention ideas, and a “restore test” mindsetbecause a backup you haven’t tested is just a comforting story you tell yourself at night.

Why video backups are different (and why that matters)

Backing up videos isn’t the same as backing up documents. Video files are often:

• Huge (so speed and storage costs matter)
• Mostly append-only (new clips are added; old clips rarely change)
• Metadata-sensitive (timestamps, folder structure, project files, and sidecars matter)
• Time-critical (you usually discover you need a backup right after something goes wrong)

That leads to a smart default strategy: follow the 3-2-1 rulekeep 3 copies of your data, on 2 different types of storage, with 1 copy stored off-site. For video, that might look like: your laptop + an external drive + cloud storage (or a drive stored elsewhere).

Step 1: Get your video library under control (future you will tip you)

Before you copy anything, make sure you know what you’re backing up. Many people have videos scattered across Downloads, SD-card imports, random desktop folders, and editing projects.

Find where the space is going

Run these from your home directory to locate your largest folders:

If you want to find video file types quickly:

Create a clean “source of truth” folder

Ideally, you’ll end up with something like:

• ~/Videos/CameraImports/
• ~/Videos/Projects/ (editing timelines, assets, exports)
• ~/Videos/Exports/
• ~/Videos/Archive/ (older footage you rarely touch)

Backups become dramatically easier when your “stuff that matters” lives in a predictable place.

Step 2: Pick your backup style (mirror vs snapshots vs archives)

Most Linux video backup plans fall into three buckets:

1) Mirror copy (simple, fast to understand)

A mirror backup makes the destination look like the sourcegreat for a single external drive. The risk: if you accidentally delete a folder, a mirror may faithfully delete it in the backup too (depending on options).

2) Snapshots (best for “oops” moments)

Snapshot-style backups keep versions over time. Tools like restic and BorgBackup store multiple “points in time” so you can restore last week’s folder even if today’s folder is a mess.

3) Archive copies (good for long-term cold storage)

Archives are for footage you won’t touch often (completed projects, old camera rolls). You might keep them on a separate drive, NAS, or cheaper cloud tier.

Method A: External drive + rsync (the Linux “pickup truck” approach)

If you want a straightforward way to back up your videos on Linux, rsync is hard to beat. It copies only what changed, can preserve permissions/timestamps, and works locally or over SSH.

1) Mount your backup drive

Plug in your drive and make sure it mounts (many desktops auto-mount). If you prefer a stable mount location, you can mount it under /mnt or /media, depending on your setup.

2) Do a “safe first run” without deletions

This command copies your Videos folder to the drive. It’s intentionally conservative for the first run.

• -a archive mode (preserves timestamps, permissions, etc.)
• -v verbose
• -h human-readable
• --progress shows progress per file

3) If you want a true mirror, add deletion (with care)

When you’re confident your destination is correct, you can mirror the source by adding --delete. This removes files from the backup that no longer exist in the source. That’s great for staying tidy, but it also means your backup will mirror mistakes.

Pro tip: Use a dry run first to preview deletions:

4) Want “Time Machine vibes” on Linux?

Plain rsync is a mirror, but you can create snapshot-like backups using hard links (or use a helper script that structures that for you). The idea is: each backup run creates a dated folder; unchanged files are hard-linked so they don’t take extra space.

That gives you quick restores (“grab the folder from last Tuesday”) without storing duplicate copies of huge video files.

Method B: Restic (encrypted, deduplicated snapshotsamazing for video libraries)

If you want proper versioned backups, restic is a favorite in the Linux world because it’s relatively simple to operate, supports many storage backends, and encrypts by default.

1) Install restic

Most distros have restic in package repos. Use your distro’s package manager when possible.

2) Initialize a repository on an external drive

You’ll set a passwordstore it safely (password manager recommended). If you lose it, you lose the ability to restore. Restic is not kidding around.

3) Back up your videos (and exclude junk)

For video workflows, exclusions usually focus on caches and generated preview files. Keep originals, project files, exports, LUTs, and audio assets.

4) Set a retention policy (so backups don’t eat your drive)

A practical retention strategy for videos might keep frequent backups for recent changes and fewer long-term points-in-time:

5) Verify and test restores

Restic can check repository integrity:

And you should practice restoring a folder (seriously). For example:

Method C: BorgBackup (fast, efficient, especially good for lots of versions)

BorgBackup is another excellent snapshot tool. It’s known for deduplication, compression, and authenticated encryption. For large video collections, dedup helps most when your workflow produces repeated exports or similar files, and snapshots help most when you want to roll back.

1) Create a Borg repository

2) Create backups (archives)

3) Prune old backups with a sane schedule

A quick filesystem note (important for external drives)

If your backup drive is formatted as FAT/exFAT for compatibility, some backup tools can behave less efficiently due to how metadata/inodes are handled. For Linux-first backups, an ext4-formatted backup drive is often smoother. If you need cross-platform access, consider a separate “transfer drive” and keep your backup drive Linux-native (and ideally encrypted).

Method D: Cloud backup with rclone (because off-site is the point)

An off-site copy protects you from theft, fire, accidental coffee-related incidents, and “my cat knocked the drive off the desk.” For Linux, rclone is the Swiss Army knife for pushing backups to cloud storage.

1) Configure a cloud remote

Run:

Then connect to a provider (Google Drive, S3-compatible storage, etc.). Once configured, you’ll have a remote name like gdrive: or s3:.

2) Choose copy vs sync

• copy: uploads new/changed files, doesn’t delete anything on the destination (safer)
• sync: destination becomes a mirror (powerful, but can also mirror mistakes)

Safer “add-only” approach for video backups:

If you want metadata support where available (and your backend supports it), you can include metadata syncing. For very large sets, consider adding bandwidth limits during work hours.

3) Encrypt before the cloud (optional but recommended)

If you don’t want your cloud provider holding readable copies of your footage, use client-side encryption:

• Use restic (encryption built-in) to a cloud backend
• Or use rclone’s crypt remote layered on top of a cloud remote

In plain English: your cloud becomes a vault of scrambled files only you can unlock.

Method E: Remote/NAS backups over SSH (the “second machine” plan)

If you have a NAS, a home server, or a friend who owes you a favor and has a spare drive, remote backups are great. Over SSH, rsync and Borg can back up to another Linux box with minimal drama.

rsync to a remote machine

Borg to a remote repo

Borg can store the repository remotely and keep your backup history tidy with pruning. It’s a popular pattern for people who want off-site control without paying recurring cloud costs.

Automation: Make backups boring (boring is good)

The best backup plan is the one that runs when you’re busy living your life. You can schedule backups with:

• cron (classic, simple)
• systemd timers (modern Linux, great logging and dependency handling)

A simple cron example

Edit your crontab:

Run a nightly rsync at 2:15 AM:

Why many Linux users like systemd timers

Timers can be more transparent than cron: you can list them, inspect logs, and tie them to services. They’re also friendly to laptops (e.g., “run when the machine is available,” depending on setup).

Verification: The unglamorous step that saves you

You don’t want to learn about corruption during a deadline. Add verification habits:

• Spot-check restores: restore a folder monthly, open files, verify playback
• Integrity checks: run restic check or Borg verification occasionally
• Checksums for archives: keep a checksum list for “cold storage” exports

Example: create checksums for a folder you plan to archive:

Later, verify:

Security: Encrypt your backups (especially portable ones)

External drives are easy to lose. If your backup drive leaves your house (or even your desk), encryption is your friend.

Practical encryption options on Linux

• LUKS for full-disk or partition encryption (great for external drives)
• restic/Borg encryption at the backup-tool layer
• rclone crypt for client-side encrypted cloud storage

Tip: Don’t store your only copy of the encryption key on the same drive you’re encrypting. That’s like locking your keys inside your car and then congratulating yourself on vehicle security.

Retention and cost control: Keep what matters, delete what doesn’t

Video backups can balloon quickly. Your goal is to keep enough history to recover from mistakes, not to preserve every accidental screen recording from 2021.

A sane retention model for video creators

• Daily backups for the last 2 weeks (active editing period)
• Weekly backups for the last 2 months
• Monthly backups for the last year (or longer for professional work)
• Archive finished projects to a separate “cold storage” location

If you’re using object storage (like S3-style services), lifecycle rules can transition older data to cheaper storage tiers or enforce clean-up policieshelpful when your archive starts to look like a museum.

Restore strategy: The part everyone skips until they can’t

A good restore plan answers these questions:

• If your laptop dies today, what’s the first folder you restore?
• How long will it take to restore your core projects?
• Where are your passwords/keys stored?
• Can you restore to a different machine (and a different folder) without overwriting good data?

Do one “fire drill” restore on a weekend. It’s slightly annoyinglike testing a smoke detectoruntil the day it isn’t optional.

Conclusion

To back up your videos on Linux, you don’t need a complicated setupyou need a repeatable one. Start with an external drive and rsync for a fast local safety net. Then add an off-site layer using rclone to a cloud provider or a remote Linux machine. If you want versioned history and strong security, restic or BorgBackup turn your backup strategy into something that can survive mistakes, not just hardware failure.

The winning formula is boring on purpose: automate it, verify it, and practice a restore now and then. That way, your future self can spend time editing videosnot starring in a tragic documentary titled “Where Did My Footage Go?”

Bonus: 7 real-world lessons from backing up video on Linux (about )

The first time you set up video backups, it’s tempting to overbuild. You start browsing tools, reading opinions, and suddenly you’re debating deduplication algorithms like you’re auditioning for a Linux conference panel. The most useful lesson? A “good enough” backup that runs automatically beats a perfect backup you keep postponing.

One common experience in video workflows is the “export explosion.” You begin with raw camera files, then generate proxies, preview renders, audio waveforms, thumbnails, and multiple exports in different formats. If you back up everything blindly, your storage fills up with junk that can be regenerated. Over time, many Linux users learn to separate irreplaceable inputs (raw footage, project files, custom assets) from rebuildable outputs (cache folders, proxy media you can recreate, preview renders). Tools like restic and Borg make it easy to back up whole folders, but your long-term sanity depends on thoughtful exclusions.

Another classic moment: the accidental deletion. It’s not dramaticjust a late-night cleanup where you remove a folder that “looks duplicated.” If you use a strict mirror sync with deletion enabled, your backup can quietly match that mistake. This is why experienced folks often do “copy-only” uploads to cloud storage, keep snapshots with restic/Borg, or at least run dry-run previews before a destructive sync. The best setups make it easy to recover from human error, because humans keep showing up to the computer.

Speed becomes personal when you start backing up terabytes. The first big upload is slow, and it’s normal to feel like your internet is moving your files using carrier pigeons. The practical fix is to seed locally first: external-drive backup for immediate protection, then let cloud syncing run overnight for the off-site copy. Many people also learn to tune transfer counts, set bandwidth limits during work hours, and avoid constantly “re-touching” files that forces re-uploading. A stable folder structure and consistent naming can shave days off a large migration.

Drive format and encryption are also “experience teachers.” People often start with an exFAT drive because it works everywhere. That’s fine for simple copies, but Linux-native filesystems can behave more predictably for preserving metadata and running snapshot tools efficiently. Once you’ve lived through the gut-punch of losing a driveor just realizing it could get stolenencryption stops being an abstract security hobby and becomes common sense. LUKS (or tool-level encryption) turns a lost drive into an inconvenience, not an incident.

Finally, the biggest “level up” is the restore drill. The first time you restore a project and it actually opens cleanlymedia linked, timelines intact, exports presentyou gain the kind of calm confidence that no backup tool marketing page can sell. Once you’ve done it, you’ll never again call something a backup until you’ve restored a file from it. That’s the point where your Linux video backup stops being a theory and starts being a system.