You ran your phone's built-in duplicate check, merged everything it found, and your camera roll still looks like a flip-book: eight nearly identical group shots, six takes of the same sunset, a dozen burst frames of the dog mid-jump. That's not a bug in the duplicate finder — it's a definition problem. Those photos aren't duplicates. They're similars, and finding them takes a different kind of tool: a similar photo finder.
This guide explains the difference, why it matters more than you'd think for storage, how similarity detection actually works under the hood (in plain language), and your realistic options — from built-in tools through third-party apps, including our own, to a purely manual workflow if you'd rather install nothing.
A similar photo finder detects near-identical shots — retakes, bursts, slight angle changes — that exact-duplicate tools miss. It works by comparing visual fingerprints of images (perceptual hashing) rather than file data, groups look-alike photos together, and helps you keep the best shot from each group while deleting the rest.
Duplicates vs. similars: the distinction that matters
Exact duplicates are the same image saved more than once: a photo saved twice from a chat, re-imported after a restore, or exported and re-saved. Same pixels, often the same file. Built-in tools catch these well because the comparison is mechanical.
Similar photos (near-duplicates) are different photos of the same moment:
- The five retakes you shot to get one where everyone's eyes were open
- Burst sequences — ten frames a second of one action
- The same landscape at three zoom levels
- "One more just in case" — the second, insurance shot of everything
- Screenshots of the same screen taken twice
Every file is genuinely unique — different pixels, different timestamps — so a byte-level comparison sees nothing to merge. Yet to you, they're one moment wearing eight file sizes. In most libraries, similars vastly outnumber exact duplicates, which is why merging duplicates alone barely dents your storage. Retake clusters are the real bulk.
Why the built-in Duplicates album misses them
Apple's Photos app includes a Duplicates album (under Utilities) that detects and merges copies of the same photo — see Apple's Photos support pages for how it handles merging. It's genuinely good at its job, and you should absolutely run it first: it's free, safe, and takes minutes. We walk through it in our duplicate deletion guide.
But its job is duplicates. Apple draws the line conservatively — it will match a photo against a resized or slightly re-compressed copy of itself, but it deliberately won't flag two different photos of the same scene. That's a defensible design choice (nobody wants the system merging genuinely distinct photos), but it leaves the retake problem entirely to you. Google Photos comes at it from a different angle — it can stack similar shots in your view — with its own limits, which we cover in our guide to deleting similar photos in Google Photos.
How similarity detection actually works (plain-language version)
The standard technique is called perceptual hashing, and the idea is simpler than the name.
A regular file hash answers "are these files identical?" — change one pixel and the answer flips to no. Useless for retakes. A perceptual hash instead answers "do these images look alike?" Roughly, the algorithm:
- Shrinks each photo to a tiny thumbnail, throwing away fine detail and keeping the broad structure — where the light and dark regions are, the dominant shapes and gradients.
- Converts that structure into a compact fingerprint — a short string of bits that encodes the image's visual essence.
- Compares fingerprints between photos. Nearly identical scenes produce nearly identical fingerprints; the number of differing bits becomes a similarity score.
- Clusters photos whose scores fall within a threshold, usually restricted to photos taken close together in time — which is why your six sunset takes group together, but a similar-looking sunset from last year doesn't.
Two properties worth understanding as a user. First, thresholds are judgment calls: set strict, the tool misses some retakes; set loose, it occasionally groups photos you consider distinct — which is why any good tool asks you to confirm rather than auto-deleting. Second, none of this requires the cloud. Perceptual hashing is computationally cheap enough to run entirely on your phone, so treat "requires upload" as a red flag, not a technical necessity.
The better tools add a second layer: within each group, scoring which shot to keep — penalizing blur, closed eyes, poor exposure — and pre-selecting the rest for deletion. That turns a grouping tool into an actual time-saver.
Your options, honestly compared
Option 1: Apple Photos (free, exact duplicates only)
Run the Duplicates album first, always. It won't touch similars, but it clears the mechanical copies for free and reduces what any other tool has to process.
Option 2: Google Photos (free, if you back up there)
Google Photos can stack similar shots taken together so your timeline shows one representative photo per cluster. Helpful for viewing; less directly a cleanup tool, and its deletions interact with backup in ways worth understanding before you bulk-delete (see our Google Photos guide). Most relevant if Google Photos is already your primary library.
Option 3: A dedicated similar photo finder — including our own
Third-party cleaner apps are where true similar-detection for your on-device library lives. Disclosure up front: Sweep is our own app, so read this knowing who's talking.
Sweep (free, iOS) includes a similar photo finder built on on-device perceptual hashing — photos never leave the phone, and no account exists to leak anything. It groups near-identical shots and suggests the best one in each group to keep; you confirm, and everything you discard goes through a review basket, one native iOS confirmation, and the standard ~30-day Recently Deleted window. Its honest limits: iOS only, and the similarity scan covers your most recent ~5,000 photos — recent-history focused, not a deep-archive excavator. The finder sits in the premium tier (one upgrade, alongside compression and unlimited swipes); the free tier still gives you swipe triage of 100 photos a day, which is itself a workable manual similar-hunt.
Other cleaner apps on the App Store offer similarity scanning too, and quality varies widely. Whatever you evaluate — ours included — apply the same tests: processing on-device? Groups similars or just duplicates? Suggests a keeper? Shows a review step before anything is deleted? Our cleanup app checklist expands each of those into what good looks like.
Quick comparison
| Exact duplicates | Similar/retakes | Suggests keeper | Where it runs | |
|---|---|---|---|---|
| Apple Photos Duplicates | Yes | No | Merges automatically | On-device |
| Google Photos stacks | Partial | Groups in view | Picks a top shot | Cloud library |
| Sweep (our app) | Yes | Yes | Yes | On-device |
| Manual workflow | Yes (slowly) | Yes (slowly) | You are the algorithm | Your thumbs |
The manual fallback: no app required
Perfectly valid, especially for smaller libraries — you're a better judge of "best shot" than any algorithm; you're just slower.
- Merge exact duplicates first in Photos > Utilities > Duplicates.
- Clear bursts: burst photos cluster automatically — open each burst, pick your favorite frame(s), and let Photos discard the rest.
- Work by event: similars live in time-clusters, so scroll a day at a time. When you hit a retake cluster, open the first shot full screen and flick through the cluster.
- Apply the one-keeper rule: best shot survives, the rest get deleted. If you can't choose between two, keep both and move on — perfectionism is the enemy of finishing.
- Lean on the safety net: deleted shots sit in Recently Deleted for about 30 days, so decide fast and trust that mistakes are recoverable.
Budget roughly an evening per few years of moderate photo-taking. iPhone-specific tactics are in our companion piece on finding similar photos on iPhone.
FAQ
What's the difference between a duplicate photo finder and a similar photo finder?
A duplicate finder matches copies of the same image file — same pixels, mechanically detectable. A similar photo finder compares what images look like, using perceptual fingerprints, so it also catches retakes, bursts, and near-identical shots that are technically different files. For most libraries the similars represent far more wasted space than the true duplicates.
Is perceptual hashing safe and private?
The technique itself runs fine on a phone's own processor — it's cheap math over shrunken thumbnails. Privacy depends on the implementation: an on-device tool never transmits your photos, while a cloud-based one does. Since on-device similarity detection is entirely practical, there's little reason to accept uploading your camera roll for this job.
Will a similar photo finder delete photos automatically?
A trustworthy one won't. The honest workflow is: the tool groups look-alikes and suggests keepers; you confirm what goes; deletion happens through the system with a confirmation, and on iOS everything then sits in Recently Deleted for about 30 days. Treat any tool that auto-deletes without review as disqualified.
Why does my phone still show near-identical photos after removing duplicates?
Because near-identical isn't duplicate. Built-in duplicate detection compares images against copies of themselves, not against other photos of the same scene. Retakes and burst shots pass that test untouched — clearing them takes either a similarity-based tool or a manual pass through each event.
How many photos of the same moment should I keep?
One, as a rule — two when a genuine tie exists or when different people are the subject of different frames. The test that cuts through indecision: if you were showing someone this moment, which single photo would you open? That's the keeper; the others are storage.
