Where Chrome Stores Your History File (And How to Read It)
The most reliable way to find your Chrome history file location is to open chrome://version and look for Profile Path. Inside that directory, the extensionless file named History is Chrome’s SQLite history database for that profile.
Do not assume the profile folder is named Default. Each Chrome profile has its own history, and another profile may use a directory such as Profile 1.
For inspection, record the path, fully quit Chrome, and work on a copy of the database. Start by examining its schema, then query urls for URL-level records or join visits to urls for individual recorded visits. Those two views answer different questions.
Find the right profile’s History file
These are the standard locations for a Google Chrome installation using the Default profile:
| Operating system | Default-profile History file |
|---|---|
| Windows | %LOCALAPPDATA%\Google\Chrome\User Data\Default\History |
| macOS | ~/Library/Application Support/Google/Chrome/Default/History |
| Linux | ~/.config/google-chrome/Default/History |
These are file paths. To navigate to the containing profile directory, remove the final History component. On Windows, paste that directory path into File Explorer’s address bar. On macOS, enter the directory path in Finder’s Go to Folder command. On Linux, open the directory in your file manager or terminal. Then locate History without opening or modifying the original.
Treat these as starting points, not universal locations. Other release channels, configuration overrides, and packaging can change the base directory. Chromium’s user-data-directory documentation explains the distinction between the user-data directory and the individual profile directories beneath it.
For a specific browsing session, use this sequence:
- Switch to the Chrome profile whose history you want to inspect.
- Open
chrome://version. - Copy the full Profile Path.
- Open that exact directory and locate
History.
This prevents a common diagnostic mistake: querying a valid database from the wrong profile and interpreting the missing rows as lost history.
Make a safe working copy
Fully quit Chrome before making a plain file copy. Closing a window may leave background processes running, so check Task Manager on Windows or an appropriate process monitor on macOS or Linux.
Once Chrome has exited, copy History into a separate working directory and name the copy History-copy. Leave the original untouched.
Chrome can hold database locks, and a database that is changing during a file copy may not produce a consistent snapshot. A read-only connection prevents your queries from modifying the database, but it does not by itself establish that you acquired all committed data correctly.
If shutdown is uncertain, or SQLite sidecar files such as History-wal or History-journal remain, do not delete them or guess which files matter. Use a database-aware backup workflow instead of copying only the main file. SQLite’s online backup mechanism supports copying a live database through SQLite; such a workflow must handle busy or locked results. It cannot include data Chrome has not yet committed.
Treat the working copy as sensitive data. URLs can contain search terms, document identifiers, and query parameters that reveal more than a page title suggests.
Open the copy read-only and inspect its schema
With the sqlite3 command-line tool available, open a terminal in your working directory and run:
sqlite3 -readonly "./History-copy"At the SQLite prompt, enable readable output and inspect the two tables:
.headers on
.mode column
.schema urls
.schema visitsSchema details can vary by Chrome version. Inspecting the copy first lets you see its actual columns rather than treating this selected field guide as an exhaustive schema.
The fields used here are:
urls:id,url,title,visit_count, andlast_visit_time.visits:id,url,visit_time,from_visit, andtransition.
The important relationship is visits.url → urls.id. Despite its name, visits.url is a reference to a URL record, not the address text.
The from_visit field records a referring visit identifier where available. The transition field contains encoded navigation metadata. Neither is a substitute for page content.
Query 1: Recent URL records and their stored counts
Use this query when the question is, “Which stored addresses were visited most recently?”
SELECT
id AS url_id,
url,
title,
visit_count,
datetime(
last_visit_time / 1000000.0 - 11644473600,
'unixepoch'
) AS last_visit_utc
FROM urls
ORDER BY last_visit_time DESC, id DESC
LIMIT 20;Each result is a URL-level record. Repeated visits to the same address are summarized here rather than displayed as separate events.
Interpret visit_count as the stored URL-level counter. Do not assume it equals the number of surviving rows you could count by joining to visits. Likewise, counting rows in urls counts URL records—not browsing visits.
Chrome history timestamps use microseconds since 1601-01-01 UTC. Dividing by 1000000.0 converts microseconds to seconds; subtracting 11644473600 shifts the epoch to Unix time. SQLite’s datetime function then formats that value using the 'unixepoch' modifier.
The displayed result is UTC and does not preserve microsecond precision. The query sorts by the original timestamp, not the formatted string.
Query 2: Individual recorded visits
Use this query when the question is, “Which individual visits are recorded, and when did they happen?”
SELECT
v.id AS visit_id,
datetime(
v.visit_time / 1000000.0 - 11644473600,
'unixepoch'
) AS visited_utc,
u.url,
u.title AS url_record_title,
v.from_visit,
v.transition
FROM visits AS v
JOIN urls AS u ON u.id = v.url
ORDER BY v.visit_time DESC, v.id DESC
LIMIT 20;Here, each returned row represents an individual recorded visit joined to its URL record. The same address can appear more than once, with different visit IDs and times.
Notice the alias url_record_title. That title comes from the URL record in this database copy. It is not a historical title snapshot for each visit. If a page’s title changed, this join does not reconstruct the title—or the page body—as it appeared on each occasion.
Once you understand which rows you need, see How to Export Chrome History to CSV or JSON for output formatting. To leave the SQLite shell, enter .quit.
Understand missing history and retention
This database copy contains records still retained in one profile, not a complete archive of every browsing session. Private browsing, manual deletion, profile selection, and retention can all affect what is available.
When an expected visit is missing, first confirm the profile path and compare timestamps in UTC. Then check whether you are looking at URL summaries or individual visits. A URL-level result cannot establish how many individual visit rows remain.
A history-view window is not a specification for database cleanup or physical overwriting. It also does not establish whether related URL records, backups, or account-service records remain. Do not use it to infer exact deletion timing.
Google Account activity is a separate dataset from this profile’s local History file. Querying the SQLite database does not query account activity, and absence from one does not establish absence from the other.
Why page-content search is a separate job
Chrome’s selected history tables contain navigation metadata, not a historical page-content archive. URLs and titles sit alongside timestamps, counts, and transition information. Those records can help answer “Which address did I visit?” but cannot reconstruct a paragraph you remember reading.
Content-level indexing therefore requires a separate capture and indexing process. It cannot manufacture old page text from a URL and timestamp.
TraceMind’s core capture and indexing run locally. Its separately captured history is distinct from its Chrome-history import: the import can bring in up to the previous 365 days and 10,000 metadata-only records, without historical page text, screenshots, or embeddings. Those are import limits, not a promise that Chrome retains that much history.
Keep the four datasets separate when investigating a missing page: Chrome’s local history, Google Account activity, imported Chrome metadata, and separately captured history. The History file is useful for inspecting retained navigation records; recovering what a page actually said requires content that was captured elsewhere.
