Guide ·

Ad Screenshots: How to Show a Client That Their Ad Ran

In print, proof was simple. The paper tore out the page with your ad on it and mailed it to you, and that page was called a tear sheet. Online, the client still asks the same question, "can you show me it ran?", but the page is now assembled separately for every visitor. Open it from a script and the ad slot is often an empty grey box.

We built a test publisher page and captured it six ways to see how often that happens. Three captures had no ad at all, and one more missed the second slot. This guide covers what an ad screenshot does and does not prove, which ads you can capture on demand, and how to get the ad into the frame every time.

Three captures of the same test publisher page. Default capture: consent banner up and the ad slot empty. Full-page capture: the lazy-loaded in-article slot shows only a placeholder. Accept consent, scroll to the slot and wait: the demo ad is in place.

Short answer

  • An ad screenshot (a tear sheet, also written tearsheet) shows that the ad appeared on a given page, in a given slot, at a given moment, and that it rendered correctly. Send it with the ad server delivery report, which covers how many times it was served.
  • To capture one automatically, load the page without an ad blocker, accept the consent banner, scroll to the slot if it loads lazily, wait for the creative, then capture the slot in context and as a close-up.
  • This works on demand for fixed placements: direct-sold banners, sponsorships, native and sponsored content, and ad server preview links. It does not work for programmatic ads, where an auction decides what each visitor sees.
  • Record the URL, the capture time and the viewport next to each image. The image has no clock in it, and the record is what makes it usable as proof.

What an ad screenshot proves, and what it doesn't

"Ad verification" usually means measurement vendors such as IAS or DoubleVerify, who track viewability, fraud and brand safety across millions of impressions. A screenshot answers a smaller question, and it helps to be clear with the client about which one.

The client asksWhat answers it
Did my ad appear on that page, in the slot I paid for, looking right?A screenshot
How many times was it served, and over which dates?The ad server delivery report
Could people actually see it?Viewability measurement. Under the MRC standard that Google's Active View follows, a display ad counts as viewable when at least 50% of its area is on screen for at least one second, and a video ad when 50% is on screen for two seconds of playback
Was it shown to real people, next to acceptable content?A verification vendor's fraud and brand-safety reports

So the screenshot is the visual half of the proof, and the report is the numeric half. Clients mostly want the first because it is the only part they can look at, and it catches things reports don't: the wrong creative size, a broken image, a banner pushed below a pop-up.

Why the ad slot comes out empty: what we tested

We built a test page that behaves like an ordinary news article with ads:

  • A consent banner. No ad is requested until the visitor clicks Accept.
  • A 728×90 slot at the top, requested right after consent.
  • A 300×250 slot in the middle of the article, about 2,000 px down. It loads lazily: the request is sent only when the slot comes within 200 px of the screen.
  • An ad server that takes 900 ms to answer. The creative is a made-up brand.

We captured it at 1280×800 with headless Chromium 153 driven by Playwright 1.63, five runs per method. All five runs gave the same result every time.

#Capture methodTop slotIn-article slot
1Open the page, captureEmpty, banner upEmpty
2Open, wait for the network to go quiet, captureEmpty, banner upEmpty
3Click Accept, capture straight awayEmptyEmpty
4Click Accept, wait for the top creative, capture the screenAdNot in frame
5Same as 4, but a full-page captureAdEmpty
6Click Accept, scroll to the in-article slot, wait for its creative, captureNot in frameAd
The same in-article ad slot in two captures. On the left, the full-page capture shows a grey placeholder labelled Advertisement. On the right, after scrolling to the slot and waiting, the 300 by 250 demo creative is in place.

Each empty slot has its own cause, and each is common on real sites:

  1. Consent comes first. Methods 1 and 2 never got an ad because nothing asked for one. Waiting longer does not help: the network goes quiet precisely because the page is waiting for a click.
  2. The ad arrives after the page. In method 3 the capture ran while the ad request was still in flight. An ad is a separate request, often a chain of them, and it finishes after the page's own content.
  3. A full-page capture does not scroll. Method 5 produced a tall image of the whole article, but the browser never moved the viewport, so the lazy slot never came near the screen and never sent its request. Lazy loading is a standard option in ad tags, so below-the-fold slots often work this way.
Test setup details

The test page and its ad endpoint ran on a local Node.js server. The consent click starts the ad code; the top slot calls the ad endpoint at once, and the in-article slot calls it from an IntersectionObserver with rootMargin: 200px. Method 1 used page.goto() with the default load state and method 2 used networkidle. Methods 4 to 6 waited with locator.waitFor() on the creative element. A real site adds things this page does not have: auctions, targeting, frequency caps and bot filtering. They are covered under limits.

Which ads you can capture on demand

Before automating anything, sort the campaign's placements into those a capture server will see and those it will not.

PlacementCapture on demand?How
Fixed banner or sponsorship sold directly (100% share of voice)YesEvery visitor gets it, so a plain capture of the page works
Sponsored article, native placement, logo on a partner page, newsletter archiveYesIt is part of the page content
Direct line item in Google Ad Manager, any share of voiceYes, through a preview linkThe publisher generates an on-site preview URL for the creative (see below)
Rotating placement shared with other advertisersSometimesCapture several times and keep the hits, or ask for a preview link
Programmatic, audience-targeted or retargetingNoThe auction serves the capture server something else. Use reports
Geo-targeted to another countryNot without a proxy in that countryThe ad server decides by the visitor's IP address

Ad server preview links

If the publisher runs Google Ad Manager, ask their ad ops for an on-site preview link. In the line item they open the creative, choose Preview, then On site, enter the page URL and click Show preview URL. Google's documentation sets out the rules:

  • The page must have an ad request that matches the line item's ad unit and size. Other targeting, such as key-values or geography, is ignored, which is exactly what you want for a tearsheet.
  • The link expires after 180 days, and once opened the preview lasts 15 minutes.
  • Previews are not counted in reporting or forecasting.
  • It is not available for Ad Exchange or Programmatic Direct, for creatives rendered in SafeFrame, or for web interstitials.

The preview link is an ordinary shareable URL, so a screenshot tool can open it like any other page. Check the first capture by eye before you run a batch.

A preview shows how the creative looks in its slot. It is not evidence that the line item delivered, because the preview skips normal ad selection. Mark these captures as previews in the record and let the delivery report cover delivery.

Mock-ups are not proof. For programmatic buys, teams often paste the creative into a page screenshot. That is fine as an illustration if it is labelled as a mock-up. Presented as a live capture, it is a fabricated record.

Capture recipes with the SnapshotFlow API

The same three fixes from the test map to request parameters. Two settings apply to every ad capture:

  • Leave block_ads and block_cookie_banners off. Both are off by default. Banner blocking uses filter lists that include ad-blocking rules, so it removes the banner and the ads with it.
  • Set cache=false. Identical requests are served from cache for up to an hour by default. Proof has to be a fresh capture.

1. A fixed banner at the top of the page

Wait for the creative, not for the slot. The slot's div is in the HTML from the start; the iframe or img inside it appears only when the ad has loaded.

curl --get "https://api.snapshotflow.com/screenshot" \
  -H "X-Api-Key: $SNAPSHOTFLOW_API_KEY" \
  --data-urlencode "url=https://publisher.example/news/some-article" \
  --data-urlencode "wait_for_selector=#ad-top iframe" \
  --data-urlencode "width=1280" \
  --data-urlencode "height=800" \
  --data-urlencode "cache=false" \
  -o leaderboard-context.png

That gives the banner in context, with the site header and headline around it. For a close-up, send the same request with selector=#ad-top iframe, which crops the image to the creative. If the selector never appears, the API returns SELECTOR_NOT_FOUND instead of a picture of an empty slot, which is the behaviour you want in an unattended job. More on cropping in the element screenshot guide.

Pick the selector on the live page. Some ad tags leave an empty iframe or a house-ad placeholder in a slot that did not fill, and a selector that matches those proves nothing. Open the page in DevTools once, find an element that exists only when your creative has rendered, and look at the first capture yourself before you trust the rest.

2. A page with a consent banner

Click the accept button with click, then give the ad time to arrive with delay.

curl --get "https://api.snapshotflow.com/screenshot" \
  -H "X-Api-Key: $SNAPSHOTFLOW_API_KEY" \
  --data-urlencode "url=https://publisher.example/news/some-article" \
  --data-urlencode "wait_for_selector=#cmp-accept" \
  --data-urlencode "click=#cmp-accept" \
  --data-urlencode "delay=3000" \
  --data-urlencode "cache=false" \
  -o leaderboard-context.png
Order matters here. The API waits for wait_for_selector first, then clicks, then runs scripts, then applies delay, then captures. So on a consent-gated page, point wait_for_selector at the accept button, not at the creative: the creative cannot appear before the click, and the request would fail. In our test the same wait before the click timed out after 10 seconds.

A fixed delay is a blind wait: if the ad is slow, you get a picture of an empty slot and a normal 200 response. To turn that into an error, add selector with the creative's selector. It is checked at capture time, after the delay, and the request fails with SELECTOR_NOT_FOUND when the creative is not there. The campaign script below uses this as its check.

When the consent banner is the thing you need to document, capture it unmodified instead; see when not to block the banner.

3. A lazy-loaded slot below the fold

full_page=true will not trigger it, as method 5 showed. Scroll the slot into view with a one-line script, then wait:

curl --get "https://api.snapshotflow.com/screenshot" \
  -H "X-Api-Key: $SNAPSHOTFLOW_API_KEY" \
  --data-urlencode "url=https://publisher.example/news/some-article" \
  --data-urlencode "wait_for_selector=#cmp-accept" \
  --data-urlencode "click=#cmp-accept" \
  --data-urlencode "scripts=document.querySelector('#ad-mid').scrollIntoView({block:'center'})" \
  --data-urlencode "delay=3000" \
  --data-urlencode "cache=false" \
  -o in-article-context.png

The capture shows the slot in the middle of the screen with the article text around it. We replayed this sequence in the test browser against the test page (wait, click, script, 3-second delay, capture) and the in-article slot came back filled. For why full-page captures skip lazy content in general, see the full-page screenshot guide.

4. The mobile placement

Mobile pages usually have different slots and sizes, so capture them separately:

  --data-urlencode "width=390" \
  --data-urlencode "height=844" \
  --data-urlencode "viewport_mobile=true" \
  --data-urlencode "device_scale_factor=2" \

Some sites choose the mobile layout by user agent rather than by width. If you get the desktop page in a narrow window, add a phone user_agent string as well. The responsive screenshot guide has the common device sizes.

A script for a whole campaign

A campaign is a list of placements, so keep it as a list. Each entry has the page URL, the slot selector, a selector for the creative inside it, the consent button if there is one, whether the slot is lazy, and whether the page is the live one or an ad server preview link:

[
  { "name": "daily-sample-leaderboard", "mode": "live",
    "url": "https://publisher.example/news/some-article",
    "slot": "#ad-top", "creative": "#ad-top iframe", "consent": "#cmp-accept" },
  { "name": "daily-sample-in-article", "mode": "live",
    "url": "https://publisher.example/news/some-article",
    "slot": "#ad-mid", "creative": "#ad-mid iframe", "consent": "#cmp-accept", "lazy": true }
]

This Node.js script (version 18 or later, no dependencies) takes two captures per placement: a close-up of the creative, then the slot in context. The close-up doubles as the check. If the creative is not on the page, the API answers 422, the script saves no image and marks the placement creativeFound: false.

// tearsheets.mjs: node tearsheets.mjs placements.json
import { createHash } from "node:crypto";
import { mkdir, readFile, writeFile } from "node:fs/promises";

const API = "https://api.snapshotflow.com";
const KEY = process.env.SNAPSHOTFLOW_API_KEY;
const placements = JSON.parse(await readFile(process.argv[2], "utf8"));
const outDir = `tearsheets-${new Date().toISOString().slice(0, 10)}`;
await mkdir(outDir, { recursive: true });
const pause = (ms) => new Promise((r) => setTimeout(r, ms));

async function capture(p, file, extra = {}) {
  const params = new URLSearchParams({
    url: p.url,
    width: "1280",
    height: "800",
    cache: "false",   // proof must be a fresh capture, not a cached one
    delay: "3000",    // time for the ad request to come back
    ...extra,
  });
  if (p.consent) {
    params.set("wait_for_selector", p.consent);
    params.set("click", p.consent);
  }
  if (p.lazy) {
    params.set("scripts", `document.querySelector(${JSON.stringify(p.slot)}).scrollIntoView({block:"center"})`);
  }

  const requestedAt = new Date().toISOString();
  const res = await fetch(`${API}/screenshot?${params}`, { headers: { "X-Api-Key": KEY } });
  const isImage = res.status === 200 && (res.headers.get("content-type") ?? "").startsWith("image/");
  await pause(2000); // stay under the per-minute rate limit
  if (!isImage) return { requestedAt, status: res.status, error: await res.text() };

  const image = Buffer.from(await res.arrayBuffer());
  await writeFile(`${outDir}/${file}`, image);
  return { requestedAt, status: 200, file, sha256: createHash("sha256").update(image).digest("hex"), cache: res.headers.get("x-cache") };
}

const manifest = [];
for (const p of placements) {
  // Close-up first: `selector` fails with 422 if the creative is not on the page.
  const closeup = await capture(p, `${p.name}-closeup.png`, { selector: p.creative });
  const creativeFound = closeup.status === 200;
  // Only spend a second capture on the context shot when the creative was there.
  const context = creativeFound ? await capture(p, `${p.name}-context.png`) : null;
  manifest.push({ name: p.name, mode: p.mode, url: p.url, slot: p.slot, viewport: "1280x800", creativeFound, closeup, context });
}

await writeFile(`${outDir}/manifest.json`, JSON.stringify(manifest, null, 2));
console.table(manifest.map(({ name, mode, creativeFound }) => ({ name, mode, creativeFound })));

We ran the script against the test page with three placements. The two above came back with both images. A third, with the consent click left out, was flagged creativeFound: false and produced no files.

The manifest is the part people skip and later wish they had. For each placement it holds the URL, the slot, the viewport, mode (live or preview), and for each image the HTTP status and a SHA-256 hash of the file, so anyone can check later that the image was not edited. requestedAt is the moment the request was sent, in UTC; the capture itself happens a few seconds later. cache should read MISS, meaning a fresh capture.

The check has a limit. The close-up and the context image are two separate page loads, and the selector is checked only on the first. On a rotating placement the second load can show a different ad. Look through the context images before they go to a client.

Two notes on scale:

  • POST /batch takes up to 10 URLs in one call, but it accepts only format, size and full_page. It has no waits, clicks or scripts, so it suits fixed above-the-fold placements on pages without a consent wall. See the batch guide.
  • For hundreds of placements, async=true with a webhook_url avoids holding a connection open per capture, but it needs different code: the API answers 202 with a job_id instead of the image, and the result arrives at your webhook. The script above expects the image in the response, so do not just add the parameter to it. See async screenshots with webhooks.

What to send the client

A tearsheet that ends the conversation instead of starting a new one has five parts:

  1. The ad in context. One screen-sized capture per placement, showing the site, the page and the slot. This is what a visitor saw.
  2. A close-up of the creative, so the client can check the artwork and the size.
  3. Desktop and mobile versions when the buy covers both.
  4. The record: page URL, capture date and time with a time zone, viewport, and how it was captured (live page or ad server preview). The manifest above has all of it; paste it into a table.
  5. The delivery report from the ad server for the same dates, for the impression and click numbers.

One capture per creative per placement at launch is the usual standard. Add one mid-flight for long campaigns, and one more whenever the creative changes. If the client wants a single document, capture with format=pdf or drop the images into your report template; the webpage to PDF guide covers the options.

Client requests worth pushing back on

Ad ops teams have been arguing about tearsheet requirements for years. Landon Bennett, writing for Ad Reform, listed the recurring ones back in 2018, and they have not changed much. Here is how each one meets an automated capture:

RequestAnswer
"Show the browser address bar and the computer clock"A headless capture has neither; it is the page, not a desktop. Offer the record with URL, UTC time and file hash, which is harder to fake than a clock in the corner
"Show the site's navigation bar even though the ad is below the fold"The honest image is what a visitor sees at that scroll position. Send the context capture plus the page URL
"No other ads in the frame"Unless the buy was exclusive, other ads were there. Hiding them with hide_selectors changes the page; if you do it, say so in the record
"No negative news near the ad"That is a brand-safety question for the media plan, not something a screenshot should fix after the fact
"Several screenshots of every ad"Reasonable for a handful of placements, and cheap once scripted. For large campaigns, agree on one per creative per placement plus the reports

Limits to know before you promise anything

  • Country targeting. The capture comes from the API's servers, and SnapshotFlow's country proxies are not live yet. Browser geolocation and timezone can be emulated today, but they do not change the IP address an ad server sees. Details are in the geo-targeted screenshot guide.
  • Consent banners vary by region. A site may show a consent wall to some locations and not to others. Capture once without click to see what the server gets, then add the click if needed.
  • Bot filtering. Ad servers and some publishers treat data-center traffic as invalid and may serve a house ad or nothing. If a fixed placement stays empty after the fixes above, this is the likely reason, and a preview link is the way around it.
  • Captures are page loads. Each one requests the ad like a visitor would. A few captures per placement are noise in the delivery numbers. Hourly captures of hundreds of pages are not, so keep the schedule modest and tell the publisher.
  • Placements behind a login need session cookies or headers; see screenshots of authenticated pages.
  • Video ads come out as a single frame, which may be the poster image or a moment mid-play.
  • Permission. Capturing a public page for a client report is routine, but republishing someone's page is a different matter. The basics are in is it legal to screenshot a website.

FAQ

What is an ad tearsheet?

A tearsheet is proof that an ad ran. In print it was the page torn out of the newspaper or magazine and sent to the advertiser. For digital campaigns it is a screenshot of the ad on the page where it was booked, usually with the URL and capture time recorded next to it.

Is a screenshot proof that an ad ran?

It proves that the ad appeared on that page, in that slot, at the moment of capture, and that it rendered correctly. It does not prove how many impressions were served or whether people could see them. Send it together with the ad server delivery report, which covers the numbers.

Why is the ad slot empty in my screenshot?

The usual causes are a consent banner that has not been accepted, a capture taken before the ad response arrived, a lazy-loaded slot that was never scrolled into view, an ad blocker switched on in the capture tool, or targeting that excludes the capture server.

Can I screenshot programmatic ads?

Not on demand. A programmatic ad is chosen in an auction for each visitor, so a capture server sees whatever wins for it, which is rarely your creative. Use the delivery and verification reports as proof, and label any mock-up as a mock-up.

Should I block cookie banners when capturing ad screenshots?

No. Banner blocking works through filter lists that also block ad requests, and on many sites ads are not requested until consent is given. Click the accept button instead, then wait for the ad.

Sources and further reading

Try it on one placement: 300 free screenshots, no card

Pick one fixed placement from a live campaign, run recipe 1 or 2 on it, and compare the result with what you capture by hand today. If the slot is filled, put the rest of the list in placements.json.