Skip to main content

Dwell Time

How long readers stay on each Signal Check edition and dashboard, as a drop-off curve of page views.

How long readers keep a Signal Check edition or a published dashboard open and visible, measured per page from the meta-analytics GA4 property.

Dwell time is a drop-off curve, not a single average. Each page fires one event the first time a page view reaches 1, 5, 15, 30, 60, 120, 300, and 600 seconds of visible time (read_1s through read_600s). The share of page views that reached each mark shows how far readers get. The median reader’s dwell time is read off that curve.

Only Signal Check editions and the dashboards fire these events. The Metrics Cookbook stream does not, nor does any production CanadaLogin page.

Calculation

Dwell curve: for each page and each milestone, divide the read_Ns event count by the page_view event count over the reporting window. Both come from meta_page_events.

Median dwell time: the time at which half of the page’s views were still open. Take the last milestone at least half the views reached and the next one, and interpolate on a log scale to where the share crosses 50%. It is 0 when fewer than half reached 1 second, and infinite when half were still open at 600 seconds.

Total reading time: count each page view as the last milestone it reached, and add them up. A view that reached 60 seconds but not 120 counts as 60 seconds, one that reached 600 counts as 600, and one that never reached 1 second counts as 0. From the event counts, that is each milestone times the views that reached it but not the next one, summed.

Group on pagepath_redacted, never pagepath, which holds a private token for Signal Check pages.

Dwell curve:

WITH events AS (
    SELECT
        pagepath_redacted,
        eventname,
        SUM(eventcount) AS n
    FROM google_analytics.meta_page_events
    WHERE page_kind IN ('signal_check', 'dashboard')
      AND (eventname = 'page_view' OR REGEXP_LIKE(eventname, '^read_[0-9]+s$'))
      -- set the reporting window; see the timespans note in cookbook/notes.qmd
      AND CAST(date AS DATE) BETWEEN DATE '2026-09-01' AND DATE '2026-09-30'
    GROUP BY pagepath_redacted, eventname
),
views AS (
    SELECT pagepath_redacted, n AS page_views
    FROM events
    WHERE eventname = 'page_view'
)
SELECT
    e.pagepath_redacted,
    CAST(REGEXP_EXTRACT(e.eventname, '[0-9]+') AS INTEGER) AS milestone_seconds,
    v.page_views,
    e.n AS page_views_reached,
    CAST(e.n AS DOUBLE) / v.page_views AS share_reached
FROM events e
JOIN views v ON e.pagepath_redacted = v.pagepath_redacted
WHERE e.eventname <> 'page_view'
ORDER BY e.pagepath_redacted, milestone_seconds;

Median dwell time:

WITH events AS (
    SELECT
        pagepath_redacted,
        eventname,
        SUM(eventcount) AS n
    FROM google_analytics.meta_page_events
    WHERE page_kind IN ('signal_check', 'dashboard')
      AND (eventname = 'page_view' OR REGEXP_LIKE(eventname, '^read_[0-9]+s$'))
      -- set the reporting window; see the timespans note in cookbook/notes.qmd
      AND CAST(date AS DATE) BETWEEN DATE '2026-09-01' AND DATE '2026-09-30'
    GROUP BY pagepath_redacted, eventname
),
views AS (
    SELECT pagepath_redacted, n AS page_views
    FROM events
    WHERE eventname = 'page_view'
),
-- every milestone, so one nobody reached reads as zero, not missing
curve AS (
    SELECT
        v.pagepath_redacted,
        v.page_views,
        m.seconds,
        CAST(COALESCE(e.n, 0) AS DOUBLE) / v.page_views AS share,
        LEAD(m.seconds) OVER (PARTITION BY v.pagepath_redacted ORDER BY m.seconds) AS next_seconds,
        LEAD(CAST(COALESCE(e.n, 0) AS DOUBLE) / v.page_views)
            OVER (PARTITION BY v.pagepath_redacted ORDER BY m.seconds) AS next_share
    FROM views v
    CROSS JOIN UNNEST(ARRAY[1, 5, 15, 30, 60, 120, 300, 600]) AS m (seconds)
    LEFT JOIN events e
        ON e.pagepath_redacted = v.pagepath_redacted
       AND e.eventname = 'read_' || CAST(m.seconds AS VARCHAR) || 's'
),
crossing AS (
    SELECT
        *,
        ROW_NUMBER() OVER (PARTITION BY pagepath_redacted ORDER BY seconds DESC) AS rn
    FROM curve
    WHERE share >= 0.5
)
SELECT
    v.pagepath_redacted,
    v.page_views,
    CASE
        -- fewer than half of the page views reached 1 second
        WHEN c.seconds IS NULL THEN 0
        -- half were still open at the last milestone
        WHEN c.next_seconds IS NULL THEN infinity()
        ELSE exp(ln(c.seconds) + (c.share - 0.5) / (c.share - c.next_share)
                 * (ln(c.next_seconds) - ln(c.seconds)))
    END AS median_dwell_seconds
FROM views v
LEFT JOIN crossing c
    ON c.pagepath_redacted = v.pagepath_redacted
   AND c.rn = 1
ORDER BY v.pagepath_redacted;

Total reading time:

WITH events AS (
    SELECT
        pagepath_redacted,
        eventname,
        SUM(eventcount) AS n
    FROM google_analytics.meta_page_events
    WHERE page_kind IN ('signal_check', 'dashboard')
      AND (eventname = 'page_view' OR REGEXP_LIKE(eventname, '^read_[0-9]+s$'))
      -- set the reporting window; see the timespans note in cookbook/notes.qmd
      AND CAST(date AS DATE) BETWEEN DATE '2026-09-01' AND DATE '2026-09-30'
    GROUP BY pagepath_redacted, eventname
),
reached AS (
    SELECT
        pagepath_redacted,
        CAST(REGEXP_EXTRACT(eventname, '[0-9]+') AS INTEGER) AS seconds,
        n
    FROM events
    WHERE eventname <> 'page_view'
),
stops AS (
    SELECT
        pagepath_redacted,
        seconds,
        -- views whose last milestone this was: reached it, not the next one
        GREATEST(n - COALESCE(LEAD(n) OVER (PARTITION BY pagepath_redacted ORDER BY seconds), 0), 0)
            AS stopped_here
    FROM reached
)
SELECT
    pagepath_redacted,
    SUM(seconds * stopped_here) AS reading_seconds
FROM stops
GROUP BY pagepath_redacted
ORDER BY pagepath_redacted;

Dwell curve:

events <- tbl(con, in_schema("google_analytics", "meta_page_events")) |>
  filter(
    page_kind %in% c("signal_check", "dashboard"),
    eventname == "page_view" | str_detect(eventname, "^read_[0-9]+s$"),
    # set the reporting window; see the timespans note in cookbook/notes.qmd
    as.Date(date) >= as.Date("2026-09-01"),
    as.Date(date) <= as.Date("2026-09-30")
  ) |>
  group_by(pagepath_redacted, eventname) |>
  summarise(n = sum(eventcount, na.rm = TRUE), .groups = "drop")

views <- events |>
  filter(eventname == "page_view") |>
  select(pagepath_redacted, page_views = n)

events |>
  filter(eventname != "page_view") |>
  inner_join(views, by = "pagepath_redacted") |>
  transmute(
    pagepath_redacted,
    milestone_seconds = as.integer(str_extract(eventname, "[0-9]+")),
    page_views,
    page_views_reached = n,
    share_reached = as.numeric(n) / page_views
  ) |>
  arrange(pagepath_redacted, milestone_seconds)

Median dwell time:

milestones <- c(1, 5, 15, 30, 60, 120, 300, 600)

# The time half the page views were still open, interpolated on a log scale
# between the milestones either side of 50%. `seconds` must be sorted.
median_read <- function(seconds, share) {
  above <- which(share >= 0.5)
  if (length(above) == 0L) return(0)
  i <- max(above)
  if (i == length(seconds)) return(Inf)
  step <- (share[i] - 0.5) / (share[i] - share[i + 1L])
  exp(log(seconds[i]) + step * (log(seconds[i + 1L]) - log(seconds[i])))
}

events <- tbl(con, in_schema("google_analytics", "meta_page_events")) |>
  filter(
    page_kind %in% c("signal_check", "dashboard"),
    eventname == "page_view" | str_detect(eventname, "^read_[0-9]+s$"),
    # set the reporting window; see the timespans note in cookbook/notes.qmd
    as.Date(date) >= as.Date("2026-09-01"),
    as.Date(date) <= as.Date("2026-09-30")
  ) |>
  group_by(pagepath_redacted, eventname) |>
  summarise(n = sum(eventcount, na.rm = TRUE), .groups = "drop") |>
  collect() |>
  mutate(n = as.numeric(n))

views <- events |>
  filter(eventname == "page_view") |>
  select(pagepath_redacted, page_views = n)

reached <- events |>
  filter(eventname != "page_view") |>
  transmute(
    pagepath_redacted,
    seconds = as.numeric(str_extract(eventname, "[0-9]+")),
    n
  )

views |>
  # every milestone, so one nobody reached reads as zero, not missing
  cross_join(tibble(seconds = milestones)) |>
  left_join(reached, by = c("pagepath_redacted", "seconds")) |>
  mutate(share = coalesce(n, 0) / page_views) |>
  arrange(pagepath_redacted, seconds) |>
  group_by(pagepath_redacted, page_views) |>
  summarise(median_dwell_seconds = median_read(seconds, share), .groups = "drop") |>
  arrange(pagepath_redacted)

Total reading time:

tbl(con, in_schema("google_analytics", "meta_page_events")) |>
  filter(
    page_kind %in% c("signal_check", "dashboard"),
    str_detect(eventname, "^read_[0-9]+s$"),
    # set the reporting window; see the timespans note in cookbook/notes.qmd
    as.Date(date) >= as.Date("2026-09-01"),
    as.Date(date) <= as.Date("2026-09-30")
  ) |>
  group_by(pagepath_redacted, eventname) |>
  summarise(n = sum(eventcount, na.rm = TRUE), .groups = "drop") |>
  collect() |>
  mutate(n = as.numeric(n), seconds = as.numeric(str_extract(eventname, "[0-9]+"))) |>
  group_by(pagepath_redacted) |>
  arrange(seconds, .by_group = TRUE) |>
  # views whose last milestone this was: reached it, not the next one
  mutate(stopped_here = pmax(n - lead(n, default = 0), 0)) |>
  summarise(reading_seconds = sum(seconds * stopped_here), .groups = "drop") |>
  arrange(pagepath_redacted)

Interpretation notes

Only visible time counts. The clock pauses while the tab is in the background and resumes when the reader comes back, so a tab left open overnight does not reach read_600s unless someone is looking at it.

The median is an estimate between two measured milestones. A median_dwell_seconds of 45 means half the views passed 30 seconds and fewer than half passed 60; the interpolation places the crossing in between. An infinite median means half the views were still open at 10 minutes, so report it as “over 10 minutes”. Signal Checks before #9 report the floor milestone instead, the longest milestone at least half the views reached, so their medians read lower.

To combine pages, such as every dashboard, add their page_view and read_Ns counts across the pages first, then build one curve and read the median off it. Never average the per-page medians: a page with five views would count as much as one with ninety.

Total reading time is a floor. Every view counts at the last milestone it passed, not at the time it was really open, so the total is time readers spent at the least. Say “at least” when you quote it. A view open for four minutes counts as two, and the 600-second cap means a long read counts as ten minutes.

Prefer the curve or the median to an average. Readership is small, often a few dozen page views per page per month, and one forgotten tab can move a mean a long way. At these counts, check page_views before comparing two pages. A share built on five page views is too unstable to rank.

The curve counts page views, not people. A reader who reloads the page, or comes back on another day, starts the milestones again and counts twice. Use page_views as the denominator, since totalusers in meta_page_events can’t be summed across days.

read_1s is approximate. The page checks the clock once a second, so read_1s means “1 to 2 seconds”. Milestones from 15 seconds up are not affected.

This metric covers only Signal Check editions and the dashboards. Public CanadaLogin pages do not fire read_Ns events. For time on those pages, use GA4’s built-in average engagement time, which is only available in the GA4 interface, not in the data lake.

Alternative names

  • time on page
  • reading time
  • read depth
  • engagement time
  • total reading time