Google foto export of 200 gb finally done.

Migrating from Google Photos to be ready for any cloud service of your choice.
I recently went through the process of migrating a large Google Photos library (~100GB+) exported via Google Takeout to macOS.
I wanted to share this specifically for people considering switching away from Google and keeping everything local, because the process is much more complicated than it should be. This is what worked in my experience but because of the complexity other scenarios might be needed for your personal situation. I wanted to share this because it took me quite some trial and error. I spent almost two weeks working things out and making the export data ready for import. Hope it helps some people de-googling.

⚠️** Important reality chec**k
Exporting your own data from Google Photos and maintaining metadata (date, time, GPS) is far more complex than it should be.
Google Takeout does NOT properly embed metadata into image files. Instead it splits everything into:
JPG / HEIC files and separate .json files containing metadata. These need to be merged later on and you need to export it in batches from google and need to merge it in automated way later on.

Most services not read these JSON files, so without extra work your entire library will import with incorrect dates and broken timelines.

💾 Storage requirement (very important)
You will need:
At least the same amount of free storage as your full library

Ideally an external SSD or HDD (recommended)

Why:
You are working with duplicates of large image sets

You need space for both raw Takeout + processed files

You need to verify steps constantly

You may need to re-run batches when something goes wrong

For a 100GB library, expect 200GB+ real working space during migration.

🧰 Tools required
Homebrew → https://brew.sh

ExifTool → https://exiftool.org

jq (JSON parser) → https://jqlang.org

Install:
brew install exiftool jq

📦 Step 1 — Export from Google Takeout
Go to:
https://takeout.google.com
Select:
Google Photos only

Export in multiple 5–10GB archives

📂 Step 2 — Extract everything
Organize into a clean folder, for example:
~/Pictures/GoogleTakeout/
You should see pairs like:
IMG_1234.jpg
IMG_1234.jpg.json

⚠️** Step 3 — Work in small batches (critical**)
Do NOT process everything at once.
Use:
yearly folders (2018 / 2019 / 2020)
or

manual batches

This is essential because:
ExifTool operations are slow on large datasets

Errors are easier to detect and fix

You must constantly verify results

📅 Step 4 — Fix metadata (date/time)
Inside each batch folder:
cd /path/to/batch
Then:
for json in *.json; do
img="${json%.json}"
timestamp=$(jq -r '.photoTakenTime.timestamp' "$json")

if [ "$timestamp" != "null" ]; then
exiftool -overwrite_original \
"-DateTimeOriginal<${timestamp}" \
-d "%s" \
"$img"
fi
done

📍 Step 5 — Fix GPS data
for json in *.json; do
img="${json%.json}"

lat=$(jq -r '.geoData.latitude' "$json")
lon=$(jq -r '.geoData.longitude' "$json")

if [ "$lat" != "null" ] && [ "$lon" != "null" ]; then
exiftool -overwrite_original \
-GPSLatitude="$lat" \
-GPSLongitude="$lon" \
"$img"
fi
done

🔍 Step 6 — Constant verification is required
At every stage you must check randomly:
exiftool IMG_1234.jpg
Make sure:
DateTimeOriginal is correct

GPS data exists (if applicable)

This is a precise, manual process, not something you can fully automate safely for large libraries without checking.

🍏 Step 7 — Import into Apple Photos
Only after metadata is fixed:
Open Apple Photos

Import batch folders one by one

Everything should now appear correctly:
correct timeline

correct locations

no broken import dates

📦 Step 8 — Repeat for all batches
Repeat carefully:
batch → fix → verify → import

This is slow but reliable.

Final note
The whole process works, but:
It is unnecessarily complex

It requires technical steps most users should not need to do

It requires external tools and manual verification

It requires a lot of storage overhead

For a proper migration you realistically need:
patience

storage space (ideally external SSD)

careful step-by-step checking