Open-Time Ad Serving Explained: Why Your Newsletter Ads Should Load When Subscribers Open

There is a quiet assumption baked into most newsletter ad platforms: that the right moment to decide which ad a subscriber sees is when the publisher presses send. This assumption is wrong, and it costs publishers real money on every single campaign. Open-time ad serving fixes it — by making the ad decision the moment a subscriber opens, not the moment the email leaves your ESP.

Why Send-Time Ad Serving Became the Default

When newsletter advertising first started scaling, email clients worked like print magazines. A publisher sent an issue, subscribers received it, and that was the transaction. The natural way to include ads was to treat them exactly like editorial content: write the copy, design the creative, paste it in, and send. Every subscriber got the same ad in the same position.

When programmatic demand entered the picture in the early 2010s, the first generation of newsletter ad technology kept this same mental model. Instead of the publisher manually picking an ad, a platform would select one — but still at send time. The ad creative would be fetched when the publisher hit send, baked into the email HTML, and delivered as a static element.

This approach has a structural problem that becomes obvious the moment you think about how email actually works. When you send a newsletter to 50,000 subscribers, those 50,000 people do not all open it at the same moment. Some open it within minutes. Some open it six hours later. Some open it three days later after seeing it in a search. According to email benchmark data, roughly 80% of opens happen within 24 hours of delivery — meaning 20% of your opens are arriving at unpredictable times across the following days.

With send-time ad serving, every single one of those opens sees the exact same ad that was selected when the publisher clicked send. The advertiser whose campaign ended the next morning? Their ad still appears on day three. The sponsor who wanted to target B2B readers during business hours? They're also appearing for the subscriber who opens at 11pm on a Saturday. The daily budget that ran out after 6 hours? The ad keeps serving — now for free, or worse, for a competitor who somehow got into the rotation.

This is not a hypothetical. It is how most newsletter advertising platforms operate today, and it explains much of the disappointment advertisers experience with newsletter ad campaigns. Stale creative, misaligned timing, and impression counting that doesn't match actual reader attention. The problem was never newsletters — it was send-time decisioning built on a print-magazine mental model.

How Open-Time Ad Serving Works

Open-time ad serving moves the decisioning step from send to open. Instead of fetching and baking in an ad when the publisher clicks send, the email contains only a lightweight reference — an image URL pointing to the ad server. When a subscriber opens the email, their client requests that image URL. The ad server receives the request, runs the full decisioning logic at that moment, and responds with the appropriate creative in real time.

The sequence looks like this:

1. Publisher sends the newsletter. The email template contains an <img> tag pointing to the ad server. No creative is selected yet. The email leaves the ESP with a placeholder.

2. Subscriber opens the email. Their email client (Gmail, Apple Mail, Outlook, etc.) begins rendering the HTML. When it encounters the ad server image URL, it makes an HTTP GET request.

3. The ad server runs the waterfall. In the milliseconds between the HTTP request arriving and the response going back, the ad server checks: which direct deals match this subscriber's attributes? Which programmatic campaigns are eligible? What is the floor price? What is the highest CPM available right now? This entire decisioning sequence completes in under 10 milliseconds on the MailAdx platform.

4. The winning creative is served. The ad server responds with the appropriate image and tracking pixels. The subscriber sees a relevant, in-budget ad. The impression is logged. Revenue is attributed to that specific open.

5. Click tracking works correctly. When the subscriber clicks the ad, the click is registered against the correct impression event — not against a batch of 50,000 sends where the majority haven't opened yet.

This is a fundamentally different architecture from send-time serving. The ad is not baked into the email — it is rendered fresh each time the email is opened. This distinction has significant practical consequences for fill rates, CPM optimization, budget management, and reporting accuracy.

For a deeper look at the platform that implements this, see how MailAdx's ad server handles send-time decisions and the publisher portal documentation.

The Practical Differences for Publishers

Fill Rate

Send-time ad serving ties your fill rate to the demand available at a single point in time — the moment you hit send. If no eligible advertisers have budget, you get a house ad or an empty slot. Open-time serving gives you a fresh auction at every open, meaning an advertiser who launched their campaign six hours after your send can still fill your inventory.

This compounds over a newsletter's open window. Most newsletters achieve 35–45% of their total opens within the first hour of delivery. That leaves 55–65% of opens happening later — and with open-time serving, each of those opens is a fresh revenue opportunity rather than a stale replay of a single decision.

Publishers using MailAdx's open-time architecture consistently achieve fill rates above 90%. Publishers on send-time platforms typically report 60–75% fill rates, with the gap representing inventory that earns nothing.

CPM Optimization

Ad demand prices fluctuate throughout the day and week. B2B advertisers bid more aggressively during business hours. Consumer brands compete more intensely on Tuesday–Thursday. Holiday campaigns push CPMs up significantly in Q4. With send-time serving, you capture the CPM that was available when you sent — regardless of when your subscribers actually open.

Open-time serving captures the CPM available at the moment of each open. A subscriber who opens your newsletter at 10am Tuesday might see a $28 CPM campaign. The subscriber who opens the same newsletter at 9pm Saturday sees whatever demand exists at that moment — which may be $18 CPM or it may be $32 CPM from a Saturday-specific campaign. The waterfall logic optimizes each impression individually.

This dynamic CPM optimization is one reason MailAdx publishers consistently see higher effective CPMs than those using static send-time platforms. The difference is not always dramatic on a per-impression basis, but across millions of monthly opens it compounds meaningfully.

Budget Management

Send-time platforms have a budget management problem that is difficult to solve cleanly. If an advertiser sets a $500 daily budget and your newsletter sends to 80,000 subscribers, the platform faces an impossible question: how many of those 50,000 will open? It has to estimate, and it will regularly be wrong in both directions — either exhausting budget too early or under-serving.

Open-time serving solves this precisely. Budget is checked and decremented at the moment of each impression. When an advertiser's daily budget hits zero, no further impressions are served. There is no estimation, no over-delivery, and no under-delivery. Budget execution is exact.

This matters for advertisers in a way that directly affects publisher revenue. Advertisers who trust their budget is being spent accurately and efficiently are willing to pay higher CPMs and run larger campaigns. Sloppy budget execution erodes that trust and leads to lower bids and more restrictive campaign caps — both of which reduce publisher revenue.

How Impressions Are Counted Differently

A fundamental question in newsletter advertising is: what counts as an impression?

Send-time platforms typically count sends as impressions. If you sent to 50,000 subscribers, you served 50,000 impressions — regardless of how many people actually opened the email. This means advertisers pay for impressions on subscribers who never saw their ad, and publishers collect revenue on inventory they never actually delivered.

Open-time serving counts impressions only when the ad is actually rendered — when a subscriber opens the email and the image URL is requested. If only 22,000 of your 50,000 subscribers open a particular send, only 22,000 impressions are recorded. This is more honest, and it commands higher advertiser trust.

Publishers sometimes worry that this will reduce their revenue — fewer billable impressions than sends. In practice, the higher CPMs that honest impression counting attracts more than compensate. Advertisers paying for verified opens rather than speculative sends will bid significantly higher for that inventory because the quality is demonstrably better. A publisher charging $22 CPM on genuine opens will typically out-earn a publisher charging $18 CPM on inflated send-counts.

The MailAdx reporting dashboard shows both sends and opens clearly, with effective CPM calculated on opens rather than sends.

Why Open-Time Serving Is Critical in an Apple MPP World

Apple Mail Privacy Protection (MPP), launched in September 2021, fundamentally broke send-time impression tracking. When an Apple Mail user has MPP enabled, Apple's servers pre-fetch all images in an email — including ad serving pixels — before the subscriber ever opens the message. This means a send-time platform sees an "open" event the moment Apple's infrastructure fetches the image, even if the subscriber never actually reads the email.

The consequences for send-time ad serving are severe:

If your platform serves ads at send time, MPP doesn't matter — the ad was already baked in. But if your platform fires impression tracking pixels on image load (as most do), MPP triggers those pixels for every Apple Mail subscriber — whether they opened or not. This inflates open rates, distorts impression counts, and makes CTR calculations meaningless.

The fuller picture of how to handle this is covered in our guide to Gmail and Apple MPP tracking for newsletter ads. The short version: MailAdx's open-time architecture is designed to detect MPP pre-fetches by analysing User-Agent strings and IP patterns, and to distinguish real human opens from automated image requests. Impressions are only logged against verified human opens. This means your reporting reflects actual reader attention rather than bot traffic.

Gmail's image proxy system creates a similar (though less severe) issue. Gmail caches images on its own servers and serves them from those servers, masking subscriber IP addresses and making individualised open detection more complex. MailAdx handles this through subscriber hash matching rather than IP-based identification — an approach that is both more privacy-respecting and more accurate. See also: audience targeting with email hashes.

The Open-Time Waterfall: How Demand Tiers Work

Open-time serving doesn't just mean "run an auction at open time." It means running a prioritised waterfall across multiple demand sources at open time, with configurable floor prices and category controls at each tier.

The MailAdx waterfall runs in the following order at each open:

Tier 1 — Direct-sold campaigns: If the publisher has a direct deal in place — meaning a specific advertiser has purchased guaranteed inventory at a negotiated CPM — that campaign gets first right of refusal. Direct deals typically carry the highest CPMs because they bypass competition. See how to build a direct sponsorship programalongside programmatic.

Tier 2 — Private marketplace (PMP): Preferred deals and private auctions where specific buyers have been invited to bid on the publisher's inventory at above-floor rates. This tier captures revenue from demand sources that want priority access to a specific newsletter audience.

Tier 3 — Open programmatic: The open market, where all eligible campaigns bid in real time. Floor prices apply. Category blocklists remove unwanted advertisers. The highest qualifying bid wins.

Tier 4 — House ads: If no paid demand fills at or above floor price, the publisher's own house ad runs instead of an empty slot. House ads can promote the publisher's own products, paid tiers, referral programs, or any other priority content.

The entire waterfall runs in under 10 milliseconds. The publisher configures floor prices, category blocklists, and direct deal priority through the publisher portal. The ad server executes the logic on every open automatically.

Understanding this waterfall is foundational to understanding fill rate optimization and why floor CPM strategy matters so much for publisher revenue.

What Implementation Looks Like for Publishers

Switching from send-time to open-time ad serving is technically straightforward, though it requires a different mental model from publishers who are used to the send-time approach.

The implementation involves three elements:

1. Ad tag in the email template: You add an <img> tag to your newsletter template. This tag contains the ad server URL with your publisher ID and placement key. It is added once to your template and remains there for every future send. There is no per-campaign action required on the publisher side. The full integration guide is available in our getting-started documentation.

2. Subscriber hash in the image URL: To enable frequency capping and audience targeting, the image URL includes a SHA-256 hash of the subscriber's email address. This is done via your ESP's merge tag system — a single variable like *|SHA256:EMAIL|* in Mailchimp or the equivalent in Klaviyo, Beehiiv, or other platforms. No raw email addresses are transmitted. See the ESP integration guide for your specific platform.

3. Placement configuration in the publisher portal: You create "placements" in the MailAdx publisher portal — one for each ad slot in your template. Each placement gets its own floor price, size specifications, and category controls. You can have multiple placements in a single newsletter (header, mid-content, footer) and each runs its own independent waterfall.

For publishers using Mailchimp specifically, the full step-by-step process is covered in our Mailchimp integration guide.

The shift in mental model is: you no longer think about ads on a per-send basis. You configure placements and floors once, set up your demand waterfall, and the platform handles ad selection automatically for every subsequent open. Your dashboard shows impressions, eCPM, and revenue in real time. There is no manual action required between sends.

This is meaningfully different from send-time platforms where publishers often need to manually coordinate with sponsors, upload creative, check fill rates before sends, and deal with unsold inventory on a per-campaign basis. Open-time serving eliminates most of that operational overhead.

Frequently Asked Questions

Does open-time serving work if the subscriber is offline when they open?

Email clients cache images differently. In practice, most opens happen while the subscriber has network connectivity — the email client fetches the ad URL as part of rendering. In cases where an email client has prefetched content for offline reading (common in some mobile clients), the image may not be re-fetched on open. MailAdx detects these cases and handles them through session-based fallback logic. For the vast majority of opens, the open-time fetch works exactly as designed.

Can I run open-time and direct-sold ads in the same newsletter?

Yes. This is actually the recommended approach for maximising revenue. Direct deals occupy Tier 1 of the waterfall, open programmatic fills the remaining inventory. You set the priority and floor prices; the platform executes the waterfall automatically. Read more in our guide to building a direct-sold sponsorship program.

How does frequency capping work with open-time serving?

Frequency caps are applied at the subscriber level using the SHA-256 email hash. When a subscriber's hash is associated with N impressions for a given campaign within the cap window, the ad server excludes that campaign from their waterfall. This is accurate even across multiple sends — if a subscriber has already seen an advertiser's creative twice this week via two different newsletters on the MailAdx network, the third impression will respect the frequency cap.

Does open-time serving affect deliverability?

It does not. The ad tag is a standard HTML image element, identical in structure to any other image in an email. Its presence does not trigger spam filters or affect sender reputation scores. Deliverability is determined by your sending domain, list hygiene, engagement signals, and content — not by the presence of ad serving tags.

How do I see the difference in my MailAdx reporting?

The MailAdx reporting dashboard shows impressions (opens with verified ad delivery), eCPM, click events, and spend — all calculated at the impression level, not the send level. You can break down performance by placement, by campaign, or by time period. Because impressions are tied to real opens rather than sends, your reported metrics will be lower in absolute number but significantly more meaningful for evaluating true campaign performance.

Is open-time serving available for all ESP integrations?

Open-time serving works with any ESP that allows custom HTML in email templates — which includes Mailchimp, Klaviyo, Beehiiv, ConvertKit, SendGrid, Ghost, Substack, and most others. The core requirement is the ability to include a custom <img> tag and a merge variable for the subscriber hash. See the ESP integration overviewfor specifics by platform.