Get AI summaries of any video or article — Sign up free
Logseq Time Tracking: Basics and Examples thumbnail

Logseq Time Tracking: Basics and Examples

Tools on Tech·
5 min read

Based on Tools on Tech's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Logseq time tracking is triggered by task status changes: switching to “doing” logs the start time, and switching to “to do” or “done” logs the finish time and duration.

Briefing

Logseq time tracking works by attaching time to task status changes—when a task moves into “doing,” Logseq records the start time, and when it moves out to “done” (or back to “to do”), it logs the finish time and duration. The practical payoff is that time totals emerge from your workflow without needing a background timer; the system simply writes timestamps when you switch task states.

In daily use, tasks live in a structured journal setup: a “day plan” area for fixed events like meetings (so they don’t clutter time logs), plus a “tasks” area where work items are copied in and linked to their source references. As work begins, the user updates a task’s status to “doing” (for example, “writing email to X” with details). When the work is interrupted or completed, the task is switched back to “to do” or moved forward to “done.” Each switch creates logbook entries that include start, finish, and duration; multiple work sessions on the same task produce multiple entries, and the displayed duration increases after each additional “doing” period.

Those logbook entries can be skimmed quickly via a small UI element at the end of the task, but if it doesn’t appear reliably, reloading the page resolves it. For deeper inspection, the logbook can be opened in a default app (such as code or a text editor) to view the full entry details. The workflow also supports resuming work: if the user returns later, they can locate the correct task using its unique ID—either by copying it from existing entries/task lists or by using clipboard history tools (Windows V key, with a similar approach on Linux). Once the correct task is found, switching it back to “doing” continues the time accumulation, and moving it to “done” preserves the newly added seconds.

After collecting many task-level time entries, the next step is turning them into project totals. This is done with a Logseq query that filters for tasks with specific statuses (“to do,” “doing,” “done”) and a project tag (e.g., “project Time Track”). The query outputs a table where tasks appear on the left and time aggregates appear on the right, with total time summarized at the top—enabling straightforward reporting like “six hours total” for a project once work is complete.

Two practical pain points and workarounds stand out. First, missed time tracking can be corrected by opening the logbook entry in the default app and editing the duration; Logseq then updates the displayed totals, though it’s somewhat cumbersome. Second, exporting time data for other tools may require conversion: one approach uses regex101 to transform copied log entries into a comma-separated format suitable for importing into tools like Toggle. The overall message is that Logseq time tracking is lightweight during execution, then powerful when paired with queries and occasional data conversion hacks for downstream reporting.

Cornell Notes

Logseq time tracking ties time to task status changes rather than a running timer. Moving a task into “doing” records a start timestamp, and switching it back to “to do” or forward to “done” records a finish time and duration, creating logbook entries. By tagging tasks with a project and using a query that filters for task statuses (“to do,” “doing,” “done”), totals can be aggregated into a project-level table. The workflow supports multiple work sessions per task, and resuming work relies on locating the correct task via its unique ID. When needed, durations can be edited via the logbook in a default app, and log entries can be converted for external tools using regex-based transformations.

How does Logseq decide when to start and stop tracking time for a task?

Time tracking is driven by status changes. When a task is switched to “doing,” Logseq records the exact time it was moved into that state. When the task is switched back to “to do” or forward to “done,” Logseq records the finish time and calculates the duration for that interval. It doesn’t run a background timer; it writes timestamps at the moment of each status switch.

What do logbook entries look like, and how do multiple sessions affect totals?

Logbook entries are recorded as start, finish, and duration lines for each interval. If a task is moved to “doing,” then back to “to do,” that creates one entry. Later, moving the same task to “doing” again creates another entry, and the displayed duration increases after refresh because the system aggregates the additional intervals.

Why might a logbook pop-up fail to appear, and what’s the fix?

The small logbook UI element at the end of a task may not show up reliably on the first attempt. Reloading the page resolves it, after which the logbook entries appear as expected.

How can a user resume work on the correct task later?

Resuming requires finding the same task instance. The workflow uses the task’s unique ID—copied from prior entries or from task lists—or clipboard history tools (Windows V key on Windows, with a similar history approach on Linux). Once the correct task is identified, switching it back to “doing” continues time tracking for that task.

How are project-level totals computed from many task-level time entries?

A Logseq query aggregates time by filtering tasks that match both (1) relevant statuses (“to do,” “doing,” “done”) and (2) a project tag (example tag: “project Time Track”). The query returns a table with tasks listed on the left and time totals on the right, with overall totals summarized at the top.

What are two practical workarounds for common time-tracking problems?

If a time interval was missed, the duration can be corrected by opening the logbook entry in a default app (like a code editor or text editor), editing the duration value, and saving; Logseq updates the totals afterward. For exporting data to other tools (e.g., Toggle), one hack is to copy the logbook text, paste it into regex101, and use a regular expression to convert it into a comma-separated format suitable for import.

Review Questions

  1. What specific task status transitions create logbook entries in Logseq time tracking, and how is duration calculated?
  2. How would you design a Logseq query to aggregate time for a single project across tasks with multiple statuses?
  3. What steps would you take to correct an incorrect duration after the fact using the logbook in a default app?

Key Points

  1. 1

    Logseq time tracking is triggered by task status changes: switching to “doing” logs the start time, and switching to “to do” or “done” logs the finish time and duration.

  2. 2

    Multiple “doing” intervals on the same task create multiple logbook entries, and the task’s displayed duration increases as intervals accumulate.

  3. 3

    A journal workflow can separate fixed events (like meetings) from time-tracked tasks to avoid cluttering time logs.

  4. 4

    Project totals come from a query that filters tasks by both status (“to do,” “doing,” “done”) and a project tag, then aggregates time into a table.

  5. 5

    Resuming work later typically requires locating the same task via its unique ID, which can be retrieved from prior entries or clipboard history.

  6. 6

    Missed or incorrect durations can be fixed by editing the logbook entry in a default app, then saving so Logseq recalculates totals.

  7. 7

    For exporting to other tools, logbook text can be transformed using regex101 into a format like comma-separated values for import.

Highlights

Time tracking doesn’t rely on a background timer; it records timestamps at the exact moments tasks switch into and out of “doing.”
Project-level reporting becomes straightforward once tasks are consistently tagged and aggregated with a Logseq query.
Resuming work hinges on finding the correct task ID—clipboard history tools can speed up that lookup.
Durations can be corrected after the fact by editing logbook entries in a default app, though it’s a bit cumbersome.
Regex-based conversion (via regex101) can turn Logseq time entries into importable formats for tools like Toggle.

Topics

  • Logseq Time Tracking
  • Task Statuses
  • Logbook Entries
  • Project Queries
  • Export via Regex

Mentioned