How can I view activities from old database backups without having to reimport them?

[directentis1]

I have some backup of Activity Watch many years ago, it's about half of GB (literally .local/share/activitywatch folder)

I'd like to view some of my activities in the past, but currently to view them, the only way is to import all of them to current database which I don't need (and also not reasonable to accumulate all the data)

Currently the only way I have is to import the data into a virtual machine and view everything from there.. but I wonder if anyone has a better way.?
Is it possible to develop a tool to make this more convenient?
Or a more radical way is to directly process the raw database file with a sqlite3 viewer?

[ComfyChloe]

Backup current state, stop process swap it out, view/export what you'd like, restore old (new) backup, Sounds plasuable(?)

[directentis1]

Well, maybe it's the only way :D

[Lopesnextgen]

Hey brother,

You can view the backup through a temporary ActivityWatch instance

You do not need to import the archive into your current database or create a complete VM.

The cleanest approach is to start only an ActivityWatch server on another port and point it at a copy of the archived SQLite database.

First, identify the database

Depending on the ActivityWatch version, the backup probably contains one of these:

• Rust server: aw-server-rust/sqlite.db
• Older Python server: aw-server/peewee-sqlite.v2.db

Always work from a copy. ActivityWatch may perform schema migrations when opening an older database, so I would never point a newer server at the only copy of the backup.

If it is an aw-server-rust database

With the normal ActivityWatch application stopped, or using another port, try:

aw-server --port 5601 --dbpath "/path/to/archive-copy/sqlite.db" --no-legacy-import

Depending on how ActivityWatch was installed, the executable may instead be named:

aw-server-rust --port 5601 --dbpath "/path/to/archive-copy/sqlite.db" --no-legacy-import

Then open:

• http://localhost:5601

Start only the server, not aw-qt or any watchers. Otherwise, new activity could accidentally be written into the archive database.

The current Rust server documents --dbpath as a database-path override, and using it also disables automatic legacy import.

If it is an old Python database

peewee-sqlite.v2.db uses the older server format, so the current Rust server may not be able to open it directly.

The safest options are:

• run the ActivityWatch version that originally created it
• run the legacy aw-server in an isolated data directory
• allow a temporary ActivityWatch instance to migrate a copy of it

Even if migration is required, it can happen entirely inside a temporary directory. Your current database remains untouched, and you can delete the temporary files afterward.

On Linux, an isolated setup could use a separate XDG_DATA_HOME and port:

XDG_DATA_HOME=/tmp/activitywatch-archive aw-server --port 5601

Place the copied legacy ActivityWatch data under that temporary directory using the same original folder structure.

Why a SQLite viewer is not equivalent

You can inspect the database with SQLite, but ActivityWatch stores raw buckets and events, not the final Activity view.

The UI performs additional processing:

• merges heartbeat events
• applies AFK filtering
• combines window and browser data
• runs categorization rules
• resolves overlapping events
• calculates durations and summaries

A generic SQLite viewer can confirm that the data exists, but reconstructing the normal ActivityWatch reports manually would be considerably more work.

A useful feature idea

An Open Archive mode would be valuable:

• select an ActivityWatch backup folder or database
• detect its server/schema version
• create a temporary working copy
• migrate the copy when necessary
• launch an isolated server on another localhost port
• disable watchers and write operations
• delete temporary state when closed

That would provide the convenience of your VM approach without requiring a VM or polluting the active database.

So yes, this is possible today by launching a second server against a copied database. The missing part is a friendly, read-only archive viewer around that workflow.

References:

• ActivityWatch data locations: https://docs.activitywatch.net/en/latest/directories.html
• Rust server repository: https://github.com/ActivityWatch/aw-server-rust
• Legacy Python server: https://github.com/ActivityWatch/aw-server