miinideckmiinideck
PricingUse casesBlog
Sign in
Comparisons

Best free way to send an HTML email to a client for approval before it goes out

A test send, your ESP's preview, a rendering-test service, a screenshot, the .html as an attachment, or a hosted page link: what each one shows the client, what a browser preview can and can't prove about an email, and the combination that gets sign-off without surprises.

By miinideck·October 14, 2026·8 min read

The template is built. You've sent it to your own inbox a dozen times, fixed the Outlook spacing, and checked it on your phone. Now the client has to approve it before it goes into the ESP and out to their list.

You could send a screenshot, but the links can't be clicked. You could send a test email, and then it sits in their inbox, gets forwarded to three colleagues, and the edits come back as a reply-all. You could attach the .html, and their mail filter might not let it through.

Each of those is the right tool for something. The trick is noticing that "approve the email" is two different requests.

TL;DR
  • First ask what the client is signing off: the copy and layout, or how it looks in their inbox? Those need different tools.
  • For copy, layout and links, a web link to the rendered email is the easiest thing to review: nothing to download, nothing in their inbox, every link clickable.
  • A browser can't show you classic Outlook, dark mode or Gmail clipping. For that, use a rendering-test service, then one real test send as the last check.
  • If you use a link, a private-link host keeps an unsent campaign out of search and lets every revision round use the same link.

Is the client approving the copy, or how it looks in their inbox?

Most sign-off is about the first. Does the headline say the right thing, is the offer correct, is the legal line there, do the buttons go to the right pages, is the logo the new one. The client is checking content and layout, and they can do that anywhere the email renders faithfully.

The second question, whether the email survives Outlook, dark mode and a phone, is a technical check. It's usually your job, not theirs, and the client can't do it from their own inbox anyway: their inbox is one mail app out of dozens.

Keep those apart and the choice of tools gets simple.

What are the ways to get an HTML email approved?

Six routes, each one built for a different job:

WayWhat the client seesWhat it's built forWhere it gets awkward
A test send from your ESPThe real email, in their own inboxThe final check that it arrives and rendersOne mail app only; can be forwarded; edits come back as email replies
Your ESP's preview or share featureA preview inside or linked from the ESPChecking inside the tool you'll send fromDepends on your ESP and plan, and the client may need to be let into it
A rendering-test service (Litmus, Email on Acid)Screenshots of the email in many mail apps and devicesTechnical QA across clients before sendingPaid (Email on Acid has no free plan; Litmus prices on request), and built for the developer, not for client comments
A screenshot or PDFA picture of the emailA quick look at the designLinks can't be clicked, text can't be searched for typos
The .html as an attachmentA file to download and open in a browserHanding over the sourceDownload step; a company's mail filter can be set to block .html attachments
A hosted page link (miinideck)The email rendered as a web page in their browser, at an unguessable addressReviewing copy, layout and links before anything is sentA browser is not an inbox (see the next section)

For the wider trade-off between attaching a file and sending a link, an email attachment vs a link for deliverables covers size, rendering and control. And if you've been sending screen recordings of the email for review, screen recording vs a live link goes through what each one loses.

What can a browser preview prove, and what can't it?

This is the honest boundary of the link route, and it's worth saying to the client too.

What it proves: the copy is right, the layout reads the way you intended at desktop and phone widths, the images load, and every link goes where it should. That's most of what a client is actually approving.

What it can't prove:

  • Classic Outlook on Windows. It renders email with Microsoft Word's engine, not a browser engine, so spacing, background images and some CSS behave differently there.
  • Dark mode. Mail apps handle dark mode differently: some leave the email alone, some invert parts of it. A browser shows you the light version.
  • Gmail clipping. Gmail cuts off long emails and shows a link to view the rest. Email testing vendors put the threshold at about 102 KB of HTML (Email on Acid's guide, as of 1 October 2026; Google doesn't publish a number).
  • What the ESP adds at send time. Tracking links, unsubscribe footers and filled-in merge fields aren't there yet.

So the combination that works: a web link for the client to sign off copy and layout, then your own rendering check (a testing service, or your own set of test inboxes), then one test send as the last step before the campaign goes out.

Will merge tags and tracking links break the preview?

They won't break it, but they will show.

Before the ESP fills them in, merge tags appear as literal text: a Mailchimp first-name field shows as *|FNAME|*, and other ESPs use their own syntax. Tell the client once, in the message with the link, that anything in that shape will be filled in at send time. Otherwise the first comment you get back is "there's a typo in the greeting".

Links in the preview are your raw links. ESPs that track clicks typically rewrite links when the campaign is sent, so the client clicking a link in the preview doesn't show up in your campaign report.

One practical point: if the template references images by a relative path on your machine (images/hero.png), the images won't come with a single .html file. Either use the absolute image URLs the ESP will host them at, or zip the HTML together with its images folder.

Which one should I use?

The short version:

  • The client is signing off copy, layout and links. Send a web link to the rendered email.
  • You need to know how it renders across mail apps. Use a rendering-test service. That's QA for you, not a review screen for them.
  • The client's team works inside the ESP already. Use the ESP's own preview or share feature, so the approval happens where the campaign lives.
  • It's the last step before sending. One test send to real inboxes, including the client's if they want to see it arrive.
  • They just need a quick glance at the design, not the words. A screenshot is fine.

Whichever you use for review, try not to run revision rounds by attachment. Each round becomes a new file in their downloads and a new question about which one is current. It's the same problem a Google Drive link vs a private link looks at for any file that keeps changing.

When a private link is the right shape

That's the job miinideck is built around: a finished page going to specific people, where you keep hold of the link.

You upload the email's .html (or a ZIP with its images) and get a link ending in 32 random characters. The page tells search engines not to index it, which matters for a campaign that hasn't gone out: an announcement or a sale shouldn't be findable before its send date. The client opens the link in any browser. They don't need an account, and nothing lands in their inbox except your message with the link.

Then the review itself:

  • Every revision on the same link. With an account, you replace the file after each round and the link the client already has opens the new version. There's no "v3-final-FINAL.html".
  • Comments on the exact spot. Turn on Review and the client can pin a comment to the headline, the button or the footer line without making an account. You mark each one resolved as you fix it. Review is free on every plan. Collecting comments on a shared page shows how it works.
  • A password for embargoed campaigns. If the email announces something that isn't public yet, put a password on the link. It's free on any account.
  • Let it lapse after sign-off. Free-account links run 7 days by default, which is often about one approval cycle.

The limits, stated plainly: an email template is small, so the No-account cap of 3 MB won't matter, but a No-account link runs 7 days and can't be replaced, which you'll want for revision rounds. Free-tier links also show a small "Powered by" footer below the page, which isn't part of your email. Paid plans drop it. And again: the link shows the email in a browser. It isn't an inbox test.


If the template is ready, drop the .html in and get a link. There's no account needed to try it. And if you're sorting out where files like this should live in general, where to put a file online maps every option by what you're holding.

More in Comparisons

Best free way to share API docs with a partner before launch

Postman's published docs, SwaggerHub, a hosted docs portal, GitHub Pages, the raw OpenAPI file, or one rendered HTML page behind a private link: what each is built for, how to turn a spec into a single page with one command, and what to strip out before anyone outside sees it.

October 11, 2026·8 min read

Quarto Pub vs RPubs vs Posit Connect vs GitHub Pages: where to publish a Quarto or R Markdown report

Quarto Pub, RPubs, Posit Connect Cloud, GitHub Pages or Netlify, an HTML attachment, or a private link: what each one is built for, why a rendered report loses its styling when you send the HTML on its own, and which route fits a report meant for a client or an advisor.

October 10, 2026·9 min read

Best free way to share an interactive chart as a link

A screenshot, an HTML attachment, Datawrapper, Flourish, Tableau Public, a public site, a drive, or a private link: what each one is built for, who ends up able to see the chart, and why the same Plotly chart can be 4.8 MB or 12 KB.

October 8, 2026·9 min read

Send your own private link.

miinideck turns a single HTML file into an unguessable link with optional password and expiry. Default-private, never indexed.

See pricingTry it free →
miinideck

HTML files, finally as links — for AI builders, agencies, and consultants. Default-noindex, default-private, default-yours.

Product

  • Pricing
  • Use cases
  • Free HTML hosting
  • Try it free

Resources

  • Blog
  • Free tools
  • Featured on
  • Report abuse

Legal

  • Privacy
  • Terms
Listed onmiinideck listed on Product Huntmiinideck listed on Faziermiinideck listed on TheSaaSDirmiinideck listed on AIToolHuntmiinideck listed on LaunchNest
© 2026 miinideckMade for people who don't want their work indexed.