- google timeline visualizer turns exported Timeline.json data into an animated journey video
- Safari setup requires Safari 16.4 or later and an Add to Home Screen shortcut
- Privacy model keeps your Timeline file on the device while requesting map tiles separately
- Best workflow starts with a short preview before rendering a longer trip or full year
- Accuracy controls help reduce GPS noise, implausible jumps, and low-quality location points
google timeline visualizer Safari Setup
google timeline visualizer is a local-first web app for turning a Google Maps Timeline export into a visual route. On iPhone, the most practical setup is Safari. The app runs from the browser and can be added to the Home Screen so it behaves more like a dedicated utility.
The key preparation step is exporting your data before opening the visualizer. If the export contains no meaningful locations, the renderer cannot reconstruct a journey. When a phone has recently been upgraded, reset, or reinstalled, check whether Timeline data has been restored locally before troubleshooting the visualizer.
Video Highlights:
- Export the Timeline JSON file before starting a render
- Use Safari 16.4 or later for the web-app workflow
- Validate a short video before processing a large date range
- Keep the location file local and review map-tile privacy details
Prepare
- Export Timeline.json
- Confirm the file contains locations
- Save it in the Files app
Launch
- Open the visualizer in Safari
- Choose the local Timeline file
- Review settings before loading the map
Render
- Select exact dates
- Preview a short clip
- Create the final journey video
Use Safari’s Share menu and choose Add to Home Screen after opening the web app. This makes the visualizer easier to access without changing where your Timeline file is stored.
| Requirement | Recommended choice | Why it matters |
|---|---|---|
| Browser | Safari 16.4 or later | Supports the iPhone web-app workflow and hardware video encoding |
| Input file | Exported Timeline.json | Supplies the route data used for the visualization |
| File location | Apple Files app | Keeps the export available for local selection |
| First render | Short duration | Helps confirm that dates, map geometry, and permissions work |
| Output | MP4 video | Creates a shareable visual record of the selected journey |
Export Timeline Data on iPhone
The iPhone export path begins inside Google Maps. Open the app, select your profile picture, and enter Settings. From there, open Personal content and choose the option to export Timeline data. Save the resulting Timeline.json file in the Files app, preferably in a folder that is easy to find again.
The export itself is separate from the visualizer. The renderer cannot repair a missing or empty database. If the file shows no useful locations, return to Google Maps and check whether your Timeline history has been imported or restored to the device before exporting again.
Open Google Maps Settings
Launch Google Maps on your iPhone, tap your profile picture, and open Settings. The export control is located within the app’s personal content options.
Export Timeline Data
Open Personal content, select Export Timeline data, and wait for Google Maps to prepare the Timeline.json file.
Save the File
Save Timeline.json inside the Apple Files app. Use a persistent local folder rather than leaving the file in a temporary share sheet location.
Open the Visualizer
Return to Safari, open the Timeline Visualizer web app, and choose the exported file when prompted.
| Export stage | Expected result | If it fails |
|---|---|---|
| Google Maps profile menu | Settings becomes available | Confirm you are using the intended Google Maps account |
| Personal content | Timeline export option appears | Update Google Maps if the menu structure differs |
| File export | Timeline.json is saved | Check Files storage and available device space |
| Visualizer import | File name appears in the app | Recheck the file location and permissions |
| Data validation | Dates and locations can be selected | Restore or import Timeline history before exporting again |
An empty or nearly empty Timeline.json file is a data problem, not necessarily a visualizer problem. Do not begin a long render until the file contains the period you want to view.
The visualizer’s file-selection screen is designed around local processing. The Timeline file is not uploaded to the app’s server. However, map tiles are a separate consideration and should be reviewed before loading a map.
Configure Dates, Accuracy, and Camera Movement
After loading Timeline.json, narrow the journey before rendering. The exact-date controls let you choose a single day, a vacation, a calendar year, or another defined period. A live summary can help confirm that the selected range contains location points and measurable movement.
The app also exposes controls for raw location data, accuracy limits, GPS outlier filtering, duration, camera movement, video format, and frame rate. These settings affect both visual quality and processing time. Larger formats and higher frame rates generally require more time and produce larger files.
Exact Dates
Isolate a trip, event, month, or year instead of rendering the entire file.
Accuracy Limit
Exclude locations below your chosen accuracy threshold when noisy points reduce route clarity.
Outlier Filter
Reduce short, impossible round trips while leaving the original Timeline file unchanged.
Camera Profile
Choose a calmer or more active movement style based on the story you want to tell.
| Setting | Best starting point | Main trade-off |
|---|---|---|
| Date range | One trip or one month | Shorter ranges are easier to inspect |
| Raw location data | Use only when semantic data is unavailable | Routes may be less accurate |
| Accuracy limit | Leave blank initially | More points can also mean more noise |
| GPS outlier filtering | Conservative | Removes some implausible short movements |
| Duration | Short preview first | Longer videos take more processing time |
| Frame rate | Default or moderate | Higher rates look smoother but enlarge output |
Start with the least aggressive filtering that produces a readable route. Tighten the accuracy limit or use conservative outlier filtering only when noisy or impossible movements are visible.
Three camera approaches are especially useful. A steady movement style keeps the route readable with a central dead zone. A fixed approach maintains a more consistent altitude. A dynamic approach changes scale more actively and can make long-distance travel feel faster. For flights or sparse GPS points, balanced compression can make large gaps easier to follow, although it does not create verified location records.
Use the live data summary beneath the date selectors as a checkpoint. If the selected period has no points or distance, change the dates before spending time on a render.
Preview and Create the Journey Video
A preview is the safest way to validate the file structure, selected dates, and device permissions. Choose a minimal duration, inspect the route geometry, and only then create the longer version. This workflow reduces the chance of tying up your phone with a failed multi-year render.
The visualizer generates the video on the device. Once processing completes, the MP4 can be saved or viewed through the device’s media library. The final result depends on the quality and meaning of the source Timeline data, so treat the animation as a visual interpretation of recorded points rather than a perfect reconstruction of every trip.
Select Create Video
Open the creation controls after importing Timeline.json. Confirm that the selected file and date range are correct.
Accept the Privacy Notice
Review the notice explaining local file handling and map-tile requests before continuing.
Run a Short Preview
Set a minimal duration, preview the route, and confirm that the map geometry follows the expected journey.
Adjust the Story
Change dates, camera movement, title, format, or frame rate if the route is too fast, too slow, or difficult to read.
Create the Final Video
Start the final render after validation. Keep the app open and allow enough storage for the selected output format.
Before the Final Render:
- Confirm Timeline.json contains the intended date range
- Verify the route appears during the short preview
- Check camera movement and video duration
- Review map-tile privacy information
- Confirm sufficient device storage for the MP4
| Render goal | Suggested workflow | Review point |
|---|---|---|
| Single vacation | Select exact trip dates and use a moderate duration | Check stops, gaps, and camera pacing |
| One calendar year | Preview a short segment first | Watch for excessive route density |
| Long-distance flight | Use a wider camera style | Expect gaps between recorded points |
| Noisy walking route | Try conservative filtering | Confirm important turns remain visible |
| Shareable summary | Add a clear title and readable duration | Choose a format that fits the destination |
A successful short preview confirms more than appearance. It also tests file access, date selection, map drawing, and the basic path from imported data to video output.
If the app displays a raw-locations-only notice, the export may contain recent unprocessed estimates rather than Google’s richer semantic activity information. The route can still be useful, but distance and path accuracy may require closer review.
Privacy, Troubleshooting, and FAQ
The privacy design has two parts. First, the Timeline file remains on the device and is processed locally by the visualizer. Second, the app requests map images from a map provider for the selected route. The file itself is not uploaded, but tile requests can reveal the map areas being viewed, along with ordinary network information such as an IP address.
For the latest interface details, review the Timeline Visualizer web app before importing personal data. The page also documents the iPhone export path and explains the map-tile request behavior.
| Symptom | Likely cause | Recommended action |
|---|---|---|
| No Timeline loaded | File was not selected or is in another folder | Reopen Files and choose Timeline.json |
| Zero locations | Local Timeline history is empty | Restore or import history in Google Maps, then export again |
| Route looks noisy | Low-quality points or raw estimates | Try a conservative filter or accuracy limit |
| Video takes too long | Large date range, format, or frame rate | Shorten the range or lower output demands |
| Map reveals unexpected areas | Selected dates include additional movement | Review the date range before loading the map |
Travel history can expose home, work, routines, and frequently visited places. Review the date range and map-tile notice before creating or sharing a video.
Q: Does google timeline visualizer upload my Timeline.json file?
The visualizer is designed to keep the Timeline file on the device for local processing. Map tiles are requested separately, and those requests may reveal selected map areas to the map provider.
Q: Why is my exported Timeline.json empty?
The phone may not have restored its local Timeline database. Return to Google Maps, check whether the history has been imported or restored, and export the data again before rendering.
Q: Which Safari version should I use on iPhone?
Use Safari 16.4 or later for the documented iPhone web-app workflow. Adding the visualizer to the Home Screen provides quicker access.
Q: Should I render an entire year immediately?
No. Start with a short date range and minimal preview. Confirm the route, pacing, filtering, and storage requirements before creating a larger video.
Treat every rendered journey as an editable visual summary. Adjust dates and filters until the route communicates the intended trip without exposing more location history than necessary.