Google Takeout JSON Viewer

Google Takeout exports your data as a ZIP archive containing JSON files. The format is designed for machines, not humans: timestamps as Unix epoch milliseconds, coordinates as E7 integers (degrees multiplied by 10 million), and records scattered across nested files with schema drift between export dates. Opening one of these files in a text editor is technically possible but practically useless without parsing. This page explains the format and shows how to view the contents in plain English in 60 seconds.


If you have already opened a Takeout ZIP, taken one look at the JSON, and closed it, you are not alone. The format trades readability for compactness. The viewer below converts those raw fields into a clean summary you can scroll through, share, or export as PDF.

Why is Google Takeout in JSON format?

JSON is the lingua franca of structured data on the web. It is supported by every programming language, easy to parse with one library call, and compact enough to keep export sizes manageable. Google chose JSON for the same reason it chose ZIP for the archive: maximum compatibility with developer tooling.


The trade-off is human readability. JSON optimizes for machine parsing, which means timestamps are stored as numbers (epoch milliseconds), coordinates are stored as scaled integers (E7), and related data is normalized across multiple files. A human looking at a single record sees something like {"latitudeE7": 487856612} and has to know the convention to recognize that as a location in Paris.

What is actually inside a Google Takeout JSON file?

Below is a real-shape Location History record from a Google Takeout export. The left side is the raw JSON that ships in the ZIP. The right side is what that record actually means.


Raw JSON in the ZIP
{
  "latitudeE7": 487856612,
  "longitudeE7": 23415879,
  "accuracy": 10,
  "timestampMs": "1710440627182",
  "source": "WIFI",
  "deviceTag": 1234567890,
  "platformType": "ANDROID"
}
What it actually means
Place
  48.7857° N, 2.3416° E
  Accuracy ±10 meters
  Source: WiFi-based reading

When
  March 14, 2024 at 6:23 PM UTC

Device
  Android phone (one of yours)

The translation rules at play in this single record:

  • latitudeE7 / longitudeE7: divide by 10,000,000 to get decimal degrees.
  • timestampMs: Unix epoch in milliseconds. Divide by 1000 and convert with your favorite date library.
  • accuracy: meters of error radius. Lower is better.
  • source: which sensor produced the reading (GPS, WIFI, CELL, UNKNOWN).
  • deviceTag: an internal hash identifying the device. Same hash means same physical device across records.

A full Takeout export contains hundreds of thousands of records like this one across dozens of files. Reading them by hand is not realistic.

See your real Takeout in plain English

The breakdown below is sample data shaped like a real export, parsed for readability. Drop your own ZIP onto the tool to see your numbers.

Sample data · your real report will look like this

Location HistorySearch ActivityYouTube HistoryChrome HistoryAndroid ActivityGmail

Search Activity

Free preview
Total searches recorded58,724
Most active periodsJanuary 2023, October 2022, March 2024
What this means: Google keeps a record of your searches. The full report includes all data categories and detailed insights.

Location History

Total location records42,856
Countries detected14

YouTube Activity

Videos watched18,329

Chrome Browsing

Pages visited89,412

Android Activity

Activity records124,592

Gmail

Emails in archive24,891

Want to read your real Takeout?

This is sample data parsed from a fictional account. Upload your own Google Takeout ZIP to convert your JSON files into a clean readable report. Free preview before you pay.

Parse your Takeout in 60 secondsFree preview first. $19 $9 one-time. No subscription.

How to parse Google Takeout JSON manually

If you want to write your own parser, the basic shape is straightforward in any language. In Python:


import json
from datetime import datetime, timezone

with open("Records.json") as f:
    data = json.load(f)

for record in data["locations"]:
    lat = record["latitudeE7"] / 1e7
    lon = record["longitudeE7"] / 1e7
    ts_ms = int(record["timestampMs"])
    when = datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc)
    print(f"{when:%Y-%m-%d %H:%M} - {lat:.4f}, {lon:.4f}")

That handles the happy path. The complications come fast:

  • Schema drift. Google has shipped at least four different shapes for Location History since 2014. Older files use timestampMs, newer files use timestamp as ISO 8601. Some have a top-level locations array, others wrap differently.
  • Multiple files per category. Search Activity is split across MyActivity.json files per product (one for Search, one for Maps, one for Image Search, etc.). YouTube has separate files for watch history, search history, comments, and subscriptions.
  • Missing fields. Older accounts have records without source, accuracy, or deviceTag. Newer accounts have those fields but may lack older fields like place visits.
  • Non-JSON data. Gmail ships as MBOX. Chrome can ship as both JSON and HTML. Photos has its own quirks. A general-purpose Takeout parser handles each format separately.
  • Encoding. Some files are UTF-8 with BOM, some without. Some have non-printable characters in places. Robust parsers normalize on read.

If you want to ship a parser, plan for several hours of work plus ongoing maintenance every time Google adjusts the export format. If you just want to read your data, the tool below saves you the time.

Read your Takeout in 60 seconds without writing code

TakeoutReader is a browser-based parser. Drop your ZIP onto the page and the report renders immediately. The parser handles the schema drift, the multi-file layouts, the format conversions, and the missing-field edge cases so you do not have to.


  • Six categories supported: Location History, Search Activity, YouTube History, Chrome History, Android Activity, Gmail.
  • Output formats: PDF, plain text, Markdown, CSV.
  • Zero upload. Parsing happens entirely in your browser via JSZip. You can verify in DevTools by watching the Network tab.
  • No account, no login, no extension.

For a full audit of what Google has on you, see what does Google know about me. For a focused look at GPS records, see our Google Location History viewer. For activity-specific exports, see the Google Activity viewer hub.

Common file formats inside Google Takeout

A typical export contains several formats depending on which Google products you included:


  • JSON: Location History (Records.json, Semantic Location History/), My Activity (MyActivity.json per product), YouTube (watch-history.json, search-history.json, subscriptions.json), Chrome (Bookmarks.json, History.json), Android Activity, Drive metadata.
  • HTML: Pre-rendered summaries Google generates for some categories (My Activity, YouTube). Faster to skim but less complete than the JSON twins.
  • MBOX: Gmail. Plain-text email format readable by any mail client (Thunderbird, mutt) but not by web browsers without conversion.
  • CSV: Some products ship CSV alongside JSON (Saved, Tasks).
  • KML: Location History also ships a Timeline KML format usable in Google Earth and other GIS software.
  • Original media: Photos and Drive contain the raw files (JPG, PDF, etc.) plus per-file metadata.

TakeoutReader currently focuses on the six JSON-based categories with the broadest user demand. Other formats are passed through unmodified.

Skip the parser. Read your Takeout now.

Drop your ZIP. Free preview. $19 $9 for the full report.

Parse your Takeout in 60 seconds

Frequently asked questions

How do I open a Google Takeout ZIP?

On any modern OS, double-click the ZIP file to extract it. You will see a Takeout folder containing one subfolder per Google product (Location History, My Activity, YouTube, Chrome, etc.). Inside each subfolder are HTML, JSON, and sometimes MBOX or CSV files. The JSON files hold the structured data; HTML files are pre-rendered summaries Google generates for some categories.

What does the JSON in Google Takeout look like?

Each JSON file is an array (or wrapper object containing an array) of records. Records use machine-friendly fields: timestamps as Unix epoch milliseconds (timestampMs) or ISO 8601 strings (time), coordinates as integers scaled by 10^7 (latitudeE7, longitudeE7), and nested objects for related data like place visits or YouTube subtitles. The schema varies slightly between products and has changed over the years.

Can I parse Google Takeout JSON in Python?

Yes. Pure-Python parsing is straightforward for any single file: open, json.load, iterate. The complexity comes from handling multiple files per category, schema drift between export dates, missing fields in older accounts, and converting machine fields (E7 coords, epoch ms) into human-readable values. Writing a robust parser typically takes a developer several hours; reading the result with TakeoutReader takes 60 seconds.

Why are timestamps in Google Takeout in milliseconds?

Older Google Takeout JSON (Location History before 2024, some legacy My Activity files) uses Unix epoch milliseconds, stored either as integers or as strings inside a timestampMs field. This is a JavaScript convention since Date.now() returns ms. To convert, divide by 1000 and pass to your language's Unix-time function. Newer files have shifted to ISO 8601 strings in a time field.

What is the E7 format in Google Location History?

Google stores latitude and longitude as integers multiplied by 10 million. To get the decimal degrees you actually want, divide by 10000000. So latitudeE7: 487856612 means 48.7856612 degrees north. The format saves storage space and avoids floating-point precision drift but is unreadable without conversion.

Is there a Google Takeout file format documentation?

Google publishes a high-level overview of supported products at takeout.google.com but does not publish a stable schema specification for each JSON file. The actual structure has to be inferred by inspecting export samples, which is why parsers (including TakeoutReader) are constantly updated as Google adjusts the format.

Read your Google Takeout the easy way

Drop your ZIP. The parser handles the JSON, the timestamps, the E7 coordinates, and the schema drift. Free preview in 60 seconds. The full report unlocks for $19 $9 one-time. No subscription. No account.

Parse your Takeout in 60 seconds

100% private. Processed in your browser. Nothing uploaded. TakeoutReader is not affiliated with Google.