How to Find Stray Backup Files on Your Mac

The backup paradox: you make copies to be safe, then forget where you put them. Months or years later, your Mac has multiple backup files of the same data scattered across Documents, Desktop, external drives that became internal again, and folders named things like “old stuff” or “backup before reformat.”

These stray backups can take serious space. A duplicated Photos library is 100+ GB. A copy of an entire project folder is hundreds of MB. A Time Machine local snapshot is whatever your daily churn happens to be — often 5-30GB.

Here’s how to find every backup-shaped thing on your Mac.

What counts as “a backup file”

For finding purposes, backups fall into a few categories:

• Manual copies of important files or folders, often with names like “backup,” “copy,” “old,” “v2,” dated filenames.
• App-generated backups like .bak files, .old files, version-suffixed copies.
• Time Machine local snapshots held on your internal drive.
• Disk image backups — sparsebundles or DMGs containing copied data.
• Cloud sync conflict files — Dropbox, OneDrive, Google Drive create these when sync conflicts occur.
• Database backups — .sqlite-journal, .db.bak, exported .csv files.

Smart Folder for naming patterns

Many manual backups follow predictable naming. Open Finder, choose File → New Smart Folder. Click “This Mac.” Hit + to add criteria.

Set Kind = Any. Then click + again and change to “Name” matches “backup.” This catches files and folders with “backup” in the name.

For broader coverage, build separate Smart Folders for:

• Name contains “backup”
• Name contains “old”
• Name contains “_copy”
• Name contains “(copy)”
• Name contains “_v2”, “_v3”, etc.
• File extension = “bak”

You can also Cmd-click multiple criteria and use OR logic by holding Option when adding criteria.

Finding .bak and version files via Terminal

find ~ -type f \( -name "*.bak" -o -name "*.backup" -o -name "*.old" -o -name "*~" \) 2>/dev/null

That covers the most common backup-suffix patterns. The *~ form is used by Unix editors as a temporary backup. With sizes:

find ~ -type f \( -name "*.bak" -o -name "*.backup" -o -name "*.old" \) -exec du -h {} + 2>/dev/null | sort -hr | head -50

To find everything that looks like a versioned copy:

find ~ -type f -name "* copy*" 2>/dev/null

That catches “Document copy.pdf”, “Project (copy 2).zip”, and similar patterns Finder creates when you duplicate.

Time Machine local snapshots

These are invisible to Finder but real on disk. List them:

tmutil listlocalsnapshots /

You’ll see entries dated by hour. macOS keeps these for up to 24 hours by default, even when no Time Machine drive is connected.

Each snapshot can hold 5-30GB depending on your daily file churn. They show as Purgeable in Storage settings, meaning macOS can release them under pressure — but they’re still using space until then.

Force thinning:

tmutil thinlocalsnapshots / 999999999999 4

That requests aggressive thinning. The “999999999999” is a target free space in bytes (effectively unlimited) and “4” is urgency level (1-4, higher = more aggressive).

Delete a specific snapshot:

sudo tmutil deletelocalsnapshots [date-string-from-list]

Disk image and sparsebundle backups

Backup utilities often create sparsebundles or DMGs. Find them:

find / -type d -name "*.sparsebundle" 2>/dev/null
find ~ -type f \( -name "*backup*.dmg" -o -name "*Backup*.dmg" \) 2>/dev/null

Common locations include external drives, network shares, and ~/Library/Application Support folders for backup apps.

For sizes:

find ~ -type d -name "*.sparsebundle" -exec du -sh {} + 2>/dev/null

If you find a sparsebundle from an old machine that no longer exists or a backup destination you no longer use, those are deletion candidates after verifying you won’t need the data.

Skip the manual huntSweep finds the largest, oldest, most-forgotten files in seconds. Download Sweep free →

Cloud sync conflict files

Sync clients create conflict files when the same file changes in two places before sync.

Dropbox uses patterns like Filename (Username's conflicted copy 2024-03-15).docx.

find ~/Dropbox -type f -name "*conflicted copy*" 2>/dev/null

Google Drive typically just lets one version win, but on Drive for desktop you may see (1) or (2) suffixes:

find ~/Library/CloudStorage -type f -name "* (1).*" 2>/dev/null

OneDrive generates Filename-DESKTOP-ABC123.docx patterns when conflicts occur:

find ~/Library/CloudStorage -type f -name "*-DESKTOP-*" 2>/dev/null

These conflict files almost always represent stale versions you didn’t intend to keep. Compare with the canonical version, keep the right one, delete the rest.

Database journal and backup files

If you’ve used SQLite-based apps (most modern apps), you’ll see .sqlite-journal, .sqlite-wal, .sqlite-shm files:

find ~ -type f \( -name "*.sqlite-journal" -o -name "*.sqlite-wal" -o -name "*.sqlite-shm" \) 2>/dev/null

These are usually managed by the app and shouldn’t be deleted manually unless the corresponding app is uninstalled. Active databases need their journal/WAL files for transaction integrity.

For .sqlite-journal files in folders for apps you’ve uninstalled, deletion is safe.

Photo library copies

People back up Photos libraries by duplicating the .photoslibrary file. Each duplicate is potentially huge.

find / -name "*.photoslibrary" 2>/dev/null

If you find more than one, check the dates. Old duplicates from before a specific event (a Mac transfer, a major iCloud change, a phone backup) can be deleted if the current Photos library has everything you need.

To check size of each:

find / -name "*.photoslibrary" -exec du -sh {} + 2>/dev/null

Old project versions

Manual versioning is common with creative work. You’re working on a video, save as “Project_v1.fcpbundle”, later save “Project_v2.fcpbundle”, and never delete v1.

Search for common pattern:

find ~ -type d \( -name "*_v1*" -o -name "*_v2*" -o -name "*_old*" -o -name "*_archive*" \) 2>/dev/null

For Final Cut libraries, Logic projects, Photoshop PSDs with version suffixes, the old versions are usually safe to delete once the project is shipped.

There’s a faster waySmart Folders work but take setup. Sweep does the same hunt instantly. Try Sweep free →

App-specific backup features

Some apps have their own backup mechanisms that quietly accumulate data:

Pages, Numbers, Keynote keep version history inside the .pages, .numbers, .key bundles. To see versions: File → Revert To → Browse All Versions. Old versions can be cleared by saving as a new file.

Keynote in particular accumulates “Backup of [filename]” copies in the same folder. These can be deleted if the main file works.

Bear, Notes, Ulysses keep databases in their support folders. Don’t delete from there, but check for old export folders.

Mail keeps “import” folders from past migrations. ~/Library/Mail/V10/Mailboxes can have outdated subfolders.

What to actually delete

Decision tree for any backup-shaped file:

1. Is the canonical version of this data accessible elsewhere? (Cloud, current Mac, external drive)
2. When was this backup made? Older than the last system migration?
3. Does the filename suggest a specific event (e.g., “before reinstall”)?
4. Have I needed this in the last year?

If all signs point to “redundant,” delete. If any uncertainty, move to an external before deleting.

For Time Machine local snapshots specifically, deletion is low-risk — your real Time Machine backup (on the external drive) has the same data.

For disk image backups, mount and verify contents first. Some of these are old but contain irreplaceable data; others are exact duplicates of folders still on the Mac.

A coherent backup strategy beats backup files

The actual fix for backup-file accumulation is a real backup strategy. Pick one:

• Time Machine to a dedicated external drive. Set it and forget it. Don’t manually duplicate files; let Time Machine handle versioning.
• Cloud backup service (Backblaze, Carbonite, Arq). Continuous, off-site, no local clutter.
• iCloud Drive + occasional manual exports for specific irreplaceable items.

Manual file duplication is the worst of all worlds: takes space, lacks structure, gets forgotten.

Building a sweep into routine cleanup

Stray backups don’t accumulate continuously, but they appear at predictable moments: before major OS upgrades, after data scares, during project handoffs. Cleaning them out a few times a year is enough.

A cleaning tool catches naming-pattern-based duplicates and old archives in normal scans. Time Machine local snapshots usually need their own dedicated handling — most people don’t even know they exist until they see “Purgeable” space they can’t account for.

Either way, the goal is the same: have one good backup strategy, then delete every accidental backup that built up in its absence.