Most teams that start verifying ad placements begin with a script and a list of URLs, and the script works. What fails six weeks later is everything around it: nobody agreed what counts as a failure, the checks cover the placements that were easy to reach rather than the ones that matter, the evidence is not good enough to take to a partner, and the findings accumulate in a spreadsheet that nobody owns.
Verification is a programme, not a script. Here is how to design the parts that determine whether it changes anything.
Decide what you are verifying
“Is the ad running” is four separate questions, and conflating them produces findings nobody can act on. Define each as its own check with its own pass criteria.
Presence. Did the creative render at all, in the slot it was booked into?
Placement quality. Where on the page, at what size, above or below the fold, and next to what content? A rendered ad in a stacked or one-pixel container has technically served and delivered nothing.
Targeting fidelity. Did the right creative serve to the right market, language, and device? This is the one that requires checking from inside each market, since it is unobservable from anywhere else.
Destination integrity. Does the click go where it should, through the expected redirects, to a page that loads and matches the offer? Broken landing pages waste spend as thoroughly as fraud does.
Brand safety and context. What content surrounds the placement. This is a judgement call rather than a binary, so define the categories you care about in advance rather than after an incident.
Write pass criteria for each in a way a machine can evaluate, because “looks right” does not survive contact with volume.
Design the sampling strategy
You cannot check everything continuously, and pretending otherwise produces either an unaffordable programme or a dishonest one. Sampling is the core design decision.
Weight coverage by three factors. Spend, since the placements taking most of the budget deserve most of the checks. Risk, meaning partners, exchanges or markets with a history of discrepancies, plus anything bought programmatically where you have least visibility. Recency, because new campaigns and new creatives are where errors concentrate, so sample heavily at launch and taper once a placement is proven stable.
Then be explicit about the residual: state what you are not covering, at what confidence, so nobody mistakes a sample for a census. A programme that quietly checks 4% of placements while implying full coverage is a governance problem waiting to happen.
Set frequency by how long you can tolerate a problem running. If a bad placement costing meaningful spend should be caught within two hours, that sets your sampling interval for that tier, and everything else follows from it.
Get the vantage points right
Targeting fidelity and geographic verification are only observable from inside the market, because delivery decisions depend on who appears to be asking. A check from your office, or from a cloud region, sees what that location is served, which is not what your audience sees.
That means residential exits in each market you buy, at the granularity you buy: country level for national campaigns, city level where the campaign is local. It also means matching device and locale to the segment being verified, since a desktop check tells you nothing about a mobile placement and a mismatched locale can change what serves, per matching geo, timezone and locale.
This is the operational core of ad verification, and the proxy selection considerations are in best proxies for ad verification.
Set an evidence standard
The output of verification is usually a conversation with a partner about money, so decide up front what a finding must contain to be actionable. In practice that is a screenshot at the moment of the check, the rendered dimensions and position of the ad element, the creative identifier and the final landing URL after redirects, the market, device and locale used, and a precise timestamp.
Two rules make the evidence hold up. Capture it at check time rather than reconstructing it later, because the placement will have changed by the time anyone asks. And keep the raw capture, not only the derived verdict, since disputes are usually about interpretation rather than about whether the check ran.
Retention matters here too: long enough to support a billing dispute cycle, and no longer than your data policy allows, particularly where captures may incidentally contain personal data.
Build the escalation path before you need it
This is the step most programmes skip, and it is the one that decides whether verification changes anything.
For each failure class, agree in advance what happens: which findings pause a placement automatically, which open a ticket with the partner, which require human review before any action, and which are logged for trend analysis only. Assign an owner per class, and a response time. Then agree the threshold for a commercial conversation, meaning how many findings over what period constitute a pattern worth raising as a make-good.
Without that, verification produces a growing list of observations and no consequences, which is worse than not verifying because it consumes budget and creates a false sense of control.
Instrument the programme itself
Verification systems fail silently in a specific and dangerous way: a market stops returning results and the absence of findings reads as an absence of problems.
Track, per market and per partner, how many checks were attempted, how many completed successfully, and how many produced a valid capture rather than a page that failed to load or returned a challenge. A drop in completed checks is an incident in its own right and should alert before any ad-related finding does, which is the same discipline as monitoring proxy health at scale and detecting blocked or fake content.
Then report on programme outcomes rather than activity: discrepancy rate by partner, time from occurrence to detection, spend protected, and how many findings led to a recovery. Those are the numbers that justify the programme’s own budget.
Keep it measurement, not interference
A verification programme observes; it does not participate. That means not clicking ads to test them, not generating impressions that enter reporting, and pacing checks so they are negligible against real traffic on the publishers you are verifying. Beyond being the right posture, it keeps your own data clean, since a system that distorts delivery is measuring itself.
A sequence to build it in
If you are starting from nothing: define the check types and pass criteria, pick the first tier of placements by spend, get vantage points for those markets, set the evidence standard, wire automatic evaluation, agree the escalation path with owners, instrument the programme’s own health, then expand coverage. Doing it in that order means the first finding you produce is already actionable, which is what earns the programme its next phase of investment.
The bottom line
Treat verification as a programme with three designed components rather than as a script. Split “is it running” into presence, placement quality, targeting fidelity, destination integrity and brand safety, each with machine-evaluable criteria. Sample deliberately, weighted by spend, risk and recency, and state openly what you are not covering. Check from inside each market at the granularity you buy, because targeting fidelity is invisible from anywhere else. Set an evidence standard that survives a partner dispute, and capture it at check time. Decide the escalation path before the first finding, or the findings will not lead anywhere. And instrument the programme itself, because silence from a market is the failure mode that looks most like success.
The market coverage underneath is ad verification running on residential proxies, with country and city targeting so each check sits in the market it is verifying, and per-GB pricing that lets sampling frequency be a programme decision rather than a licensing one.