Every rule behind every number.

The public view count is read from the YouTube Data API and reproduced without adjustment.

Since 24 August 2026 YouTube counts a public view from the first frame of playback, so this number rises even when someone leaves after a second. We do not correct it, because it is YouTube’s number and the point is to show it next to a stricter one.

Enforced in src/lib/youtube-public.ts

Engaged views are read from the YouTube Analytics API, and only ever with the channel owner’s authorization.

YouTube defines an engaged view as one watched past the first frame. It is visible to the creator and to nobody else, so it appears here only when that creator has connected their channel. For any channel that has not, we leave it blank.

Enforced in src/lib/youtube.ts

Verified Rate is engaged views divided by public views.

Nothing is weighted, smoothed or adjusted. It is one division, and both of its inputs are shown next to it so the arithmetic can be checked.

Enforced in src/lib/youtube.ts, verifiedRate()

When public views are zero or unknown, Verified Rate reads "Not enough data" rather than 0%.

A rate of zero and an unknown rate are different claims. Rendering the second as the first is how a page states something it does not know.

Enforced in src/lib/youtube.ts, verifiedRate() returns null

Views per hour is only shown when two readings exist and are at least 30 minutes apart. Below that the page says so.

Dividing a handful of views by a few minutes produces a large, confident and meaningless number. The window actually used is printed next to the rate, so you can see what it was measured over.

Enforced in src/lib/video.ts, computeVelocity()

If a video’s public count is lower than the previous reading, no rate is shown.

YouTube restates counts downward when it strips invalid traffic. That is a correction to the past, not a speed, and presenting it as a negative rate would describe something that did not happen.

Enforced in src/lib/video.ts, computeVelocity() returns null on a negative delta

Milestone estimates are extrapolated from the measured rate, are never shown when that rate is zero, and are never projected more than 365 days out.

It is the only forward-looking figure on the site. It changes whenever the rate changes, and a projection a year away is a guess wearing a date.

Enforced in src/lib/video.ts, projectMilestone()

YouTube Analytics data lags by roughly one to three days, so every verified figure carries the date it was read and never claims to be live.

A number presented as live that is actually three days old is a false claim about the present, which is worse than an old number honestly dated.

Enforced in src/lib/channel-page.ts, formatVerifiedAs()

Authorized per-video numbers describe a period with a start and an end, shown on the page, and are never summed across periods.

The YouTube Analytics API does not allow the video and day dimensions together, so per-video data only exists aggregated over a range. Two overlapping ranges would double count, so the most recent one is shown rather than a total.

Enforced in prisma/schema.prisma, VideoSnapshot

A stored public count is reused for up to 10 minutes before a page view triggers a fresh read. The time of the reading is always shown.

Spending an API call per visitor would be wasteful without making the number meaningfully more current. An old reading labelled with its age is honest; an unlabelled one is not.

Enforced in src/lib/video.ts, ensureTracked()

Videos on Rising are ranked on views per hour computed from readings we took. A video without enough readings is absent rather than ranked at the bottom.

Every other ordering would be an opinion. Nobody can pay to appear there, and no figure on that page is estimated.

Enforced in src/lib/video.ts, getRising()

We do not model, infer or approximate a figure that belongs to someone who has not authorized us to read it.

An estimate of somebody’s real audience, made without asking them, is the practice this site exists to argue against. Where we do not know, the page says it does not know.

Enforced in src/lib/mirror.ts

Where enough readings exist, the page draws the measured arrival rate between each pair of readings. It needs at least four readings across six hours, and nothing is drawn between readings.

A total says how much attention arrived, never when. Attention that is delivered to order tends to arrive at a steady rate and not fall away, because pacing is the point of it; attention that is earned tends to arrive in bursts and decay. Both patterns also have ordinary causes, including a paid ad campaign, a steady embed, or an algorithmic plateau, so the page shows the shape and stops there. We publish the measurement and leave the conclusion to you, because describing somebody’s audience as inauthentic without their consent is an accusation rather than a measurement.

Enforced in src/lib/arrival.ts, buildArrival()

We confirm that a figure is real as the platform reports it, read with the account holder’s authorization. We do not verify that an account’s history is authentic, that its audience was earned rather than bought, or that the person holding it is the person who built it.

Aged accounts with monetization already active are sold retail, in public, from a few hundred dollars. Every figure on one is genuinely real: the account exists, the API answers, and the new owner’s authorization is valid. Verification of that account would be correct and misleading at the same time. We cannot detect it, so we say so here rather than let the word carry a promise it does not make.

Enforced in docs/research/teardown-creator-supply-chain-2026-09-26.md

Every verified page prints the date views.tv first recorded that channel, and how long ago that was, however short.

It is a fact about our own observation rather than a claim about the creator, and it is the one date on the page that cannot be bought or backdated by anyone, including us. A history can be purchased; the day we started looking cannot. It reads badly when it is short, and printing it anyway is the point.

Enforced in src/lib/channel-page.ts, formatObservationWindow()

An upload is an outlier when its views in a window are at least 2× the median of the channel’s rankable uploads in that same window, worked out separately for public views and for engaged views.

Creator tools rank outliers on the public count alone, and since 24 August 2026 that count includes a view from the first frame, so a public outlier can be an exposure spike nobody watched. Ranking the same uploads on engaged views as well shows which outliers survive. The median, not the average, is the norm, because the average is pulled up by the very outliers it is meant to measure them against.

Enforced in src/lib/outliers.ts, outliersFor()

No outlier multiples are given for a window that starts before 24 August 2026. The figures are still shown.

On 24 August 2026 YouTube changed what a public view means. A window that starts earlier mixes the two definitions, so its median is a median of two different measurements and a multiple against it means nothing.

Enforced in src/lib/seam.ts, straddlesSeam()

With fewer than 8 rankable uploads in a window, no outlier multiples are given. The figures are still shown.

A median of a handful of uploads is not a norm, and calling one of them an outlier against it would be a confident claim from too little data. The views are real either way, so they print; only the comparison is withheld.

Enforced in src/lib/outliers.ts, MIN_OUTLIER_VIDEOS

When the median public views or the median engaged views of a window’s rankable uploads is zero, no outlier multiples are given.

A multiple of zero is undefined, and giving the public half of the comparison without the engaged half would print the one-sided ranking this feature exists to correct.

Enforced in src/lib/outliers.ts, outliersFor()

An upload published after a window started, or with no publish date on record, is listed with its figures but not ranked in that window.

It had only part of the window to earn views, so comparing it with uploads that had all of it would be unfair in both directions. Scaling its views up to a full window would be an estimate, and we do not publish estimates.

Enforced in src/lib/outliers.ts, outliersFor()