Make a verified offline archive of your phone photos (iPhone and Android)

You want your phone’s photos somewhere safe that you control, maybe so you can free up space or cancel a cloud plan. The copy looks fine. Then a year later you notice that half of 2019 is blurry thumbnails, or the videos are missing, or every file is dated the day you copied it.

This guide gets everything off the phone at full quality onto a computer, copies it to an external drive, and then proves the copy is complete before you delete a single thing.

Stop if: you’re planning to delete photos from the phone or the cloud “once the copy finishes”. Don’t delete anything until every check in Step 5 passes on every copy. With iCloud Photos, Apple says deleting a photo on one device deletes it everywhere you use iCloud Photos. Google says deleting a backed-up item in the Google Photos app deletes it on all devices with backup turned on. The item leaves your cloud library as soon as that deletion syncs. The 30-day trash (Recently Deleted on iPhone, Trash in Google Photos) is only a recovery window. After it ends, the item is gone for good.

Step 1: Find out where your originals actually are

Before copying, work out where the full-quality files live. Usually it isn’t where you’d guess.

iPhone with iCloud Photos: the “Optimize Storage” trap

Apple’s own storage page says that with Optimize iPhone Storage on, your full-resolution originals live in iCloud and the phone keeps smaller, space-saving versions. Apple even suggests turning it on to save space, so many phones have it on. If you plug that phone into a computer, you may only get what’s on the phone. Microsoft warns that photos stored only in iCloud may not download to a PC over USB.

Check it: Settings > [your name] > iCloud > Photos. In iOS 27 and later, also tap iPhone Storage to see the choice. If it’s set to Optimize, use one of these to get the originals:

1. Switch the phone to keep originals, then wait for the downloads to finish (you need enough free space on the phone). Apple’s wording for the option varies between iOS versions, so pick the one that keeps full originals on the device.
2. Use a Mac with Photos. In Photos > Settings > iCloud, choose Download Originals to this Mac. The Mac then holds full-size copies, which you export in Step 3.
3. Download from iCloud.com/photos. You can select up to 1,000 items at a time. Under More > More Download Options, choose Unmodified Originals (Apple says this is the format as it was captured or imported). Don’t use Most Compatible, which gives you converted JPEG or H.264 files.
4. Apple’s data copy. At privacy.apple.com, sign in and choose Request a copy of your data. Apple says photos and videos come in their original formats. It doesn’t give a turnaround time, the option isn’t available in every country, and you get 14 days to download the copy once it’s ready. Apple also says data it stores end-to-end encrypted (which it can’t decrypt) isn’t included, so if you use Advanced Data Protection, use one of the methods above instead.

Android with Google Photos: Storage saver and Takeout

Google Photos backs up at one of three qualities. Original quality keeps your files as they were. Storage saver shrinks photos over 16 MP to 16 MP and videos above 1080p to 1080p. Express (where it’s offered) goes down to 3 MP and 480p. In the app, tap your profile picture, then go to Google Photos settings > Backup > Photos & videos quality.

Gotcha: the setting you see today only controls future uploads. It doesn’t tell you what quality older items were stored in. To check an item, open it on photos.google.com and click Info. The backup quality and size are listed under Details. Check a sample from each year. Anything stored as Storage saver or Express is a reduced copy in the cloud, and Google’s help doesn’t describe a way to get the original back. If the original is still on the phone, copy that one over USB in Step 3.

To get your whole cloud library, use Google Takeout (takeout.google.com) and select Google Photos. Takeout gives you the versions Google stored. Anything backed up in Storage saver or Express comes out at that reduced quality. The key facts from Google’s help:

• Pick zip (opens anywhere) or tgz, and an archive size. If your library is bigger than the size you pick, it’s split into several files. Choosing 50 GB reduces the splitting.
• Each archive expires after about 7 days and can be downloaded up to 5 times.
• Google warns that the export may not include changes made after you requested it, such as photos you added or deleted. Don’t take new photos you care about and then delete them from the phone on the strength of an older export.
• Embedded metadata keeps the original timestamps, but your computer may give the downloaded file a new date. Extra information that isn’t part of the file (Google gives comments as an example) goes into separate JSON files next to the photos.

Download and extract every part. Download every archive file in the export, not just the first one. Extract all of them into one folder so the folder structure stays intact, and make sure none report an error. Keep the folders and the JSON files exactly as they come out. Run the counts and checksums in Step 5 on the extracted photos and videos. A checksum of a zip only proves the zip copied correctly. It doesn’t prove every part arrived or that the photos inside extract.

Note: keep the JSON files in your archive even if they look like clutter. Some of your photo information may exist only in them, and photo tools can read them later.

Step 2: Set the phone up for a clean copy

iPhone: HEIC/HEVC and “Keep Originals”. iPhones usually shoot HEIF/HEIC photos and HEVC video. Apple says that when you import these over USB into Photos, Image Capture or a PC, they may be converted to JPEG or H.264. To stop that, Apple says: open Settings > Apps > Photos, scroll down, and tap Keep Originals (it’s under the section for transferring to a Mac or PC). For an archive you want the untouched originals, so choose Keep Originals.

Note: to view HEIC/HEVC on Windows, Microsoft points you to the HEIF (free) and HEVC (paid) extensions in the Microsoft Store. Apple’s tip of setting Settings > Camera > Formats > Most Compatible only affects new shots. It doesn’t change files you’ve already taken.

Android: USB mode. Unlock the phone and plug it in. Tap the Charging this device via USB notification and, under Use USB for, choose File Transfer. Camera photos are normally in the DCIM folder (usually DCIM/Camera). Screenshots and app pictures (messaging apps, downloads) are often in other folders, so look in Pictures too.

Step 3: Copy to a plain folder on the computer

Use a plain folder (not just a photo-app library) so the checksums in Step 5 work on ordinary files. The examples use ~/PhoneArchive/2026-11 on a Mac or Linux machine and C:\PhoneArchive\2026-11 on Windows.

Mac, Image Capture (simplest for a folder): connect the iPhone, unlock it and tap Trust if asked. Select it under Devices. Set Import To to your folder (choose Other), then click Download All. Leave Delete after import off. Apple notes that a Live Photo downloads as two files, a still and a video. It also says that on macOS 15.4 or later, items in the Hidden album won’t be imported if that album is locked. Opening the album with Face ID on the phone isn’t enough. Apple’s fix is to go to Settings > Apps > Photos on the iPhone and turn off Use Face ID (or Use Touch ID / Use Passcode) for the import. Turn it back on when you’re done.

Mac, Photos app: importing with Import All New Items puts photos in your Photos library, not in a folder. To get files out, select everything and choose File > Export > Export Unmodified Original. Apple says this exports each item in the format it was imported in, and that a Live Photo again becomes two files.

Windows, Photos app: for an iPhone, install Apple Devices from the Microsoft Store first. Connect, unlock, tap Trust/Allow, open Photos, select Import, choose the device, pick the items and the destination folder, and let it finish.

Android to Windows: with File Transfer on, the phone appears in File Explorer. Copy the DCIM folder (plus any other picture folders you want) into your archive folder.

Edited photos. Apple says iCloud.com’s Unmodified Originals download doesn’t include your edits, and that Export Unmodified Original on a Mac gives you the file as it was imported. If your edits matter, also export the edited versions into a separate subfolder (for example edited/) so the two never get mixed up.

Step 4: Copy the folder to the external drive

Copy the whole archive folder to the external drive with Finder or File Explorer, for example to /Volumes/PhotoBackup/PhoneArchive/2026-11 or E:\PhoneArchive\2026-11. Don’t reorganise or rename anything on one copy only. The manifest you make next records the file paths.

Step 5: Prove nothing is missing

There are two separate questions here, and each needs its own check:

1. Is the export complete? Did every photo and video on the phone or in the cloud make it into your folder? Only counting against the source (5a) answers this.
2. Did the copies come through intact? Is every file on the computer and on each drive byte-for-byte identical? Checksums (5c and 5d) answer this. A checksum can’t tell you about a photo that was never exported in the first place.

5a. Reconcile the counts against the phone or cloud

Your phone’s Photos app shows how many photos and videos you have (where it shows the count varies by app and version). For a Takeout export, count the extracted folder. On the computer, count the files by type:

SRC="$HOME/PhoneArchive/2026-11"
cd "$SRC" && find . -type f ! -name '.DS_Store' ! -name 'manifest.sha256' | wc -l     # total files
cd "$SRC" && find . -type f ! -name '*.json' | sed 's/.*\.//' | tr 'A-Z' 'a-z' | sort | uniq -c   # by extension

$ErrorActionPreference = 'Stop'
$root = 'C:\PhoneArchive\2026-11'
$all = @(Get-ChildItem -LiteralPath $root -Recurse -File -Force)
$all.Count
$all | Group-Object -Property Extension -NoElement | Sort-Object -Property Count -Descending

-Force makes PowerShell include hidden files. With $ErrorActionPreference = 'Stop', a folder it can’t read stops the command with an error instead of being skipped silently. Treat that as a failure and fix it before going on.

The file count won’t match the phone’s count 1:1, so reconcile it rather than just checking that it’s “big enough”:

• Live Photos come out as two files, a still and a .mov. If your copy method gives both files the same base name (check a few), this counts the pairs. Subtract that number from the .mov total before comparing videos:

  cd "$SRC" && find . -type f \( -iname '*.heic' -o -iname '*.jpg' -o -iname '*.jpeg' \) | sed 's/\.[^.]*$//' | sort -u > "$HOME/PhoneArchive/stills.txt" \
    && find . -type f -iname '*.mov' | sed 's/\.[^.]*$//' | sort -u > "$HOME/PhoneArchive/movs.txt" \
    && comm -12 "$HOME/PhoneArchive/stills.txt" "$HOME/PhoneArchive/movs.txt" | wc -l

• Edited versions you exported into edited/ are extra files. Leave that folder out of the comparison.

• Duplicates (the same shot saved twice, or a file that appears in more than one exported folder) push the count up. That means a total can look right while something is missing. So don’t stop at the total.

• Takeout’s .json files aren’t photos. Leave them out of the media count (the second command above already skips them).

Then check by month to find where a gap is. This uses each file’s modified date. For camera files that’s usually the capture date, but some copy methods set it to the copy date (Google says Takeout downloads may get a new file date). Compare any month that looks thin with the same month on the phone or in the cloud.

# macOS
cd "$SRC" && find . -type f ! -name '.DS_Store' ! -name '*.json' -exec stat -f '%Sm' -t '%Y-%m' {} + | sort | uniq -c
# Linux
cd "$SRC" && find . -type f ! -name '*.json' -printf '%TY-%Tm\n' | sort | uniq -c

$all | Where-Object Extension -ne '.json' | Group-Object { $_.LastWriteTime.ToString('yyyy-MM') } -NoElement | Sort-Object Name

If you can’t account for a difference, find the missing items on the phone and copy them again. Don’t go on to deleting anything.

5b. Spot-check, and know what it can’t prove

Open a dozen files at random from different years, including several videos and a Live Photo’s .mov. This catches the obvious failures: thumbnails, broken files, videos that won’t play. It doesn’t prove you have the originals. A Storage saver copy can look perfectly sharp. The real evidence of quality is where the file came from: the phone over USB with Keep Originals, iCloud Unmodified Originals, or Google Photos items whose Info > Details shows Original quality.

5c. Make a checksum manifest

A SHA-256 checksum is a fingerprint of a file’s contents. If even one byte changes, the checksum changes. Build the manifest from the computer copy. It’s written to a temporary file outside the folder (so it doesn’t hash itself) and moved into place only if every step succeeded.

macOS (shasum is built in) or Linux (swap in sha256sum):

set -o pipefail
SRC="$HOME/PhoneArchive/2026-11"
TMP="$HOME/PhoneArchive/manifest-2026-11.tmp"
cd "$SRC" \
  && find . -type f ! -name 'manifest.sha256' ! -name '.DS_Store' -print0 \
     | sort -z | xargs -0 shasum -a 256 > "$TMP" \
  && mv "$TMP" "$SRC/manifest.sha256" \
  && echo "manifest lines: $(wc -l < manifest.sha256)   files: $(find . -type f ! -name 'manifest.sha256' ! -name '.DS_Store' | wc -l)"
# Linux: replace "shasum -a 256" with "sha256sum"

set -o pipefail makes the whole command fail if find or shasum fails partway through, so a half-finished manifest never gets moved into place. The two numbers printed at the end must be equal. If nothing prints, something failed, so read the error and run it again.

Windows PowerShell (Get-FileHash uses SHA256 by default):

$ErrorActionPreference = 'Stop'
$root = 'C:\PhoneArchive\2026-11'
$tmp  = 'C:\PhoneArchive\manifest-2026-11.tmp.csv'      # outside the folder being hashed
$files = @(Get-ChildItem -LiteralPath $root -Recurse -File -Force | Where-Object Name -ne 'manifest.csv')
if ($files.Count -eq 0) { throw "No files found in $root" }
$files | ForEach-Object {
  [pscustomobject]@{
    Hash    = (Get-FileHash -LiteralPath $_.FullName -Algorithm SHA256).Hash
    RelPath = $_.FullName.Substring($root.Length + 1)
  }
} | Export-Csv -LiteralPath $tmp -NoTypeInformation -Encoding UTF8
Move-Item -LiteralPath $tmp -Destination (Join-Path $root 'manifest.csv') -Force
"manifest written for $($files.Count) files"

-Encoding UTF8 matters on Windows PowerShell 5.1, where Export-Csv writes ASCII by default and would mangle accented or emoji file names.

Then copy the manifest to the drive with the photos (Finder, File Explorer, or cp / Copy-Item).

5d. Verify every copy against the manifest

Run the check on the computer copy and on each drive, so every file is read back from where it’s stored. The cd ... && means that if the drive isn’t mounted, the check fails instead of quietly testing the wrong folder.

DEST="/Volumes/PhotoBackup/PhoneArchive/2026-11"     # then repeat with "$HOME/PhoneArchive/2026-11"
cd "$DEST" \
  && shasum -a 256 -c --strict --quiet manifest.sha256 \
  && [ "$(find . -type f ! -name 'manifest.sha256' ! -name '.DS_Store' | wc -l)" -eq "$(wc -l < manifest.sha256)" ] \
  && echo "ALL OK"
# Linux: sha256sum -c --strict --quiet manifest.sha256

With --quiet, only failures are printed. --strict fails on any badly formatted line in the manifest. The file-count comparison catches files that exist in the folder but aren’t in the manifest. ALL OK prints only if all three pass.

$ErrorActionPreference = 'Stop'
$copy = 'E:\PhoneArchive\2026-11'                    # then repeat with 'C:\PhoneArchive\2026-11'
$rows = @(Import-Csv -LiteralPath (Join-Path $copy 'manifest.csv') -Encoding UTF8)
if ($rows.Count -eq 0) { throw 'Manifest is empty' }
$bad = 0; $checked = 0
foreach ($r in $rows) {
  if ($r.Hash -notmatch '^[0-9A-Fa-f]{64}$' -or [string]::IsNullOrWhiteSpace($r.RelPath)) { throw "Bad manifest row: $($r.RelPath)" }
  $f = Join-Path $copy $r.RelPath
  if (-not (Test-Path -LiteralPath $f -PathType Leaf)) { "MISSING  $($r.RelPath)"; $bad++ }
  elseif ((Get-FileHash -LiteralPath $f -Algorithm SHA256).Hash -ne $r.Hash) { "CHANGED  $($r.RelPath)"; $bad++ }
  $checked++
}
$onDisk = @(Get-ChildItem -LiteralPath $copy -Recurse -File -Force | Where-Object Name -ne 'manifest.csv').Count
if ($onDisk -ne $rows.Count) { "COUNT MISMATCH  manifest=$($rows.Count)  on disk=$onDisk"; $bad++ }
if ($bad -eq 0 -and $checked -eq $rows.Count) { "ALL OK ($checked files)" } else { "FAILED: $bad problem(s)" }

If the manifest is missing, unreadable or empty, the script stops with a red error and never prints ALL OK.

If anything reports FAILED, MISSING, CHANGED or COUNT MISMATCH, copy the affected files again from the computer and re-run the check. If the same file keeps failing, suspect the drive or the cable. If the computer copy itself fails, re-copy from the phone or the cloud.

Keep manifest.sha256 / manifest.csv with the archive. A year from now, the same command tells you whether the drive has quietly corrupted anything.

Step 6: Follow the 3-2-1 rule and keep one copy offline

CISA describes the 3-2-1 rule as 3 copies of important files, on 2 different types of storage, with 1 copy kept off-site. It also recommends offline copies. For phone photos that could mean:

1. The computer copy.
2. External drive A, unplugged and kept at home.
3. External drive B (or a cloud service you trust) kept somewhere else, such as at work or with family.

An unplugged drive can’t be hit by ransomware, a sync mistake or an accidental delete. Run Step 5d on drive B as well, and re-run it on each drive about once a year.

Stop if: any of these is true. Then don’t delete anything from the phone, iCloud or Google Photos:

• The counts in 5a don’t reconcile with the phone or cloud, after allowing for Live Photo pairs, edited copies, duplicates and JSON files.
• Any check in 5d printed a failure, or you haven’t run it on the computer copy and every drive.
• Any Google Photos items you’re relying on show Storage saver or Express under Info > Details, and you no longer have the phone originals.
• Any Takeout part is missing or failed to extract, or you took photos after you requested the export.
• You only have one copy so far.

On a synced phone, an ordinary delete removes the item from iCloud or Google Photos as soon as it syncs. The 30-day trash is only a chance to undo it. If you only want to free space on an Android phone and keep the cloud copy, Google Photos has Delete from device (in a photo’s menu) and Free up space on this device (from your profile picture). Google says these remove only the copy on the phone and keep backed-up items in your Google Photos library. Make sure backup has actually finished first.

Quick checklist

• iPhone: iCloud originals are local (not Optimize), or downloaded as iCloud.com Unmodified Originals, or exported from a Mac set to Download Originals to this Mac.
• Google Photos: a sample of older items checked under Info > Details. Remember Takeout only returns what Google stored, and Storage saver/Express items stay reduced. Surviving phone originals copied over USB.
• iPhone set to Keep Originals before the USB transfer. Hidden album unlocked for Image Capture if needed.
• Every Takeout part downloaded and extracted, with folders and JSON files kept.
• Counts reconciled against the phone or cloud, by type and by month.
• Manifest built, and ALL OK on the computer copy and on every drive.
• Second offline copy made and verified. Only then think about deleting.