If you build or QA marketing emails, you know the drill: every client renders them a little differently, and what looks great in Gmail might explode in Outlook. Manually testing every send in every client is a special kind of pain. This guide is for anyone who’s tired of wasting time on repetitive previews — and wants a straightforward way to automate the whole mess using Emailonacid.
Let’s cut the fluff and get right into it.
Why Email Previews Matter (And Why Automation Helps)
You can ignore the “pixel-perfect” hype, but you can’t ignore the reality: Outlook, Gmail, Apple Mail, and others all interpret HTML emails in their own (often broken) ways. If you only check your email in one or two clients, you will miss bugs — guaranteed.
Manual testing sounds reasonable until you’re sending more than one campaign a month. Then it’s a timesuck. Automation doesn’t just save you hours; it saves your sanity and reduces embarrassing mistakes. But you need to set it up right, or you’ll just create a new headache.
Step 1: Get Your Emailonacid Account Set Up
First things first, you’ll need an Emailonacid account with access to their automated testing features. If you’re on a free plan, fair warning: automation and advanced integrations are usually paid features. Don’t get suckered into a trial if your company won’t pay for it later.
Pro tip: If you’re in a bigger team, make sure everyone who needs to see previews or test runs has the right access. Nothing more annoying than chasing down logins.
Step 2: Decide What You Actually Need to Test
Here’s where people waste the most time: testing every email in every client, every time. Be practical. Most of your audience uses a handful of clients (check your analytics!). Focus on the top 5–10. The rest can be spot checked now and then.
Recommended clients to include: - Outlook (desktop & web, both Windows and Mac) - Gmail (web and mobile) - Apple Mail (Mac and iOS) - Yahoo Mail (if your audience skews older) - Android native mail apps
Don’t bother with ancient clients unless you have legacy customers who depend on them. And don’t test “every version of Outlook ever.” Pick the most common.
Step 3: Choose Your Automation Approach
Emailonacid offers a few ways to automate previews:
- Manual Uploads: You send or upload an email, then manually click which clients to preview. Not truly “automation,” but the baseline.
- Integrations: Hook Emailonacid into your ESP (like Mailchimp, Salesforce, or HubSpot) so that a preview triggers automatically when you send a test or publish a campaign.
- API: For developers or teams with custom tools, you can trigger previews programmatically.
For most people: Integrations strike the right balance between hands-off and not-overly-complex. APIs are powerful, but overkill unless you’re running dozens of campaigns a week or have a dev team.
Step 4: Set Up Integrations (The Easiest Way)
Let’s walk through the process for a typical integration. I’ll use Mailchimp as an example, but the steps are similar for most ESPs.
a. Connect Your ESP
- Go to the “Integrations” section in Emailonacid.
- Find your ESP (e.g., Mailchimp) and follow the prompts to connect your account. You’ll usually need to log in and grant permissions.
- Double-check that the integration lists as “Connected.”
b. Configure Automated Test Triggers
- In Emailonacid, choose which events should trigger a preview (e.g., every time you send a test email from Mailchimp).
- Pick which clients/devices you want previews for. Stick to your “must-test” list from Step 2.
- Set notification preferences so you (or your team) get alerted when previews are ready.
Pro tip: Don’t set it to trigger on every minor draft. You’ll drown in notifications and waste credits. Set it to trigger on final tests or right before approval.
c. Test the Setup
- Create a throwaway campaign or use an old one.
- Send a test through your ESP, making sure it’s routed through Emailonacid.
- Check that previews generate for the right clients, and notifications come through.
If it doesn’t work, triple-check you’re sending from the right address and that the integration is still live. ESPs love to “forget” permissions.
Step 5: Review, Fix, and Collaborate
Once previews are automated, the real work starts: fixing what’s broken.
- Review in Emailonacid: Open the test results. You’ll see screenshots for each client.
- Spot Issues Fast: Look for obvious misalignments, missing images, or text that’s unreadable. Don’t sweat one-pixel differences — nobody cares but you.
- Use the Markup Tools: Emailonacid lets you annotate issues and leave comments. Handy for collaborating or flagging for designers/developers.
- Share Results: You can generate a share link or PDF for the rest of the team or clients. Cuts down on endless “Can you show me?” emails.
Honest take: Automation won’t magically fix your code. It just tells you what’s broken, faster. You’ll still need to dig in and fix the HTML/CSS. (And yes, Outlook will still be a pain.)
Step 6: Build Email Previews Into Your QA Workflow
If you want this to actually save time, make it part of your regular process:
- Set a “preview and fix” checkpoint before you hit send or pass for approvals.
- Don’t treat previews as a chore — treat it as insurance. It’s easier to fix now than after a messy campaign goes out.
- If you’re working in a team, assign someone as the “preview checker” each send. Accountability helps.
Pro tip: Create a checklist for each campaign:
- Content done
- Links checked
- Previews reviewed in top clients
- Approval granted
This keeps you honest and avoids “I thought you checked it” disasters.
Step 7 (Optional): Advanced Automation with the API
If you’re a developer or have a custom workflow, you can use the Emailonacid API to trigger previews whenever you want — from your CI/CD pipeline, in bulk, or as part of a custom dashboard.
- Get API credentials from your Emailonacid account.
- Use their documentation to POST your email code or campaign to the API endpoint.
- Parse results and surface screenshots or errors wherever your team needs them.
Reality check: The API is powerful but not plug-and-play. Unless your volume justifies it, integrations are simpler. Only go here if you really need to.
What Works, What Doesn’t, and What to Ignore
Works well: - Catching layout bugs before they hit your audience - Saving time on repetitive manual checks - Keeping a record of what you tested and when
Doesn’t work: - Fixing code for you (you still need to know your HTML/CSS) - Making Outlook behave like a modern email client (sorry) - Magic “one-click” fixes — you still need a human eye
Ignore the hype: - You don’t need to test in 50+ clients. Focus on what your audience actually uses. - Don’t automate for the sake of automating. Make sure it fits your workflow and actually saves time.
Wrapping Up
Email previews are a hassle, but automating them with Emailonacid can seriously cut down the pain — as long as you set it up to match your real-world needs, not some “best practice” wish list. Start small, focus on your biggest clients, and build from there. Don’t overcomplicate it. The goal is to catch the stuff that matters, not to chase perfection.
Iterate, improve, and keep it simple. Your future self (and your inbox) will thank you.