Preheader Text: The Most Wasted Space in Email
Open your sent folder and look at the last five campaigns you shipped. Now look at them in Gmail’s mobile app. There’s a decent chance the gray line of text under each subject is either a repeat of the subject itself, a mangled fragment of your preheader HTML, or a URL. That line is your preheader, and in most inboxes it occupies more visual real estate than the subject line does.
Here’s the frustrating part: you probably didn’t write it. Or you wrote it, but your ESP’s template quietly overrode it. Or you wrote it and the client ignored it because of how the email was assembled. Preheader text is the only major copy asset in email that is routinely written by nobody and rendered by everybody.
This piece is about how that happens mechanically, what the trade-offs are in fixing it, and how to write preheaders deliberately rather than letting the inbox decide for you.
What the preheader actually is, and where it comes from
The preheader is the snippet of text clients display next to or beneath the subject line in a list view. It is not a dedicated email header field. There is no Preheader: header in the SMTP specification. What clients render is derived from the message body, and the rules differ by client and change without notice.
The dominant approach, used by Gmail, Apple Mail, and Outlook in most configurations, is to pull the first run of readable text from the HTML body after stripping tags, images, and hidden content. That’s why so many preheaders are the words “View this email in your browser” followed by a logo alt attribute. The client is doing exactly what it was told: reading the top of your document.
The workaround the industry settled on is the hidden preheader span: a snippet of text placed at the very top of the body, styled to be invisible in the rendered email but present in the HTML. Clients that scrape the body pick it up first. Whether they honor it depends on how it’s hidden.
How the hiding technique affects what gets scraped
Three common approaches, with different failure modes:
- Display:none. Cleanest in the rendered email, but a meaningful share of clients and spam filters treat display:none content as suspicious or skip it entirely when scraping. Gmail has historically been inconsistent here. If your ESP’s template relies solely on display:none, test it.
- Zero-height, zero-width, overflow hidden, color matched to background. The most widely used pattern. Renders invisibly and survives most scrapers. The risk is accessibility: some screen readers will announce hidden text, so keep the content meaningful rather than stuffed with keywords.
- Visible preheader text. Some brands place a short line of copy directly under the logo. It’s honest, it always renders, and it consumes vertical space above the fold. That’s a real trade-off, not a free win.
None of these is universally correct. The zero-height pattern is the safest default, but if you’re on a template you didn’t build, the first task is finding out which one you have.
Why your preheader keeps duplicating your subject line
This is the single most common complaint, and the cause is almost never a bug. It’s an assembly order problem.
Most ESPs assemble the final HTML from a template plus content blocks. If the preheader block is empty, missing, or placed after the logo and hero image in the document order, the client scrapes whatever comes first. That’s frequently the logo alt text, a “view in browser” link, or the first heading in the body. If your subject line is also the first heading, you get a duplicate.
There’s a second cause that catches people who did write a preheader: length. The visible snippet in a list view is roughly 40 to 100 characters depending on client, device, and font size, and the subject line eats into that budget in some layouts. If your preheader opens with a restatement of the subject, the client truncates before it reaches anything new. Gmail on a recent Pixel shows around 90 to 100 characters of preheader on one line; Apple Mail on iPhone shows more; Outlook desktop often shows less. Writing a preheader that only makes sense in full is writing one that mostly won’t be read.
A third cause is the ESP’s own defaults. Several major platforms auto-populate the preheader from the first paragraph of the email body if the field is left blank, and some append a merge tag or a fallback like “Having trouble viewing this email?” That default is invisible in the editor and visible in the inbox.
If you can’t answer “what exact string will appear in the preheader for this send” before you hit schedule, you don’t control your preheader. You’re hoping.
The assembly chain, step by step
Understanding the sequence is what lets you debug it. For a typical campaign send:
- Template render. The ESP merges your content into the base template. The preheader block, if the template has one, is usually a dedicated merge field or a content area at the top of the body.
- Fallback logic. If the field is empty, the platform may inject a default. Check your ESP’s documentation for what that default is; it’s often documented but rarely read.
- HTML serialization. Whitespace, comments, and conditional comments are written into the output. Some clients and scrapers are sensitive to leading whitespace before the preheader text, which can truncate it.
- Delivery and client scraping. The receiving client parses the HTML, strips hidden and image content per its own rules, and takes the first N characters of what remains.
- Truncation and layout. The client fits the result into the available width, appending an ellipsis. What you wrote and what renders are two different strings.
Each step is a place where the preheader can be replaced, truncated, or skipped. The practical implication: test the preheader in the actual clients your list uses, not in your ESP’s preview pane. The preview pane is step one. The inbox is step five.
What to actually write
The preheader’s job is to extend the subject line, not repeat it. Think of the pair as a single 130-to-160-character unit that has to do two things: earn the open, and set an accurate expectation for what’s inside.
Patterns that work
- The specific detail. Subject: “Your renewal price is changing.” Preheader: “Up 8% from March. Here’s the new rate and how to lock in the old one.” The preheader carries the number the subject withheld.
- The qualifier. Subject: “A note about your account.” Preheader: “Only affects customers on the legacy plan. Everyone else can ignore this.” This reduces unsubscribes from people who don’t need the message.
- The second half of the thought. Subject: “We got the pricing wrong.” Preheader: “And we’re refunding the difference to 4,200 customers this week.” The subject creates the question; the preheader answers enough of it to be credible.
- The deadline. Subject: “Last call.” Preheader: “Closes Thursday at 11:59pm ET. No extensions this time.” Concrete, verifiable, and it does work the subject can’t fit.
Patterns that waste the space
- Restating the subject with different words (“Big savings inside” / “Huge discounts await”).
- “View this email in your browser.” This is a functional link, not a preheader. Put it in the body footer or hide it properly.
- Alt text from the logo. If your preheader reads “CompanyName logo,” the template is broken.
- Generic urgency with no specifics. “Don’t miss out!” tells the reader nothing they didn’t already assume.
Length: aim for 40 to 90 characters of new information, front-loaded so the most important words survive truncation. Write it as a standalone line first, then check it against the subject. If the two lines could be swapped without changing the meaning, one of them is redundant.
Where to host the site behind the list
None of the tactics in this article matter if the infrastructure behind them is slow,
poorly configured, or capped at a mailbox size you outgrow in a month. If you are setting up
a site, a landing page, or a sending domain from scratch, Hostinger is a sensible starting point: entry plans are cheap enough to
experiment with, the control panel exposes DNS records for SPF, DKIM and DMARC without a support
ticket, and the VPS tier is there when you outgrow shared hosting. What matters more than the
headline price is that it scales predictably as the list grows.
Personalization and the rendering risk
Merge tags in preheaders are tempting and usually a mistake at the start of the string. The failure mode is well known: if the tag doesn’t resolve, the preheader opens with “Hi ,” or “{{first_name}},” and the reader sees a broken template before they see your offer. Some clients also render the preheader before the merge completes in certain send paths.
If you personalize, put the tag late in the string so a failure is less damaging, and always set a fallback value at the platform level. Test with a contact record that has an empty first name field. That test takes two minutes and catches the failure that reaches prospects.
There’s a contested point here worth naming. Some practitioners argue preheaders should never be personalized because the incremental lift is small and the downside is a visible defect. Others report meaningful gains from city or segment-level personalization. The honest answer is that it depends on your data quality. If your first-name field is above 98% populated and validated, personalize. If it isn’t, don’t.
Testing preheaders without fooling yourself
Preheader testing is harder than subject line testing because the preheader is not the only variable in the open rate. If you change the preheader and the open rate moves, you’ve changed the combined subject-plus-preheader impression, and you can’t cleanly attribute the effect.
A workable approach:
- Test the pair, not the preheader alone. Hold the subject constant and vary only the preheader across a 10% to 20% split. Measure open rate, but treat a difference under about 2 percentage points as noise unless your list is large enough to detect it.
- Log the rendered string. Before each test, capture what the preheader actually renders as in your two or three largest clients. Test the string the reader sees, not the string in the editor.
- Watch the downstream metric. A preheader that promises something the email doesn’t deliver will lift opens and depress clicks and unsubscribes. Track click-to-open and complaint rate alongside open rate. A preheader that overpromises is a churn accelerator.
- Run it long enough. Open rates are noisy. A 24-hour read on a small list will produce false winners. Give it at least 48 to 72 hours, and be skeptical of single-test results.
One more trap: some ESPs and inbox providers now use machine learning to generate preview snippets, and some clients show a snippet derived from the email content rather than the hidden preheader. If your test results don’t match your expectations, check whether the client is even using your preheader. You may be optimizing a string that isn’t being displayed.
The template audit you should run this week
Most teams discover their preheader problem by accident. A faster route is a deliberate audit. It takes about an hour and it will find issues in almost every template you have.
- Pull the last ten campaigns and open each in Gmail mobile, Apple Mail mobile, and Outlook desktop. Screenshot the list view.
- For each, record the exact preheader string rendered. Compare it to what was written in the editor.
- Categorize failures: duplicated subject, default fallback, alt text, URL, truncated mid-word, merge tag failure.
- Open the template source and locate the preheader block. Confirm where it sits in the document order relative to the logo and hero.
- Check the hiding method. If it’s display:none only, flag it for testing against the zero-height pattern.
- Check the ESP’s default fallback behavior and disable or replace it.
- Add a preheader field to your campaign checklist and a required field in the brief. If it’s optional, it will be skipped.
That last point is the one that actually changes outcomes. Preheaders get wasted because nobody owns them. Assign the field to the copywriter, require it before the send is approved, and put the rendered string in the QA step alongside the subject line.
Related reading
- Email Copy Structure: Writing for Skimmers Who Still Read
- Subject Line Psychology: What Actually Drives Opens
Conclusion
Preheader text is wasted because it’s assembled by a chain of systems that nobody on the marketing team fully owns, and because the easiest thing to write is a restatement of the subject line. Both problems are fixable, and neither requires new tooling.
The mechanics matter: know where your preheader block sits, how it’s hidden, what your platform does when it’s empty, and what string actually renders in your top clients. The copy matters too, but it only matters if the string survives assembly. Write 40 to 90 characters of new information, front-load the specific detail, keep merge tags late and fallback-protected, and test the pair rather than the preheader in isolation.
The inbox gives you two lines of text to earn an open. Most senders spend their effort on one and let a machine write the other. That’s the gap. Close it deliberately, template by template, and the difference shows up in the metrics you already track.
Disclosure: this article contains an affiliate link. If you buy through it we may earn a commission at no extra cost to you. We only link to services we would recommend on merit.
Pingback: Moosend vs ConvertKit: Which Is Better for Segmentation Features in 2026? – emailversus.com
Pingback: Email Copy Structure: Writing for Skimmers Who Still Read – emailversus.com