View-through is a join, not a model

Ask a display vendor how a campaign performed and you get click math. Click-through on display is a fraction of a percent, so the industry built models on top of it: view-through windows, multi-touch attribution, media mix modeling. They all share one trait. Nobody can check them. There is no way to verify that the person who converted ever saw the ad.

We took a different route. We measure it.

The idea is embarrassingly simple

Delivr already runs an identity pixel on advertiser websites. It resolves anonymous visitors to real people, deterministically, with hashed emails as the spine. The move: fire that same pixel inside the ad impression itself. Same pixel, same cookie space, same identity spine.

Once an ad impression and a later site visit land in one identity space, view-through attribution stops being a model. It becomes a join.

The flow

When one of our ads renders, the creative fires an impression event carrying campaign context and our identity cookie. That event flows into the same pipeline as website traffic and lands in the same columnar event store, with a source column marking which side it came from. One schema for both worlds, sitting in Parquet on S3, queryable with anything that speaks SQL. Events that fail schema validation land in a quarantine file rather than disappearing, a boring decision that has paid for itself more than once.

Identity arrives on two legs. The browser leg is the cookie, which the impression and the later site visit share. The bidstream leg is the UID2 token that rides the auction. Tokens rotate by design, so we maintain an offline mapping layer, rebuilt continuously from our identity graph, that turns a token into a durable hashed-email identity. The binding usually lands within a day of the impression. That timing detail matters more than it looks, and the numbers below explain why.

The measurement query is then the least clever part of the system, which is the whole point. Roughly this shape:

select campaign,
       count(distinct person) as people_reached,
       count(distinct person) filter (where returned) as people_returned,
       median(return_ts - impression_ts) as time_to_return
from impressions joined to site_visits on person
group by campaign;

What we measured

The obvious objection is that a cookie set in an ad slot should not survive to a landing page in 2026. Instead of arguing about it we measured a recent impression cohort end to end. Method: restrict impressions to a five day slice so every cookie in the cohort had a full week or more to show up again, then scan site events across the following two weeks and join on the cookie. Worth admitting that our first pass scanned a shorter site window than the impression window and quietly undercounted by almost half. Align your observation windows before you trust your own funnel math.

Three numbers came out. 0.74 percent of impression cookies later showed up on an advertiser site. The median time from impression to that visit was 77 hours. And 87 percent of the returners resolved to a named person. That last one is the timing detail from earlier: the identity binding lands within a day, the median return takes three, so by the time most people come back we already know who they are.

The 0.74 percent is unremarkable, and that is fine. It is in the normal range for display behavior, and it scales linearly: per million impressions that is roughly 7,400 returning visitors, about 6,400 of them resolved to a person. The number that actually changed how we think is the 77 hours. The typical payoff of a display impression is a return visit three days later. A 24 hour attribution window misses most of that tail. We had to widen our own defaults to see our own signal, which makes us wonder how much display performance is sitting invisible inside other people's dashboards for the same reason.

The tradeoffs, honestly

Cookies are device-level, and shared browsers over-match. A kiosk machine will happily accumulate identities forever, so we cap how many people a single cookie is allowed to resolve to instead of letting one browser become a crowd.

Token rotation means the mapping layer is never finished. It is a freshness problem you operate, not a problem you solve.

Safari limits third-party persistence for the whole industry, including us. We do not model around the gap. Unresolved traffic stays unresolved in every report we produce.

Which points at the real cost of this approach: deterministic numbers are smaller than modeled numbers. A vendor selling modeled view-through will always quote you a bigger figure than we will. Ours you can check.

Why nobody else does this

You need three things at once: an identity graph deep enough to resolve strangers, presence inside the impression at serving time, and presence on the destination site. Most of adtech has one of these, sometimes two. A DSP sees the impression but has no spine on the advertiser's site. The analytics tools live on the site and never see the ad. Identity vendors sell the graph to both sides and touch neither surface. We ended up with all three mostly because we were too stubborn to pick a lane, and it took running our own serving stack to get a pixel inside the impression at all.

The next layer is person-level frequency and reach, and the full journey from impression to research activity to pipeline. Same spine, more joins. If you would rather have small true numbers than large modeled ones, that is the trade we built for.