How to count a video view you can defend

When a creator asks why their payout dropped, or an advertiser asks what they paid for, the answer depends on what you count as a view. Here is how to store the evidence and prove it.

A creator emails to ask why their payout dropped last month. An advertiser asks what, exactly, they paid for. Both questions have the same honest answer, and most teams cannot give it: it depends on what you count as a view, and the evidence is already gone. Someone on your team picked a threshold once, in an afternoon three years ago, thirty seconds, or the first frame, or half the episode, and wired it into a counter. Every view since has been filed as counted or not counted, and once it is bucketed, the watching behind it is lost. You cannot recount it under a fairer rule, and you cannot prove a single view to the person disputing it.

This is not carelessness, because the industry has never agreed on what a view is. Netflix has redefined its own several times; Meta counts at three seconds; TikTok almost immediately; and on 24 August 2026 YouTube began counting from the first frame, renaming the old thirty-second metric "engaged views," which is still the one that gates monetization. A view is not a fact you measure. It is a policy you set, and the day money rides on it, a payout, a royalty, an ad invoice, that policy becomes something you must be able to change and defend on every view.

Same viewers, same month. Nova Reels earns most when a view is the first frame and least when it is watch time; Marisol Vega is the reverse. The definition, not the work, decides the payout.

The finished view: one revenue pool, split three ways by three definitions of a view. Built from the sample export below.

The fix is to stop storing a verdict and start storing the evidence: every second actually watched, on every view. Call it the watch-second ledger. With the seconds on record, a view definition becomes a query you run, not a counter you hard-code, revenue share becomes arithmetic you own, and any single view can be proved to the creator or advertiser who asks.

view-definitions-sample-synthetic.csv: illustrative synthetic data (not real viewers): 260 views across 6 creators over one month, each row carrying the seconds actually watched and the episode length. Columns mirror a real FastPix Video Data export. Every snippet below runs against it. No FastPix account yet? The sample works without one, or start free with $25 credit (no credit card).

Download the sample video-data file (CSV) →

What Video Data records: every second, on every view

Playback happens in your player. FastPix Video Data captures every interaction from inside it: it dedupes the beacons, stitches events into sessions, adds geo and device data, and computes quality scores, across millions of concurrent views when you need it. The column that matters here is the seconds actually watched on each view. That is the watch-second ledger, and it is the raw material a bucketed view count throws away. Video Data supplies the watch-second signal; the revenue pool, the coins, and the payouts live in your billing system, joined to this data on the viewer and creator IDs. The same Video Data feed powers the episode funnel and retention dashboards. You own the arithmetic.

Part 1 · Capture

Get view data flowing from your player

Tag each view with the viewer and the creator whose content it is, so every second watched can be grouped by who watched and who gets paid.

import fastpixMetrix from "@fastpix/data-core";
fastpixMetrix.tracker(videoElement, {{
  hlsjs: hls, Hls: Hls,          // both are required
  data: {{
    workspace_id: "YOUR_WORKSPACE_KEY",
    viewer_id: viewer.id,        // who watched
    custom_1:  creator.handle,   // who gets paid
    custom_2:  series.title,
    custom_3:  episode.number,
  }},
}});

Export from the Video Data dashboard (Views → Export CSV) or the export API. The columns this article uses: viewer_id, creator, video_duration, view_total_content_playback_time (the seconds watched), view_max_playhead_position, and view_start.

Part 2 · Build

What counts as a view? Make it a setting, not a guess.

Define a view as a function of seconds watched, not a fixed counter. Then you can count the same month under every definition and watch the number move.

import chdb, pandas as pd
v = chdb.query("""SELECT creator, viewer_id,
      CAST(video_duration AS Int64)/1000.0 AS dur_s,
      CAST(view_total_content_playback_time AS Int64)/1000.0 AS watch_s
   FROM file('view-definitions-sample-synthetic.csv', CSVWithNames)""", "DataFrame")

defs = {{
  "first frame": v.watch_s > 0,
  "3 seconds":   v.watch_s >= 3,
  "15 seconds":  v.watch_s >= 15,
  "30 seconds":  v.watch_s >= 30,
  "50% done":    v.watch_s >= 0.5*v.dur_s,
}}
for name, mask in defs.items():
    print(name, int(mask.sum()))

On the sample, the count runs 260 at the first frame, 245 at 3 seconds, 198 at 15, 143 at 30, and 105 at half the episode. The thirty-second count is 45 percent lower than the first-frame one, and the first-frame count is nearly double the thirty-second. Nothing about the watching changed; only the rule did.

Start using FastPix for free. $25 credit, no credit card required. Build this on your own views this week. Create your workspace →

How to calculate creator revenue share by watch time

Split the pool by the seconds watched, not by a bucketed view count, and each creator earns in proportion to the attention they actually held. Here is the whole calculation.

POOL = 10000.0
by_watch = v.groupby("creator").watch_s.sum()
payout   = (by_watch / by_watch.sum() * POOL).round()
# or split by a view definition instead of watch time:
def by_definition(mask):
    n = v[mask].groupby("creator").size()
    return (n / n.sum() * POOL).round()

Because the rule sets the split, whoever picks it picks who earns most. On the sample, Nova Reels, a creator of many shallow, swipe-away plays, earns $2,462 when a view is the first frame but only $864 by watch time. Marisol Vega, whose smaller audience watches to the end, is the mirror image: $1,308 by first frame, $2,367 by watch time. Splitting by watch time pays for attention held, not for plays started.

Change the definition and recompute backwards

Because the ledger stores seconds, not verdicts, you can change the rule and recompute any past month exactly. Switching this pool from first-frame to a thirty-second view moves $2,597 between creators, about 26 percent of the entire pool, on the same viewers and the same month. That is the number a creator feels when a policy changes, and the ledger is what lets you show them precisely why.

Prove any single view

When a creator or an advertiser asks, you answer from the row, not from a bucket. In the sample, view v0147 is viewer u538 watching 33 seconds of a 75-second episode, 48 percent, on 14 February. It counts as a view under a first-frame, three-second, or fifteen-second rule, and does not count under a thirty-second one. Same view, three answers, each defensible, because the seconds are on record.

Part 3 · Read

What the ledger tells you

The headline number is a policy choice. A 45 percent swing between first-frame and thirty-second counting is not a measurement error; it is two different definitions of the same month. Decide which one your business reports, and know it is a decision, not a fact.

Changing the rule moves real money. Moving from a first-frame to a watch-time split shifts 26 percent of the pool between creators, so the definition is worth deciding on purpose and being able to explain.

Watch time pays for attention, not for plays. A view-count rule rewards whoever generates the most starts, which favours shallow, swipe-away content. Splitting by seconds watched rewards the creators who hold an audience, which is usually what the platform actually wants to fund.

You can defend a payout only if you kept the seconds behind it. Every claim above is reconstructable to the single view because the ledger keeps the seconds watched. A bucketed counter cannot answer "why did my payout move," because the watching is already gone.

Part 4 · Act

Turn the ledger into payouts and proof

FastPix supplies the seconds watched per view; your billing system holds the pool and sends the money. The ledger drives the run:

defn = get_current_view_policy()          # the rule you publish to creators
shares = revenue_share(v, defn, pool=monthly_pool())
for creator, amount in shares.items():
    queue_payout(creator, amount, statement=per_view_breakdown(creator))

None of this sets your revenue-share policy for you, and it does not make a fair split feel fair to a creator who earned less. What it removes is the guesswork and the arguments you cannot win: with the seconds on record, you can change the rule, recompute the past, and prove any single view. A companion analytics view or a revenue-share calculator that lets a creator move the definition and see their own payout is a natural next build on the same data.

How different teams use this

Run this on your own data

Point the loader at your own export and set your revenue pool and the definitions you want to compare. The counting, the revenue-share split, the recompute, and the per-view audit run unchanged, and the same SQL scales from this laptop file to a real ClickHouse as your view volume grows.