> ## Content Index
> Fetch the complete content index at: https://allmycameras.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Fix Google Takeout Photo Dates and Missing Locations (Mac and Windows)
- URL: https://allmycameras.com/fix-google-takeout-photo-dates/
- Published: 2026-10-08T20:13:11.000Z
- Updated: 2026-10-08T20:13:11.000Z
- Description: Your Takeout photos all show the day you downloaded them, and the locations are gone. The data is in the JSON sidecar files next to each photo. Here is how to put it back with exiftool, and when to use a ready-made tool instead.
- Author: All My Cameras
- Tags: Google Photos, Guides

You exported your library with Google Takeout, unzipped it, and every photo says it was taken the day you downloaded it. Some have no location. Nothing is lost: the date, location and description Google stored are in a separate JSON file next to each photo. The fix is to copy that data back into the files.

Before you start, work on a copy of the extracted folder and keep the original zip files until you are happy with the result. The commands below rewrite files in place.

## Why the dates look wrong

Two different things are going on, and it helps to know which one you have.

- **The file date is wrong, the photo date is fine.** Most photos from phones and cameras still carry their original capture date inside the file (the EXIF `DateTimeOriginal` tag). Finder, File Explorer and many importers sort by the file's modified date instead, and unzipping sets that to today.
- **The photo has no date inside it at all.** Screenshots, images saved from messaging apps, scans, and photos whose date you corrected inside Google Photos. For these, the only correct date is the one in the JSON sidecar.

Locations work the same way. If you added or edited a location in Google Photos, that edit lives only in the JSON.

## What is in the JSON sidecar

Each photo or video normally has a sidecar in the same folder. Open one in a text editor and you will see something like this (trimmed):

```
{
  "title": "IMG_20230815_152536.jpg",
  "description": "",
  "photoTakenTime": {
    "timestamp": "1692105936",
    "formatted": "Aug 15, 2023, 1:25:36 PM UTC"
  },
  "geoData": {
    "latitude": 50.0647,
    "longitude": 19.945,
    "altitude": 0.0
  },
  "geoDataExif": { ... }
}
```

Three details matter:

- `photoTakenTime.timestamp` is a Unix time in seconds, in UTC. It carries no time zone. A photo taken at 3:25 pm in Kraków is stored as 1:25 pm UTC.
- `geoData` is the location Google shows you, including your edits. `geoDataExif` is what was in the original file.
- When there is no location, Google writes `0.0` for latitude and longitude rather than leaving the field out. Copied blindly, that puts the photo in the Atlantic off West Africa.

## Sidecar names are not consistent

This is why most scripts you find online match only some of your photos.

- **Older exports** name the sidecar after the full file name plus `.json`: `IMG_1234.jpg.json`.
- **Newer exports** use `IMG_1234.jpg.supplemental-metadata.json`.
- **Long names get cut short.** Takeout caps the length of the sidecar's file name, so the suffix is truncated: `.supplemental-metad.json`, `.supplemental-me.json`, `.supp.json`, or with very long photo names even `IMG_123456790.j.json`. Pixel photos named like `PXL_20240101_123456789.MP.jpg` are long enough to hit this.
- **Duplicate names move the counter.** A second `IMG_1234.jpg` becomes `IMG_1234(1).jpg`, but its sidecar is `IMG_1234.jpg(1).json` or `IMG_1234.jpg.supplemental-metadata(1).json`.
- **Edited copies.** If you edited a photo in Google Photos, you get the original and an `IMG_1234-edited.jpg`. The edited copy usually has no sidecar of its own. The suffix is translated if your Google account is not in English.
- **Live Photos and motion photos.** iPhone Live Photos come out as a still and a short `.MOV` with the same base name. Often only the still has a sidecar. The video half usually has its own date inside it already.

## Step 1: install exiftool

On a Mac, install the package from [exiftool.org](https://exiftool.org/?ref=allmycameras.com) or run `brew install exiftool` if you use Homebrew. On Windows, download the Windows executable from the same site, rename `exiftool(-k).exe` to `exiftool.exe`, and keep the `exiftool_files` folder next to it. Check it runs:

```
exiftool -ver
```

## Step 2: write the photo date and location from the sidecar

Open Terminal, `cd` into the folder that contains `Takeout`, and run this. If your Takeout was in another language, the folder may be called something other than `Google Photos`.

```
exiftool -r -d %s -wm cg -overwrite_original \
  -tagsfromfile "%d%F.supplemental-metadata.json" \
  "-DateTimeOriginal<PhotoTakenTimeTimestamp" \
  "-GPSLatitude<GeoDataLatitude" "-GPSLatitudeRef<GeoDataLatitude" \
  "-GPSLongitude<GeoDataLongitude" "-GPSLongitudeRef<GeoDataLongitude" \
  -ext jpg -ext jpeg -ext heic -ext png \
  "Takeout/Google Photos"
```

Then run it again with `"%d%F.json"` in place of `"%d%F.supplemental-metadata.json"` to catch sidecars that use the older naming. Warnings about files that could not be opened are expected: they are photos that have no sidecar under that name.

What the options do:

- `-d %s` tells exiftool the source value is a Unix timestamp.
- `-wm cg` only creates tags that are missing. A photo that already has a capture date or GPS keeps it. If you corrected dates inside Google Photos and want those corrections to win, remove `-wm cg`.
- `%d%F` is the photo's folder and full file name, so exiftool looks for `IMG_1234.jpg.supplemental-metadata.json` next to `IMG_1234.jpg`.

On Windows, run the same command in Command Prompt on one line, without the trailing backslashes, with the path written as `"Takeout\Google Photos"`.

## Step 3: the time zone problem

The timestamp is UTC, and EXIF dates are local time with no zone. exiftool converts the timestamp using your computer's time zone. That is right for photos taken at home and off by the difference for photos taken elsewhere.

If a trip matters, move those photos into their own folder and run the Step 2 command on that folder with the time zone set for that one command (Mac):

```
TZ=America/New_York exiftool -r -d %s -wm cg ...
```

## Step 4: videos

Videos store dates in QuickTime tags, which are defined as UTC. Phone videos almost always have a correct date already, so this only fills in videos where it is missing or zero:

```
exiftool -r -d %s -api QuickTimeUTC -overwrite_original \
  -if 'not $QuickTime:CreateDate or $QuickTime:CreateDate =~ /^0000/' \
  -tagsfromfile "%d%F.supplemental-metadata.json" \
  "-QuickTime:CreateDate<PhotoTakenTimeTimestamp" \
  "-QuickTime:ModifyDate<PhotoTakenTimeTimestamp" \
  -ext mp4 -ext mov \
  "Takeout/Google Photos"
```

Repeat with the older `.json` naming as in Step 2\. On Windows, swap the single quotes around the `-if` condition for double quotes.

## Step 5: remove the 0,0 locations

Photos whose sidecar had no location now have GPS set to 0,0\. Remove it:

```
exiftool -r -overwrite_original \
  -if 'defined $GPSLatitude and $GPSLatitude# == 0 and $GPSLongitude# == 0' \
  -gps:all= -ext jpg -ext jpeg -ext heic -ext png \
  "Takeout/Google Photos"
```

## Step 6: fix the file dates

Now that the capture date is inside every file, set the file's modified date to match so Finder and Explorer sort correctly:

```
exiftool -r -overwrite_original "-FileModifyDate<DateTimeOriginal" \
  -ext jpg -ext jpeg -ext heic -ext png "Takeout/Google Photos"

exiftool -r -api QuickTimeUTC -overwrite_original \
  "-FileModifyDate<QuickTime:CreateDate" -ext mp4 -ext mov "Takeout/Google Photos"
```

## Step 7: find what did not match

Truncated names, `(1)` duplicates and `-edited` copies will not have matched. This lists every media file with no sidecar under either standard name (Mac or Linux):

```
cd Takeout
find . -type f ! -name '*.json' ! -name '.*' | while IFS= read -r f; do
  [ -e "$f.supplemental-metadata.json" ] || [ -e "$f.json" ] || echo "$f"
done > unmatched.txt
wc -l unmatched.txt
```

If the list is a few dozen files, fixing them by hand is quicker than anything else. If it runs to thousands, use one of the tools below on the whole export instead.

## When to use a tool instead

**GooglePhotosTakeoutHelper Neo (gpth)** is a maintained fork of the original GooglePhotosTakeoutHelper. It matches sidecars including the awkward cases above, writes dates and GPS into the files through exiftool, and sorts the output into date folders. It can read the Takeout zips directly. It moves files out of the input folder as it works, so keep the zips.

```
gpth --input "/path/to/Takeout" --output "/path/to/Photos" --albums "shortcut"
```

**immich-go** is built for moving a Takeout into an Immich server, and it can also write a sorted copy to a local folder without any server:

```
immich-go archive from-google-photos --write-to-folder=/path/to/Photos /path/to/takeout-*.zip
```

Both are free and open source. Run either on a copy first and spot-check a handful of photos you know the dates of, especially ones from trips.

## Related

- [Google Takeout split into many zip files: download, merge and check nothing is missing](https://allmycameras.com/google-takeout-multiple-zip-files/)
- [Verified copy vs drag and drop: offloading camera cards safely](https://allmycameras.com/verified-copy-vs-drag-and-drop/)
- [How to download everything from GoPro Cloud](https://allmycameras.com/download-all-gopro-cloud-media/)
- [DJI drone file names explained](https://allmycameras.com/dji-drone-file-names-explained/)