Compare omnichannel marketing solutions that unify email, SMS, and messaging. Find platforms with real deliverability infrastructure and value-based pricing.

Omnichannel Marketing Software: Email, SMS, and Messaging in One Platform


People send us screenshots like this all the time:

"98% delivered, 24% opens, 3% clicks... are we good?"

The annoying truth is those numbers are proxies. Delivered is an SMTP acceptance. Opens are image loads. Clicks are URL requests. And a decent amount of opens and clicks can be automated.

Below is how we read these metrics in practice: what they mean, what they don't, and what we look at when something feels off.

## TLDR

- **Delivery means "accepted by the receiving mail server," not "landed in the inbox."**
- **Opens are image loads.** Real people can open without loading images, and machines can load images without a person reading anything.
- **Clicks are closer to intent, but still noisy.** Security scanners and link checkers can create "clicks" that weren't human.
- **Mailbox providers track engagement you can't see** (replying, moving to folders, marking spam/not spam, time spent reading).
- **Use these metrics for trends and debugging, not absolute truth.**
- **If you want cleaner measurement, anchor it to first-party outcomes** (replies, sign-ins, purchases, product events), not opens.

## A quick cheat sheet (what the metric really is)

- **Delivered**: your mail server got a successful SMTP acceptance (usually a `250` response).
- **Open**: a device or service fetched your tracking pixel image URL.
- **Click**: a device or service requested your tracked redirect URL.

Everything else is inference, and it gets messy fast.

## 1) "Delivered" is an SMTP receipt, not an inbox guarantee

Most platforms count a message as "delivered" when the recipient's infrastructure says "OK, we'll take it" during the SMTP conversation. You'll often see something like:

> `250 2.0.0 OK: queued as ...`

That's a real success signal, and you should care about it. But it doesn't tell you where the message went next.

### What delivery is good for

- **Your message was accepted** (it wasn't blocked at the front door).
- **You're probably not failing authentication catastrophically** (if you were, you'd often see rejects/deferrals).
- **A provider isn't outright refusing you** (which is what a true "can't send mail" crisis looks like).

### What delivery can't tell you

- **Inbox vs spam folder placement**: the provider can accept the mail and still route it to spam.
- **Post-acceptance filtering**: some filtering happens after SMTP accept (it's possible to get an asynchronous bounce later, but "accepted then bounced" isn't the common case for most modern consumer mail).

No provider (Bento included) can tell you, with certainty, that a specific message landed in the inbox for every recipient. "Delivered" just isn't that metric.

### What to watch instead (for deliverability health)

If you're trying to answer "are we having a deliverability problem?", start with signals that are much closer to the truth:

- **Bounce/deferral rate by provider** (Gmail vs Microsoft vs Yahoo)
- **Spam complaint rate** (keep it low; spikes matter more than day-to-day noise)
- **Sudden provider-specific drops** (e.g., only Microsoft starts deferring)

When something is actually wrong, the most useful artifact is still the least glamorous: the bounce or deferral message.

Note: if you use Bento, we can pull SMTP responses for a specific send and show you exactly what's happening. Just ask.

## 2) Opens are image loads (and they're easy to misread)

An "open" is usually counted when a hidden tracking pixel (a tiny image) is requested from your tracking server.

So the metric is downstream of a lot of things you don't control:

- Whether the recipient's client loads images
- Whether the provider proxies/caches the image
- Whether a security system fetches remote content while scanning
- Whether the email gets clipped/truncated before the pixel is even reachable

### Why opens get overcounted

Opens can be inflated by automation. Common patterns:

- **Privacy prefetching / proxying**: Apple Mail's Mail Privacy Protection (MPP) is the big one. It can fetch your pixel even if the person never reads the email.
- **Security scanning**: filters may fetch remote content to classify messages.
- **Provider caching**: the "open" might be a proxy/cache fetch more than a person reading.

Depending on where scanning happens, you can even see weird sequences like an "open" timestamp that shows up before the message was successfully delivered.

### Why opens get undercounted

You can miss real readership for totally normal reasons:

- **Images disabled by default** (the user reads the text without loading images).
- **Plain-text viewing** (no pixel to load).
- **Offline reading** (email opened on a plane/train, images never load).
- **Long-message clipping** (Gmail is famous for clipping HTML around ~102KB; if your pixel is at the bottom, it can get cut off).

### What opens are still good for

Opens are still useful. Just use them for the right job:

- **Trend detection**: "opens at Gmail dropped week-over-week" can be a clue.
- **Relative testing**: subject line A vs B, send time tests, same audience, same provider mix.
- **Triage**: if opens fall off a cliff (not down 2%, but down to single digits), it's worth investigating.

Opens are not a clean engagement metric anymore. If you build automation off opens ("if opened, do X"), just know you're building on a squishy signal.

## 3) Clicks are closer to intent (but scanners can click too)

Click tracking typically works by turning your links into tracked redirect URLs. When someone (or something) requests that URL, your tracking server records it, then redirects to the real destination.

Clicks are a better indicator of interest than opens. But clicks can also be created by automation, especially in corporate environments.

Bento does block some of this, but not all.

### Why you might see scanner clicks

Some systems follow links to protect users:

- **Security link scanners** (corporate gateways, endpoint protection)
- **Safe browsing checks** that fetch pages to evaluate risk

That can produce click spikes that look real in a dashboard but don't convert, don't scroll, and don't behave like humans. If you have a Microsoft-heavy audience, this can show up as a weird spike in "clicks" that never match real sessions on the site.

### How to make click data more useful

Treat clicks as a starting point. The real question is what happens after the click.

- **Look at time-to-click**: clicks that happen immediately at delivery time are more likely to be automated than clicks that happen minutes or hours later.
- **Track what happens after the click**: did the visitor log in, purchase, or trigger a product event?
- **Use UTMs + first-party events**: clicks are a bridge; outcomes are the destination.

## 4) "Engagement" to mailbox providers is not your dashboard "engagement"

When Gmail, Yahoo, or Microsoft decide whether to place future emails in the inbox, they're not basing that decision on your open rate chart.

They see signals you don't, like:

- Replies and forwards
- Reading behavior (time spent, scrolling)
- Moving a message out of spam (strong positive)
- Marking as spam (strong negative)
- Filing into folders, starring/flagging, deleting immediately

This is why "our opens are low" and "we're going to spam" are not the same statement.

You can have an audience that reads everything with images off (low opens) and still have great inbox placement. You can also have high opens from automated fetching and still be underperforming with real humans.

## 5) How we use these metrics in practice

- **Delivery**: break out bounces/deferrals by provider and read the actual SMTP messages before you change anything.
- **Opens**: ignore small movement. Look for big shifts against your baseline, especially by provider.
- **Clicks**: assume some scanner noise, then validate with first-party outcomes (logins, purchases, activations).
- **Always watch**: spam complaints, hard bounces, and sustained sending to unengaged segments. Those can hurt inbox placement fast if they keep happening.

## Bots, scanners, and privacy: don't overreact

It's tempting to see automated opens/clicks and assume "these contacts aren't real." Usually that's the wrong conclusion.

Security systems and privacy features often interact with emails that are absolutely intended for real humans, and those humans may still read and value your mail. On the flip side, some audiences (especially security-conscious ones) routinely block images, so they'll look "unengaged" in open-based reporting even when they're not.

The better approach is to treat automation as measurement noise, then anchor your decisions in outcomes that matter: replies, conversions, product usage, and long-term list health.

## If you want cleaner measurement, track outcomes (not pixels)

If you're currently optimizing for opens, consider shifting the question from "did they open?" to "did they do the thing we wanted?"

That might be:

- Started onboarding
- Activated a feature
- Booked a demo
- Made a purchase
- Replied with a question

Those outcomes are harder to fake, and they map directly to business value.

## Further reading

If you want a deeper deliverability-native breakdown of how these metrics behave in the wild, this piece is worth your time:

- [Deliveries and Opens and Clicks](https://www.wordtothewise.com/2024/06/deliveries-and-opens-and-clicks/) (Word to the Wise)

If you're tired of guessing what your email metrics *mean*, Bento helps you zoom in on the signals that actually move inbox placement (bounces, complaints, provider-specific behavior) and build automation off first-party events, not just opens.

Learn more at [bentonow.com](https://bentonow.com) or start with a quick setup at [bentonow.com/signup](https://bentonow.com/signup).


Delivery, opens, and clicks measure server acceptances and tracking requests, not a clean count of humans reading your email. Here's how to interpret them (and what to watch instead).

What Email Delivery, Opens, and Clicks Actually Mean


# How To Handle An Email Deliverability Crisis Calmly

When someone comes to us with a deliverability problem, they usually show up for one of two reasons. Either a third-party monitoring tool flagged something and they are letting us know, or they noticed a spike in bounces/poor performance in a recent campaign. Both feel urgent. Neither means you should panic.

The first thing to know about third-party monitoring tools is that they produce a lot of false positives. They might flag an IP that isn't even being used for sending. They might surface a blocklist entry that doesn't affect your actual mail flow. The alert is real, but the impact might not be.

So before you start changing things, take a breath. Then start your delivery debugging with a bounce message. Always, always start with the bounce message.

## TLDR

- Look in your email platform and try to work out if your emails are bouncing (if they aren't it is likely a false positive).
- If they are look for a bounce message, if you can't find them open a ticket with your email provider. 
- The bounce message will contain a string with a reason i.e "554 5.7.1 The message contained a URL which is listed in the Spamhaus DBL".
- If the item mentioned in the bounce message is owned by you, like your domain or a dedicated IP you use, this is a YOU problem.
- If the item mentioned is something you don't recognise, then it's likely NOT your problem.

**If it's your problem, you need to work out what caused the issue**. In cases such as a Spamhaus listing, you're often given some information on why you got the listing such as sending to too many spam traps (list hygiene issues) or sending malware. 

**If it's not your problem, you need to talk to your email provider**. In these cases, often with a shared IP, you'll need to raise a ticket with your email provider and tell them what you've discovered. If they are on top of things they're probably already working on a delisting or fixing the issue. 

## Why People Panic (And Why You Don't Need To)

Most deliverability "crises" start the same way. A tool sends an alert, or open rates drop on a send, and suddenly it feels like all your email is broken.

But not every dip is a crisis. Deliverability naturally moves around day to day. A real problem usually looks like this:

1. **Bounce rates spike noticeably** across more than one campaign.
2. **Multiple providers are affected**, not just one inbox.
3. **It doesn't recover on its own** within 24 to 48 hours.

If one campaign underperformed but everything else looks normal, that's probably a campaign issue. Not an infrastructure problem. The distinction matters because the fix is completely different.

## Why Opens & Clicks Are Misleading 

People often come to us when opens dropped a percentage point or two. This is very rarely indicative of an issue, and more so just a mechanism of a tracking pixel not firing or bots fetching the pixel less often for a given send. We only really dig into deliverability tickets based on opens when we see them go from XX% to single digit % (i.e 5% or less). It's usually fairly drastic when it does happen. 

## Find the Bounce Message

This is always step one. The bounce message is a tell-all.

When an email bounces, the receiving server sends back a response that explains why it rejected the message. That response contains an SMTP code, the provider, and usually a human-readable reason. Go into your email platform and pull that data before you do anything else.

If you skip the bounce message and start tweaking subject lines or swapping templates, you're guessing. And guessing can make things worse by burning more reputation while the real problem goes unfixed.

## Find the Asset in the Bounce

Here's the part most people miss. The bounce message almost always references a specific asset. That asset is either an IP address or a domain. And it could be anything, not just your sending domain. It could be a link inside the email, a tracking domain, an image host, or the sending IP itself.

For example, a bounce message might say something like:

> "554 5.7.1 The message contained a URL listed on the Spamhaus DBL"

That's telling you a domain somewhere in your email is on a blocklist. It could be your domain. It could also be a third-party domain you're linking to.

Once you find the asset, you have your next question.

## Do You Own and Control It?

This is the fork in the road that decides what you do next.

**If the flagged asset is something you own and control** (your sending domain, your dedicated IP, a tracking domain you manage), then this is your problem to fix. You need to figure out what caused the listing and resolve it. In cases like a Spamhaus listing, you're often given some information about why. Maybe you were sending to too many spam traps, which points to a list hygiene issue. Maybe there was a sudden volume spike that looked suspicious.

**If the flagged asset is something you don't own or control**, then it's not directly your problem, but it's still affecting you. You need to work with whoever owns that asset to get it resolved.

### When It's a Link Inside Your Email

This one catches people off guard. We've seen it happen with link shorteners. Say you're using a service like Dub.co for link tracking, and their domain ends up on Spamhaus. Now every email you send that includes one of those links will bounce at providers that check Spamhaus, even though your own domain and IP are totally clean.

Your options in that situation:

- Reach out to the link shortener and ask them to get delisted.
- Use their custom domain feature so the tracked link runs on a domain you control.
- Switch to a different link tracking provider.

The key point is that the problem isn't your sending reputation. The problem is a domain inside your email content that's been flagged. The bounce message tells you exactly which one.

### When It's a Shared IP

If the bounce message references an IP and you're on shared sending infrastructure, the listing might have nothing to do with your sending. Another sender on that same IP could have triggered it. In that case, the right move is to contact your ESP, raise a ticket, and tell them what you found. If they're on top of things, they may already be working on a delisting. If not, ask them to delist the IP or move you to a different one.

### When It's a Dedicated IP

If you're on a dedicated IP and that IP is on a blocklist, that's almost certainly your doing. Something in your sending behavior triggered the listing. Look at what changed recently: a new segment you mailed, a volume spike, a drop in engagement, or a list source you haven't validated.

## Scope the Damage by Provider

Once you know what's flagged and why, the next step is understanding how much of your traffic is actually affected.

Not all providers use the same blocklists. This matters a lot.

Say your domain ends up on the Spamhaus DBL. What actually happens?

- **Yahoo and Microsoft** will start bouncing your mail. They check Spamhaus.
- **Gmail** probably won't bounce you. Gmail doesn't use Spamhaus for blocking decisions.

So yes, you have a real problem. But it's not all your traffic. It's a portion of it, specifically the providers that reference that particular blocklist.

Look at your bounces per provider, not just the overall bounce rate. The total number might look scary, but when you break it down, the situation is usually more contained than it first appears. That's the kind of clarity that keeps you calm.

## Contain While You Fix

Once you know which providers are bouncing and why, slow things down before making big changes:

- **Pause or throttle sends** to the affected providers.
- **Protect transactional traffic.** If your marketing sends triggered the issue, make sure order confirmations and password resets on a separate stream aren't caught in the blast radius.
- **Stop sending to unengaged segments** during triage. This isn't the time to re-engage cold contacts.
- **Hold off on campaign experiments** until baseline health returns.

Containment isn't about shutting everything down. It's about reducing damage while you work the root cause.

## Apply the Fix That Matches the Cause

Only after you've read the bounces, found the asset, and scoped the impact should you start fixing.

- **Blocklisted domain or IP you own?** Submit a delisting request and clean whatever triggered the listing. Spamhaus, Barracuda, and others have self-service removal processes.
- **Blocklisted asset you don't own?** Contact whoever owns it. If it's a shared IP, talk to your ESP. If it's a third-party link domain, talk to that provider or stop using their domain in your emails.
- **Authentication failure?** Check SPF, DKIM, and DMARC alignment. DNS changes, domain migrations, or infrastructure updates often break these without anyone noticing.
- **List quality issue?** Suppress the bad segments. Remove known spam traps. Tighten your engagement windows.
- **Reputation damage?** Reduce volume, focus on your most engaged contacts, and rebuild trust with providers gradually.

Every fix should trace back to what the bounce message told you. If you can't connect your fix to specific bounce data, you're probably still guessing.

## Ramp Back Up Carefully

After applying fixes, don't flip everything back on at once. Ramp volume back up in stages and watch the signals:

- Bounce rate by provider
- Spam complaint rate
- Inbox placement trend
- Engagement (opens, clicks) by provider

If things improve, widen traffic. If bounces climb again, pull back and re-check your assumptions. Recovery is usually gradual, not instant.

Some rough timelines for how long things take:

- **Hours**: authentication fixes, DNS corrections, simple configuration changes.
- **1 to 3 days**: blocklist delistings (once approved), content-related adjustments.
- **1 to 2+ weeks**: deeper reputation rebuilds after sustained damage or prolonged blocklist issues.

## Build Habits That Prevent This

The best way to handle a deliverability crisis is to not have one. That comes down to operating discipline:

- Keep SPF, DKIM, and DMARC aligned and check them after any DNS or infrastructure change.
- Clean your list regularly. Don't let unengaged contacts pile up.
- Ramp sending volume intentionally. Sudden spikes trigger automated defenses at mailbox providers.
- Separate your sending streams. Marketing and transactional mail should not share the same risk profile.
- Watch bounce and complaint trends weekly, not just when something breaks.

None of this is complicated. It just requires consistency. And it's much easier than debugging a crisis under pressure.

## Future Prevention

A few things that can keep your future a little more stress-free.

### Separate IPs for Transactional and Marketing

This is the single most impactful thing you can do. Run your transactional email (order confirmations, password resets, shipping updates) on a completely separate IP and domain from your marketing sends. That way, if your marketing reputation takes a hit and gets flagged, your transactional mail keeps flowing. Your customers still get their receipts and login emails while you sort out the marketing side.

### Stop Using Third-Party Link Shorteners

We talked about this earlier with the Dub.co example. Every time you use a third-party link shortener in your emails, you're trusting their domain reputation with your deliverability. If their domain gets listed, your emails bounce and you can't do anything about it except wait or switch.

The better approach is to use custom link tracking domains that you own and control. Bento supports this natively. Set up a subdomain like `click.yourdomain.com` for link tracking and you remove that dependency entirely. If something goes wrong, you can fix it yourself because it's your domain.

### Host Images on Domains You Own

Same principle as links. If you're hosting email images on a third-party CDN or image service and their domain gets flagged, your emails can start bouncing or landing in spam through no fault of your own. Host images on a domain you control, like `images.yourdomain.com` or a subdomain you manage. That way you're not exposed to someone else's reputation issues.

### Get SPF and DKIM Set Up Correctly

This sounds basic, but authentication misconfigurations are one of the most common causes of deliverability problems. Make sure your SPF record includes all legitimate sending sources, your DKIM keys are properly aligned, and your DMARC policy is set up and reporting. Check these after every DNS change, domain migration, or infrastructure update. It takes five minutes and can save you days of debugging.

### Consider Separate Subdomains for Different Sending Types

If you want to be extra cautious, send marketing email from `marketing.yourdomain.com` and transactional from `transact.yourdomain.com` (or similar). Each subdomain builds its own reputation with mailbox providers. So if one gets dinged, the other is insulated. This is overkill for most small senders, but if you're sending at volume or you've been burned before, the isolation is worth the setup cost.

## If You're Debugging a Drop Right Now

Pull your bounce data. Read the actual messages. Figure out which providers are bouncing you and why. Then work backwards from there.

Most of the time, the situation is more contained than it feels in the moment. The bounce message will tell you where to look, and scoping by provider will show you how much of your traffic is actually affected.

For a closer look at how Bento's deliverability tools and monitoring work, check out our docs and deliverability resources.

When deliverability drops, bounce messages show you where to start. Here is Bento's practical process to debug, contain issues, and recover inbox placement.

How To Handle An Email Deliverability Crisis Calmly

# Can You Use a PO Box for CAN‑SPAM? Yes.

If you’re starting a newsletter, you’ll hit this question sooner than you’d think: **do I really have to put my home address in the footer?**

Short answer: CAN‑SPAM does require a “valid physical postal address,” but that does *not* mean a street address. A PO box you’ve accurately registered with USPS (or a private mailbox you’ve accurately registered with a CMRA) can satisfy the requirement.

## TL;DR

- You need a **valid physical postal address** in commercial marketing emails.
- The FTC says that can be a **street address**, a **PO box accurately registered with USPS**, or a **private mailbox accurately registered with a commercial mail receiving agency (CMRA)**.
- Use something real, keep it up to date, and don’t forget the rest of CAN‑SPAM (especially unsubscribe).

## What the FTC Says (In Plain English)

The FTC’s CAN‑SPAM compliance guide spells out what counts. It states:

> “Your message must include your valid physical postal address. This can be your current street address, a post office box you’ve registered with the U.S. Postal Service, or a private mailbox you’ve registered with a commercial mail receiving agency established under Postal Service regulations.”

For most creators and small teams, that settles it. If you want privacy (or you don’t have a stable office address), a PO box is perfectly fine.

## What “Valid Physical Postal Address” Means in Practice

The statute itself requires a “valid physical postal address of the sender” in commercial messages. The FTC guidance above explains the practical options.

In practice, “valid” boils down to three things:

- **It’s real**: mail can be delivered there, and you can receive it.
- **It’s yours**: it’s properly registered to you/your business (PO box) or through a CMRA (private mailbox).
- **It’s maintained**: you check it and update it when things change.

If you can’t receive mail at the address you list, it’s hard to argue it’s “valid,” even if it looks professional in a footer.

## The Mistakes That Actually Cause Problems

Where people get spooked is the vague “you’ll get fined” advice. The problems are usually simpler (and fixable):

- **Using a fake or stale address** (a random location, an old office, or something you don’t control)
- **Burying or breaking unsubscribe** (or making people jump through hoops)
- **Misleading “From” names or subject lines** (trying to trick people into opening instead of being clear)

If you’re using a real PO box and you honor opt‑outs, you’re already in good shape.

## Quick Footer Checklist

- Include a **valid physical postal address** (street address, USPS PO box, or CMRA mailbox).
- Include a **clear unsubscribe** that works and is easy to spot.
- Make sure unsubscribe requests are honored **within 10 business days** (15 U.S.C. § 7704(a)(4); FTC guidance).
- Keep your opt‑out mechanism working for **at least 30 days** after you send the email (15 U.S.C. § 7704(a)(3)).
- Keep your “From” and subject line **truthful and consistent**.

## Sending internationally? (Australia, Canada, UK, Germany, France, Netherlands)

CAN‑SPAM is a US law. If you have subscribers abroad (or you’re intentionally marketing to them), you may need to follow local rules too. Here’s the high-level shape:

- **Australia (Spam Act / ACMA)**: Consent first. Identify the sender and include contact details. Include an unsubscribe option that’s clear, free, works for at least 30 days, and is actioned within 5 working days.
- **Canada (CASL / CRTC)**: Consent (express or implied). Your message needs sender identification **plus a mailing address** and at least one other contact method (phone, email, or web). Include an unsubscribe mechanism and honor opt-outs within 10 business days. You’re expected to be able to prove consent, and the mailing address must remain valid for at least 60 days after sending.
- **UK (PECR / ICO)**: Marketing emails to individuals generally require consent (with a narrow “soft opt‑in” for existing customers). Don’t conceal identity, and provide a valid address to opt out/unsubscribe. Separately, UK companies also have trading‑disclosure rules for certain business communications and websites.
- **Germany (UWG)**: Email advertising generally requires prior express consent, with a narrow existing-customer exception (and you must clearly tell customers they can object each time). Don’t hide who you are, and include a valid way to tell you to stop. If you’re a registered company (e.g., GmbH/AG), there are also “business letter” disclosure requirements that often apply to business emails/signatures.
- **France (CNIL guidance)**: For consumers, consent is the default. For professionals, outreach is often possible on an opt‑out basis if the message relates to their role — but every message should identify the sender and include a simple, free way to object/unsubscribe.
- **Netherlands (ACM + RVO)**: Opt‑in is the default, with an exception for existing customers and similar products/services. You must clearly identify the sender and make unsubscribing easy and free. Business correspondence (including emails) generally needs at least a trade name and Chamber of Commerce (KVK) number.

If you want a single “global-ish” footer that usually keeps you out of trouble, include:

- **Who you are** (company/legal name or brand)
- **A real contact method** (reply-to or support email)
- **A mailing address**
- **One-click unsubscribe** + a process to honor it fast
- **Any required company registration details** for the jurisdictions you operate in

## Sources

- FTC: [CAN‑SPAM Act: A Compliance Guide for Business](https://www.ftc.gov/business-guidance/resources/can-spam-act-compliance-guide-business)
- Rule definition (valid postal address): [16 CFR § 316.2(p)](https://www.ecfr.gov/current/title-16/chapter-I/subchapter-C/part-316/section-316.2)
- Statute text: [15 U.S.C. § 7704](https://www.law.cornell.edu/uscode/text/15/7704)
- Australia: [ACMA — Avoid sending spam](https://www.acma.gov.au/avoid-sending-spam)
- Canada: [CRTC — CASL FAQ](https://crtc.gc.ca/eng/com500/faq500.htm), [CRTC — Guidance on implied consent](https://crtc.gc.ca/eng/com500/guide.htm), and [Electronic Commerce Protection Regulations (CRTC) (CanLII)](https://www.canlii.org/en/ca/laws/regu/sor-2012-36/latest/sor-2012-36.html)
- Germany: [UWG (English) — Section 7](https://www.gesetze-im-internet.de/englisch_uwg/englisch_uwg.html) and [IHK — Required disclosures in business emails](https://www.ihk.de/osnabrueck/recht-und-fair-play/handel-und-gewerbe/handelsrecht/pflichtangaben-auch-in-geschaeftlichen-e-mails-1100948)
- UK: [ICO — Electronic mail marketing (PECR)](https://ico.org.uk/for-organisations/direct-marketing-and-privacy-and-electronic-communications/guide-to-pecr/electronic-and-telephone-marketing/electronic-mail-marketing/) and [Companies (Trading Disclosures) Regulations 2008 (PDF)](https://www.legislation.gov.uk/uksi/2008/495/pdfs/uksi_20080495_en.pdf)
- France: [CNIL — Prospecting by email](https://www.cnil.fr/fr/la-prospection-commerciale-par-courrier-electronique) and [economie.gouv.fr — obligations for commercial email](https://www.economie.gouv.fr/entreprises/developper-son-entreprise/innover-et-numeriser-son-entreprise/entreprises-quelles-sont-vos-obligations-en-matiere-de-courriel-commercial)
- Netherlands: [ACM — Prevent spam in advertising](https://www.acm.nl/nl/verkoop-aan-consumenten/reclame-en-verleiden/spam-voorkomen-uw-reclame) and [RVO — Rules for business correspondence](https://ondernemersplein.overheid.nl/regels-voor-bedrijfscorrespondentie/)

This is general information, not legal advice. If you’re unsure, get advice for your specific situation.

---

*Questions? Feedback? Hit us up — we're all ears.*


Can You Use a PO Box for CAN‑SPAM? Yes.

CAN-SPAM and PO Boxes for Newsletters: Do I Need It?

CAN-SPAM and PO Boxes: Clearing Up the Confusion

BIMI is the “real” way to get a brand-controlled logo next to your emails in supporting inboxes — but for most teams, the **expensive** part is the **Verified Mark Certificate (VMC)/Common Mark Certificate (CMC)** process (trademark + certificate + ongoing work).

If you’re not ready to pay for that, you still have a few **legit, provider-specific** levers you can pull to get *some* kind of inbox avatar / sender image showing up for *some* recipients.

This is a practical playbook for maximizing coverage (with clear limits and links to the underlying docs).

## TL;DR (do these first)
- **Gravatar**: Set it up if you want extra coverage in apps that integrate it — but **don’t expect it to show in Gmail/Outlook/Apple Mail**.
- **Yahoo/AOL**: Implement **DMARC enforcement** and publish a **self-asserted BIMI record** (no VMC). Yahoo explicitly says they’ll display logos without a VMC if you meet their other requirements.
- **Apple Mail**: Use **Apple Business Connect Branded Mail** (Apple-only) if you can meet Apple’s DMARC + DKIM requirements.
- **Gmail (person-to-person)**: Set a **Google Account / Workspace profile photo** for the actual account sending the mail.
- **Everyone**: Add “**save us as a contact**” to your welcome email. Contact photos are the most widely supported “inbox avatar,” but they’re recipient-controlled.

## Coverage cheat sheet (what’s realistic)

| Inbox | Cheapest way to get a logo/avatar showing | What to expect |
|---|---|---|
| **Yahoo / AOL** | **Self-asserted BIMI** (no VMC) | Works only for bulk mail with enough reputation/engagement. |
| **Apple Mail / iCloud Mail** | **Apple Business Connect Branded Mail** | Apple-only; strict DMARC + DKIM requirements; not shown in every language/device combo. |
| **Gmail** | **Google profile photo** (if you send from a Google Account) | Great for human senders; doesn’t solve “brand logo for ESP marketing mail.” |
| **Outlook / Microsoft** | **Contacts** (recipient-controlled) | Expect initials unless recipients save you; logo behavior varies by Outlook client. |

## Step 0: Know what “logo next to an email” means

There are three different things people call “the logo”:

- **Inbox avatar**: the circle image next to a message in the list.
- **BIMI verification UI (Gmail checkmark)**: Gmail only, and it’s tied to BIMI with VMC/CMC.
- **Logo inside the email body**: your HTML header logo (not an inbox avatar).

This post is about **the inbox avatar** (and the few systems that influence it).

## 1) Self-asserted BIMI (works in Yahoo/AOL; won’t work in Gmail)

Some mailbox providers will display **self-asserted BIMI**. Yahoo is explicit: **they do not require VMCs** for BIMI logos to appear (though they may use one “to inform eligibility” if present).

### What you get

- **Where it can show**: Yahoo Mail and AOL Mail experiences that support BIMI.
- **Where it won’t**: Gmail (requires VMC/CMC), and Apple Mail’s BIMI implementation can require additional evidence/document verification.

### Setup steps (safe + accurate)

1. **Get DMARC to enforcement** for the domain you use in the visible `From:` address.
   - Your DMARC policy needs to be `p=quarantine` or `p=reject`.
   - Many programs also require `pct=100` (apply the policy to all mail).
   - If you’re currently at `p=none`, don’t jump straight to reject—review DMARC reports first so you don’t break legitimate sends.
2. **Make sure DMARC passes** (SPF and/or DKIM aligned to the `From:` domain). If you’re using an ESP, DKIM alignment is usually the lever you control.
3. **Create a BIMI-compliant SVG** (SVG Tiny P/S).
   - Don’t include scripts, external references, or animations/interactive elements.
   - Use SVG Tiny Portable/Secure (baseProfile `tiny-ps`, version `1.2`).
   - Avoid `x=` and `y=` attributes on the root `<svg>` element.
4. **Host the SVG on a public HTTPS URL**.
   - No auth, no “works only in a browser” redirects, no geoblocking.
5. **Publish the BIMI TXT record** at `default._bimi.yourdomain`.
   - Example (self-asserted, no VMC):

```txt
default._bimi.example.com  TXT  "v=BIMI1; l=https://example.com/.well-known/bimi/logo.svg"
```

6. **Be patient and realistic about eligibility**:
   - Yahoo says they show BIMI logos for **bulk mail**, and only when they see **sufficient reputation and engagement**. Personal one-off mail won’t qualify.

### Quick troubleshooting checklist

- Does `default._bimi.yourdomain` resolve publicly?
- Is the SVG reachable over HTTPS (200 OK) and not blocked by auth, geo rules, or robots?
- Is DMARC actually enforcing (`quarantine`/`reject`) for the *organizational domain*?
- Are you a bulk sender with decent reputation? (Yahoo explicitly gates display on it.)

## 2) Apple Business Connect Branded Mail (Apple-only, no VMC required)

If Apple Mail matters to you, **Apple Business Connect Branded Mail** is the most practical alternative to “full BIMI everywhere.”

It’s not BIMI; it’s Apple’s own verification + branding system. It can show your brand in:

- the **Mail app on iPhone** (with certain device languages), and
- **iCloud Mail on the web**

### Requirements (Apple is strict here)

Apple’s docs call out the big ones:

- You must use a **commercial domain** (no `gmail.com`, `icloud.com`, `outlook.com`, `yahoo.com`, etc.).
- Your domain must have mail records (MX, A, or AAAA).
- Your mail must meet **DMARC** requirements (`v=DMARC1`, `p=quarantine` or `p=reject` — or `sp=quarantine`/`sp=reject` when registering subdomains — and `pct=100`).
- Apple requires **DKIM** authentication for customer-facing mail; SPF-only isn’t supported.

### Setup steps

1. **Create an Apple Business Connect account** and register your company at `businessconnect.apple.com`.
2. **Verify your company** in Apple Business Connect (Apple has multiple verification methods).
3. **Add a Brand** and upload your logo for approval (Apple may take several business days to review).
4. In Apple Business Connect, go to **Branded Mail** and **add your domain/subdomain or a specific email address**.
5. Apple will provide a **TXT record**. Add it to your DNS, then click **Verify**.
   - Apple notes you have a limited window (14 calendar days) to complete verification.
6. **Publish/confirm DMARC enforcement** that matches Apple’s requirements. Apple’s own example looks like:

```txt
_dmarc.example.com  TXT  "v=DMARC1; p=reject; pct=100;"
```

### Gotchas to know up front

- Branded Mail visibility is **not universal**: Apple notes the logo is visible only:
  - in iPhone Mail when the device language is one of: English, Portuguese, French, Italian, German, Spanish, Simplified Chinese
  - and in iCloud Mail on the web
- Apple needs to **approve email names** before they’re allowed.

## 3) Google profile photos (best for humans; limited for bulk brand mail)

If your email is being sent from a **Google Account** (Gmail or Google Workspace), you can often influence the avatar by setting a **profile picture**.

This is the most “free” way to get a recognizable image in **Gmail inboxes**, but it mainly helps when:

- the sender is a person, or
- you’re sending from a real mailbox like `founder@`, `support@` (as a user account), etc.

### Option A: Set your Google Account / Gmail profile picture

1. Go to `myaccount.google.com`
2. **Personal info** → **Profile picture** → upload and save
3. If you want to control who can see it: **People & sharing** → **About me** → set visibility (for example, “Anyone” or “People you interact with”)

Google notes the Gmail profile picture is the same as your Google Account picture and can take up to 24 hours to update.

### Option B: (Workspace) Set a user photo in the Admin console

If you manage a Workspace domain:

1. Go to `admin.google.com`
2. **Directory** → **Users**
3. Select the user → click the avatar → upload JPEG/PNG

Google notes:

- Profile photos are JPEG/PNG (max 5MB; max 20 million pixels).
- If your org turns off Directory, users won’t see profile photos.
- Admin-added photos have tighter visibility than user-managed photos, so don’t assume this becomes a universal “brand logo” for every external recipient.

### Important limitations (don’t get surprised)

- If you send marketing mail through an ESP (not through Gmail/Workspace), this usually won’t affect what recipients see. That’s where BIMI comes in.
- Profile photos are account-level. Don’t expect separate avatars per “From” alias.

## 4) The universal fallback: get into Contacts

The most widely supported inbox avatar system is also the least controllable: **recipient contacts**.

You can’t force this, but you *can* increase the odds:

- **Welcome email**: add a plain line like “Save this address to your contacts so you always recognize our emails.”
- **Consistent From name + address**: people only save contacts when they’re confident it’s stable.
- **Customer support**: it’s easier to get saved when the relationship is 1:1 (support, onboarding, sales) than in pure promo blasts.

If Outlook/Microsoft inboxes are a big part of your audience, this matters more: Microsoft doesn’t support BIMI, so **contacts are the main way** a real image shows up instead of initials.

## 5) Gravatar (extra coverage outside major inboxes)

Gravatar is real and useful — just not for most inbox avatars.

Gravatar’s own support docs say most popular email services **don’t** show Gravatar avatars (including Gmail, Outlook, and Apple Mail). That means this won’t move your “logo in the inbox” KPI for typical consumer inboxes.

Still, it can help in tools and platforms that integrate Gravatar (and it’s quick to set up):

1. Create an account at `gravatar.com`
2. Add/verify the sender email address(es)
3. Upload an avatar and assign it to that email

## The hard truth (so you don’t waste time)

- **If your goal is “logo in Gmail for marketing mail,”** Google’s Workspace Admin docs are clear: BIMI in Gmail requires **a VMC or CMC**.
- There’s no reliable “cheap BIMI alternative” that produces the same result in Gmail today.

So the practical strategy is:

- do **self-asserted BIMI** for Yahoo/AOL coverage,
- do **Apple Branded Mail** for Apple coverage,
- do **profile photos** for human senders in Gmail,
- and use **Contacts** as the universal fallback.

## Sources

- Yahoo BIMI requirements (and VMC not required): [Yahoo Sender Hub: BIMI](https://senders.yahooinc.com/bimi)
- Gmail BIMI requirements (VMC/CMC required + DMARC enforcement + pct=100): [Google Workspace Admin Help: Set up BIMI](https://support.google.com/a/answer/10911320)
- Apple Mail BIMI support details (evidence documents verified by provider): [Apple Developer: Prepare your email server for BIMI support in Apple Mail](https://developer.apple.com/support/bimi/)
- Apple Branded Mail overview + requirements: [Apple Business Connect: Prepare to use Branded Mail](https://support.apple.com/guide/apple-business-connect/prepare-to-use-branded-mail-abcb761b19d2/web)
- Apple Branded Mail setup steps: [Apple Business Connect: Set up Branded Mail](https://support.apple.com/guide/apple-business-connect/set-up-branded-mail-abcb28ad2a2d/web)
- Apple Branded Mail DMARC requirements: [Apple Business Connect: Verify your email domain for Branded Mail](https://support.apple.com/guide/apple-business-connect/verify-your-email-domain-for-branded-mail-abcb22cbade5/web)
- Gmail profile picture behavior: [Gmail Help: Change your Gmail profile picture](https://support.google.com/mail/answer/35529?hl=en)
- Google Account profile photo + steps: [Google Account Help: Change your Google Account picture](https://support.google.com/accounts/answer/27442?hl=en)
- Workspace admin user photos: [Google Workspace Admin Help: Add or change a user's profile photo](https://support.google.com/a/answer/6371005)
- Google profile visibility (“About me”): [Google Account Help: Control what others see](https://support.google.com/accounts/answer/6304920?hl=en)
- Gravatar + email clients: [Gravatar Support: Avatars for gmail and email clients](https://support.gravatar.com/avatars/email-avatars-are-not-showing/)
- Mailbox-provider BIMI support overview (includes Microsoft “does not support BIMI”): [BIMI Group: BIMI Support by Mailbox Provider](https://bimigroup.org/bimi-infographic/)

---

*Questions? Feedback? Hit us up — we're all ears.*


Ways to get your logo to show up in the inbox reliably!

BIMI Alternatives: How to Get Your Logo to Show Next to Your Emails

Did you know you can send email broadcasts several times a day without annoying your subscribers or ruining your deliverability? Most businesses send infrequent broadcast emails–a monthly or biweekly newsletter, for example–if they send them at all. This is a mistake.

The truth is, the more emails you send, the more money you make. Done correctly, email broadcasts are the most profitable marketing channel in your business.

And Bento gives you the tools to make it happen.

## TL;DR: Keep Your Reputation While Sending at Scale

- Segment your subscribers using RFM (Recency, Frequency, Monetary). How recently they made a purchase, how often they buy, and how much they spend when they do.  
- Send in batches. Spread large sends over hours, not minutes.
- Watch metrics in real time. Catch problems before ISPs block you.
- Don't unsubscribe unengaged contacts but send re-activation broadcasts instead.

## Before You Send: The Setup Work That Matters

### Clean Your List Like Your Reputation Depends on It

Because it does. Every list has dead weight. People who signed up three years ago and never opened a single email. Old work addresses that bounce. Role accounts like info@ that nobody checks. These addresses hurt you more than you think.

Hard bounces tell ISPs you don't maintain your list. Sending to inactive subscribers tanks your engagement rates. Both signal that you're a spammer, even if you're not. The fix is simple. Remove anyone who hasn't opened in 6 months. Delete every hard bounce immediately. Skip the role accounts entirely. Yes, your list gets smaller. But a list of 50,000 engaged subscribers beats 200,000 dead ones every time.

Double opt-in helps here too. When someone confirms their subscription, you know the address works and they actually want your emails. It cuts your list growth by about 20%, but those confirmed subscribers open at twice the rate of single opt-ins.

You can clean your list using services like Klean13 and EmailListVerify. Bento also offers list cleaning on import...

![bento email verification on import](//images.ctfassets.net/7154jijfbyeo/3rqsVEHFHKsHEDwpdB8Www/93d9d11b88aca7f173371e7b55ac931f/bento_email_verification_on_import.png)

...As well as more aggressive verification via our spam-checker API.

![bento spam check flow](//images.ctfassets.net/7154jijfbyeo/2jpfylS6zHkojiMPjyJChq/bde55a90c1273894dc3bfac5cbeeea8b/bento_spam_check_flow.png)

### Segment Based on What People Actually Do

Generic blasts get generic results. You need segments that reflect real behavior. Someone who bought last week needs different messaging than someone who browsed and left. A daily reader wants different content than someone who opens once a month.

Start with engagement levels. Your most active subscribers, the ones who open everything, they're your VIPs. Send to them first during warmups. They boost your metrics. Next come the occasional openers. They need different subject lines, maybe different send times. Then you have the dormant group. These need re-engagement campaigns before regular broadcasts.

Geography matters too. A noon send in New York hits London at 5 PM. Their workday is ending. Engagement drops. Break your list by time zone and schedule accordingly. Product interest creates natural segments. If someone only buys shoes, stop sending them handbag promotions. Purchase history, browse behavior, email preferences, they all create segments that actually mean something.

Bento allows you to create precise segments based on subscriber behavior. For example, when creating engagement-based segments, you can use our “engagement score” filter...

![bento engagement score filter](//images.ctfassets.net/7154jijfbyeo/4tCsf8mk0yBcMwkFKHkOuv/c7a224ad9d6769f0ebc38420eaf81caf/bento_engagement_score_filter.png)

...Or you can use our “last activity” filter.

![bento last activity filter](//images.ctfassets.net/7154jijfbyeo/11jrHLApiNqd8rVallqtps/c1a171fb325b790e8a35aae8018aa988/bento_last_activity_filter.png)

### Warm Up Your Sending Infrastructure

Volume spikes scare ISPs. You normally send 10,000 emails a week. Suddenly you blast 500,000 for Black Friday. Gmail sees that spike and assumes you're compromised or bought a list. Into the spam folder you go.

The solution is gradual warming. Two weeks before your big send, start ramping up. Send 20% more each day. Start with your best segments, the people who always open. Their positive engagement tells ISPs this volume increase is legitimate. By the time you hit your target volume, the ISPs expect it.

New domains need even more care. Start at 50 emails per day. Increase by 30% every three days. It takes about a month to reach normal volumes safely. Skip this and you'll fight deliverability problems for months.

Bento allows you to do this natively with it's batch-sending feature for email broadcasts. you can control how many emails you send down to the minute. Simply set your desired batch size and duration. Or you can use our recommended presets.

![bento batch sending](//images.ctfassets.net/7154jijfbyeo/2DBy8rc3wjTzflzO7YFBw/e9716bcc68b2fcc8a6f575b8e5e61da3/bento_batch_sending.png)

## Sending Day: Execute Without Drama

### Control Your Send Speed

Dumping a million emails in 60 seconds looks suspicious. Even if every address opted in legitimately. ISPs have rate limits. Exceed them and you get throttled or blocked. Sometimes permanently.

Smart platforms handle this automatically. They spread your send over hours, not minutes. They monitor feedback loops and slow down if complaints rise. They respect ISP limits without you having to think about it. Bento does this by default. Set your campaign, pick your audience, and the system handles pacing.

Manual throttling works too if you're technical. Limit yourself to 100,000 emails per hour per IP. Watch your complaint rate. If it goes above 0.1%, slow down. Above 0.3%, stop and investigate. These numbers come from years of testing across millions of sends.

Bento's batch-sending feature allows you to change the batch size after you've started sending an email broadcast. You can even pause sending and make changes to your email content. This comes in handy when you've forgotten to add a link or included the wrong link (every email marketer's nightmare.)

### Get Authentication Right Every Time

SPF, DKIM, and DMARC aren't optional anymore. Gmail and Yahoo require them for bulk senders. Even smaller providers check authentication now. One misconfigured record can tank your entire campaign.

SPF tells receivers which servers can send for your domain. DKIM adds a digital signature proving the email hasn't been tampered with. DMARC ties them together and tells receivers what to do with failed messages. Get all three right and you pass the first deliverability test. Get them wrong and nothing else matters.

Your From name and address need to stay consistent too. Switching between "Company News" and "Company Updates" confuses both spam filters and subscribers. Pick one and stick with it. Same with reply addresses. Use a real mailbox that someone monitors, not noreply@. People who reply are engaged. That's a positive signal you want to encourage.

Bento has several guardrails to make sure your sending addresses meet all authentication requirements. We can even predict which inbox your email will end up in.

![bento email sender authentication](//images.ctfassets.net/7154jijfbyeo/1ku7lq4Ir2yQUFZi9kVipK/54165680dcf21d2a84f046c5e5e938df/bento_email_sender_authentication.png)

### Make Opting Out Obvious

Hidden unsubscribe links increase spam complaints. It's that simple. When someone wants out, they'll find a way. Either they click your unsubscribe link or they hit the spam button. You want them choosing the link.

Put it at the top and bottom of every email. Use clear text like "Unsubscribe" or "Manage Preferences." Don't hide it in tiny gray text. Don't require a login to unsubscribe. Process opt-outs immediately, not "within 10 business days." The CAN-SPAM Act requires it, and delayed processing leads to spam complaints.

Preference centers reduce unsubscribes. Instead of leaving entirely, subscribers can reduce frequency or change topics. Someone might not want daily emails but still wants your monthly newsletter. Give them options.

## After the Send: Monitor and Adjust

### Watch Your Metrics in Real Time

Opens, clicks, bounces, complaints, you need to see them as they happen. Not tomorrow, not in an hour, right now. A normal campaign might run 20% opens in the first hour. If you're seeing 5%, something's wrong. Maybe you're in spam folders. Maybe your subject line failed. Either way, you can fix it if you catch it early.

Complaints are the most important metric. Anything above 0.1% is concerning. Above 0.3% is an emergency. Stop the send, figure out what went wrong. Maybe you included an old segment. Maybe your content missed the mark. Fix it before ISPs blacklist you.

Domain-specific metrics matter too. If Gmail engagement drops but Outlook stays strong, you have a Gmail-specific problem. Maybe you triggered their filters. Maybe you need to check your Google Postmaster Tools. These patterns only show up if you segment your reporting by domain.

### Use ISP Feedback Tools

Google Postmaster Tools and Microsoft SNDS give you data your ESP can't. They show your domain reputation, spam rates, and authentication results from the ISP's perspective. Check them during and after every major send.

Postmaster Tools might show you're hitting spam traps you didn't know about. Or that your domain reputation dropped even though engagement looks fine. SNDS might reveal that Outlook is junking your mail despite good authentication. These tools are free. Not using them is like driving blindfolded.

### Learn From Every Send

Every broadcast teaches you something. That subject line that flopped? Don't use that style again. The segment with 40% opens? They're your new VIP group. The time slot with the highest clicks? That's your new default send time.

Keep a send log. Track what worked, what didn't, and what you'd change. Include subject lines, send times, segments, and results. Over time, patterns emerge. Tuesday at 10 AM might consistently beat Thursday at 2 PM. Questions in subject lines might outperform statements. Your European segment might prefer different content than North America.

## Common Broadcast Email Mistakes

### Buying or Renting Lists

Purchased lists are spam complaints waiting to happen. Those addresses didn't opt into your messages. They don't know who you are. When your email arrives, they hit spam. Your complaint rate spikes, ISPs notice, and your domain reputation crashes. Recovery takes months if it happens at all.

Build your list organically. It's slower but sustainable. Every address opted in specifically for your content. They expect your emails. They engage with them. That's how you maintain deliverability long-term.

### Ignoring Inactive Subscribers

Inactive subscribers are dead weight. They don't open, they don't click, they don't buy. But ISPs see you sending to them month after month. It looks like you're spamming. Your engagement rates drop. Your reputation suffers. Eventually, even your engaged subscribers stop seeing your emails because you're in spam folders.

Set an inactivity limit. Six months is standard. No opens in six months means they're out. Run a re-engagement campaign first if you want. "We miss you" with a special offer. If they don't respond, remove them. Your metrics improve immediately.

### Sending Without Testing

Every broadcast should start with a test. Send to a seed list of your own addresses across different providers. Check that images load, links work, and formatting holds up. Run your content through spam checkers. Look for trigger words, broken HTML, missing authentication.

A/B test when possible. Try two subject lines with small segments before the main send. Test send times, From names, preview text. Even a 2% improvement in open rate means thousands more people seeing your message in a large broadcast.

## What Makes Bento Different for Broadcast Email

Bento handles the technical complexity so you can focus on content and strategy. Authentication setup happens automatically. Domain warming follows best practices without manual schedules. Send pacing respects ISP limits while maximizing delivery speed.

The reputation dashboard shows real-time metrics across all major ISPs. You see problems before they become emergencies. Complaint spikes, authentication failures, reputation drops, they all trigger alerts. List cleaning happens automatically too. Hard bounces get removed instantly. Engagement tracking identifies inactive subscribers. Suppression lists prevent sending to opt-outs and complaints.

Built-in batching spreads large sends optimally. Instead of managing throttling rules, you set your audience and hit send. The system handles the rest. It monitors feedback loops, adjusts speed based on performance, and pauses automatically if metrics go bad.

## Your Broadcast Email Checklist

Before any major send, run through this list:

1. **List hygiene.** Remove bounces, inactives, and anyone who didn't explicitly opt in. Your list should be clean enough to eat off.
2. **Segmentation.** Group by engagement, behavior, geography, or product interest. Generic blasts get generic results.
3. **Authentication.** Verify SPF, DKIM, and DMARC are configured correctly. One broken record ruins everything.
4. **Content review.** Test emails across devices. Check every link. Run spam scores. Look professional, not promotional.
5. **Send strategy.** Plan your batching, timing, and fallback options. Know what you'll do if metrics go south.
6. **Monitoring plan.** Keep dashboards open. Watch metrics in real time. Be ready to pause if needed.
7. **Post-send review.** Check ISP tools, analyze results, document lessons learned. Every send should make the next one better.

Compare your approach with our guides on [transactional vs bulk email delivery](/posts/transactional-vs-bulk-email-delivery) and strengthen your monitoring with [email deliverability tools](/posts/email-deliverability-tools).

Broadcast email success comes from respecting the inbox. Clean lists, relevant content, and careful execution beat volume every time. Get these fundamentals right and large sends become routine, not risky.

Learn broadcast email best practices for sending to large lists. Understand how to send bulk emails responsibly, maintain deliverability, and avoid triggering spam filters.

Broadcast Email Best Practices: How to Email Every Day Without Annoying Your Subscribers


Hey there,

Brennan Dunn recently recorded a video walking through the RightMessage + Bento integration, and I wanted to share it with you. If you've ever wondered how to take all that contact data you're collecting in Bento and actually use it on your website—this is it.

What follows is my take on what Brennan covers, but honestly? Just watch the video. Brennan explains it better than I can write it.

## The Problem This Solves

Here's something that's always frustrated me about email marketing.

You spend all this time segmenting your list. You build automations. You personalize your emails based on who someone is, what they've bought, what they've clicked on. Then they click through to your website and... they see the exact same page as everyone else.

A first-time visitor sees the same homepage as a paying customer. A churned user sees the same pricing page they cancelled from six months ago. All that data you collected? Wasted.

RightMessage fixes this.

## What RightMessage Actually Does

In simple terms: RightMessage reads your Bento data and uses it to change what people see on your website.

When someone visits your site, RightMessage checks if they're in Bento. If they are, it pulls their tags and fields. Then it modifies the page based on that data—different headlines, different CTAs, different testimonials. Whatever makes sense for that person.

The visitor doesn't notice anything happening. They just see a page that feels weirdly relevant.

## The Integration Is Native

This isn't some Zapier hack. RightMessage has a direct integration with Bento that works both ways:

**Reading from Bento:** Every page load, RightMessage checks if the visitor exists in your Bento account. If yes, it pulls their current tags and fields. This is live—if you tag someone in Bento, they'll see updated content on their next page view.

**Writing to Bento:** When someone fills out a survey or form in RightMessage, that data gets pushed back to their Bento record. Tags get added, fields get updated. Same data everywhere.

**Identity stitching:** If someone's anonymous, then opts in through a RightMessage form, it connects their browsing history to their new contact record. When they click an email link later, RightMessage recognizes them. No more "who is this person?" amnesia.

Setup takes about five minutes. Paste your API credentials, pick which fields to sync, done.

## Practical Examples

In the video, Brennan walks through some flows that I think are really useful:

**The basic three-way split.** Anonymous visitors see opt-in offers. Leads (in Bento but not customers) see demo requests or trial CTAs. Customers see upgrade offers or account-related messaging. Simple, but most sites don't even do this.

**Win-back for churned users.** If someone has a `churned` tag in Bento, swap the headline: "A lot has changed since you left." Link to a reactivation offer. These people already know your product—you don't need to re-explain it.

**Industry-specific proof.** If someone told you they're in ecommerce (via a survey, UTM, or form), show ecommerce testimonials. "Here's how Company X increased conversions" hits different when Company X is in your industry.

**SaaS trial personalization.** Trial users see onboarding content and support prompts. Converted users see feature announcements. Churned users see win-back offers. Same page, different experience based on lifecycle stage.

## The Survey Feature

This is the part that impressed me most.

After someone opts in, you can push them through a quick branching survey. "Do you work solo or with a team?" If team: "How big?" Then: "What's your biggest challenge?"

Each answer gets pushed to Bento in real time. Even if they bail halfway through, you keep whatever they gave you.

Here's the clever bit: that data immediately feeds back into your website personalization. Someone who said they're a freelancer sees freelancer messaging on their next visit. But it also flows into your Bento automations—different welcome sequences, segmented broadcasts, personalized email copy. Same data, used everywhere.

## One Piece of Advice

Brennan mentioned this in the video and I want to echo it: don't go too deep too fast.

I've seen people build elaborate 47-condition flows and then never launch because they couldn't test all the paths. Start with three segments—anonymous, lead, customer—and nail those before adding more branches.

Ship the simple version first. You can always get fancier later.

## Worth Checking Out

If you're already using Bento and you want your website to be as personalized as your emails, RightMessage is worth a look. The integration is solid, the setup is minimal, and the concept just makes sense.

Check out [RightMessage](https://rightmessage.com) if you want to learn more. And if you're not on Bento yet, [start a free trial](https://bentonow.com) and get some data flowing first. The personalization stuff works better when you actually have data to personalize with.

Questions? Hit me up at jesse@bentonow.com.


Learn how to show different CTAs, headlines, and content to visitors based on their Bento data. Brennan Dunn walks through RightMessage's visual flow builder.

How to Personalize Your Website with RightMessage + Bento

Understand the difference between transactional and marketing emails. Learn why separating them matters for deliverability and how to use each type effectively.

Transactional vs Marketing Email: Key Differences Explained

We're thrilled to announce **AI Mode** — a powerful new way to create, edit, and refine your emails and automations with the help of Tanuki AI, your intelligent assistant built right into Bento.

## What is AI Mode?

AI Mode is a conversational interface that lets you describe what you want, and watch it come to life in real-time. Whether you're building a complex automation workflow from scratch or fine-tuning the copy in an email, Tanuki AI understands your intent and executes changes instantly.

No more context-switching between documentation and your editor. No more hunting for the right setting. Just tell Tanuki what you need.

## AI Mode for Workflows

The workflow builder now features **Tanuki AI** — a conversational interface for building entire automation flows.

**Just describe what you want to automate:**
- *"Create onboarding, dunning, and win-back flows based on my existing Stripe events"*
- *"Send a thank you email and tag people that buy X but not Y"
- *"Build a welcome series for new sign ups"*
- *"Set up abandoned cart recovery emails"*
- *"Increase all delays to 10 days"

Tanuki asks clarifying questions, then builds the complete workflow — triggers, delays, conditions, and all. And it's not just creating new automations, it can also patch and make fast edits often quicker than doing it yourself.

## AI Mode for Email Editors

### Visual Editor (Stripo)
We shipped a way to talk to your Stripo templates and make design and content edits easily. Click the **AI Mode** toggle in your email editor header to enter a split-screen experience: your live email preview on the left, Tanuki AI chat on the right. 

**What you can do:**
- Click any element in the preview to select it, then ask Tanuki to modify it
- Double-click text to edit it directly in the preview
- Ask Tanuki to change colors, swap images, rewrite copy, or restructure sections
- Watch changes appear instantly in the live preview
- Save when you're happy, or discard and return to the visual editor

### Plain Text Editor (Shoji)
The AI sidebar slides in alongside your writing canvas. Ask Tanuki to help you:
- Craft compelling subject lines
- Punch up your copy
- Add personalization with Liquid tags
- Restructure your message for better flow
- Brainstorm hooks and sales pitches
- Design custom components 

### Raw HTML Editor
For developers who prefer working in code, AI Mode gives you a three-panel workspace:
- Monaco code editor with syntax highlighting
- Live preview with click-to-select elements
- Tanuki AI chat for intelligent code generation

Select an element in the preview, and Tanuki knows exactly which HTML you're referring to.

### Smart Features

**Ask vs YOLO Mode:** Choose whether Tanuki asks for confirmation before applying changes, or goes full YOLO and builds immediately.

**Undo Support:** Made a mistake? Every AI action can be instantly rolled back with one click.

**Multi-Flow Awareness:** Tanuki understands when your workflow has multiple paths and shows you exactly what's being created.

**Next Steps Checklist:** After building your workflow, Tanuki provides actionable next steps — like configuring specific nodes or setting up sequences — with checkboxes to track your progress.

## How to Access AI Mode

AI Mode is available now for all Bento users:

1. **Email Editors:** Look for the "AI Mode" toggle with the Tanuki icon in the editor header
2. **Workflow Builder:** Click "Plan with Tanuki AI" at the bottom of the canvas, or use the example prompts to get started

## What's Next

This is just the beginning. We're actively improving Tanuki's capabilities based on your feedback. Have ideas for what AI Mode should do next? We'd love to hear from you.

---

*AI Mode is powered by Tanuki AI, Bento's intelligent assistant. Your data stays secure and is never used to train external models.*

We're thrilled to announce **AI Mode** — a powerful new way to create, edit, and refine your emails and automations with the help of Tanuki AI, your intelligent assistant built right into Bento.

Introducing AI Mode: Your New Creative Agent in Bento

Compare the best email marketing services and choose the right ESP. Find platforms that deliver real results, not just impressive feature lists.

Best Email Marketing Services: Choose the Right ESP for Your Business

Best Email Marketing Services: Choosing the Right ESP for Your Business


Imagine this: a customer resets their password and the confirmation email hits their inbox before they can tab back to the app. Meanwhile, your newsletter from hours ago is still crawling through delivery. 

This is normal and actually what you want. 

Inbox providers (who you send to) and email platforms (who you send from) run two completely different playbooks for transactional versus bulk email, and the only way to keep both streams healthy is to learn the rules that govern both of them. 

Here’s the short version: transactional email is lightening fast when you follow best practices and marketing email is often a little slower either due to throttling by ISPs and/or throttling by the ESP you are sending through. Keep both streams separate to ensure your most critical emails don't suffer and flood your support inbox. 

## Intent, Not Volume, Defines the Stream

Transactional email exists because a person or system just did something that demands a response right away—login codes, shipping notices, outage alerts. These messages are expected, time-sensitive, and usually critical to the experience. 

Bulk email follows your calendar instead of the user’s actions. You decide it’s time for a promo, product update, or nurture sequence, and you hit send. Even if that campaign targets a single person, it’s still bulk because the recipient wasn’t waiting on it.

## Why Password Resets Own the Fast Lane

(We believe that) inbox providers have built an express lane for transactional traffic. When SPF, DKIM, and DMARC align, transactional mail slips right through. It seems to us that ISPs keep **filters intentionally light** because false positives here create support tickets and angry customers. If a transactional template ever lags, check authentication failures or infrastructure hiccups first.

We also recommend making sure that your content is minimal (like, literally no content) and your emails are light on the HTML code. Too much code and markup can make an innocent password reset come across as a promotional email to the ISPs and be handled differently. 

## Your Newsletters Don't Need To Be Send Fast

Bulk email has to earn the right to land in the inbox. Once you cross the bulk sender threshold providers treat it as suspicious until reputation proves otherwise. **Domain and IP health** are the first handshake; shaky scores trigger throttling or junking before the content is even scanned. When the scan happens, **URLs, copy, images (YES! even images) and the code get dissected** for spam indicators and patterns. Then engagement history weighs in. Low opens or a spike in complaints tell the ISP that subscribers don’t want the message, so they tighten the tap.

Delivery timing is where the slowdowns show up. Some ISPs park marketing campaigns in a queue, releasing them gradually to watch engagement in real time. We see this a lot during holiday seasons like Black Friday and Cyber Monday weekend. 

ESPs, the platforms you're sending from, layer on their own controls: if your send risks crowding the pipes for higher-priority mail, they’ll **throttle or stagger delivery** behind the scenes to keep transactional or automation streams flowing. 

High-volume campaigns can also hit ISP rate limits that trigger intelligent back-off. The result? A newsletter can be delayed because the ISP is still evaluating it, because the ESP is pacing it, or both.

(Fun little aside: a platform like Bento always prioritizes transactional sends over our marketing emails. In fact, the priority is: transactional > automations > broadcasts in that order).

## Keep the Lanes Separate on Purpose

Letting transactional and bulk traffic share the same IPs or domains is like putting ambulances and parade floats on the same street. 

One bad marketing campaign can drag your reputation down and strand critical notifications in spam. Split the streams and you protect your most important messages while giving yourself room to tune each channel independently.

Separation also keeps compliance clean. Regulations like CAN-SPAM and GDPR treat operational and promotional mail differently. Distinct infrastructure simplifies opt-in flows, unsubscribes, and reporting so you can pinpoint which stream needs attention when deliverability dips.

An easy way to keep things separate is to use different platforms for each, or use a platform where the separation is native like in Bento. 

## Transactional Email Tune-Up

Transactional deliverability is all about reliability. Run this checklist on repeat:

**Authenticate every send.** Publish precise SPF records, rotate DKIM keys, and set a DMARC policy that enforces alignment.  
**Dedicate the infrastructure.** Use a transactional ESP or isolate IPs and subdomains so reputation splashback never touches these messages.  
**Monitor relentlessly.** Alert on delivery latency, bounce patterns, and authentication failures for each template.  
**Keep the content lean.** Strip these emails to the most simplest design you can think of. 
**Do not use marketing heads.** Skip the bulk: precedence header and other similar ones in your transactional emails. 

## Bulk Email Reputation Playbook

Marketing campaigns live or die on trust signals. Keep them healthy with a rhythm like this:

**Warm up deliberately.** Ramp new domains and IPs using your most engaged segment before you push real volume.  
**Obsess over engagement.** Segment by behavior, prune inactive subscribers, and send content worth opening.  
**Clean the list constantly.** Remove hard bounces immediately, suppress dormant contacts, and skip purchased lists.  
**Stay ahead of complaints.** Prominent unsubscribe links and instant opt-outs keep complaint rates under 0.1%.  
**Test in cycles.** Experiment with timing, subject lines, and creative, then watch engagement and throttling logs to see what resonates

## Where Bento Fits in

Bento separates transactional and bulk streams out of the box. Password resets and order receipts live on protected infrastructure, so they keep moving even if a marketing campaign stumbles. The platform handles authentication tooling, pacing controls, and reputation monitoring automatically, which means you’ll see whether an ISP is queuing your marketing traffic or the ESP is throttling it—and you’ll still meet those real-time expectations for operational mail.

## Bottom Line

Treat transactional and bulk email like siblings, not twins. Give transactional messages their own authenticated lane so they always arrive on time. Build bulk campaigns around reputation, engagement, and intelligent pacing, and remember the delay might come from the ISP or from your ESP’s safeguards. Keep the streams separated, watch the data, and your deliverability stays predictable—even on the busiest send days.


Learn the differences between transactional and bulk email delivery. Understand how ISPs treat different email types and how to optimize delivery for each.

Transactional vs Bulk Email: Delivery Differences Explained

I get this question a lot: "Jesse, why doesn't Bento have a free plan?"

Sometimes it comes from people comparing us to other platforms. Sometimes from folks just starting out who are watching every dollar. And honestly? I get it. When you're building a business, $30 can feel like real money.

But our starting price of $30 is our secret weapon.

## A Story About Bad Neighbors

Let me tell you what happened when I first started sending email for my businesses.

I was using one of those platforms with a generous free tier. Great, right? Save money while you're starting out. Except my welcome emails started landing in spam. My carefully crafted onboarding sequences? Right into the naughty folder with a warning on the top :(

I spent hours tweaking subject lines, rewriting copy, removing "trigger words." Nothing worked.

Then I dug into the technical side. Turns out, I was sharing IP addresses with thousands of other "free" users on this platform. And some of them were... not great at email marketing. Bought lists, spam content, ignoring unsubscribes. The works.

Apparently, the IP I was sending on landed on a popular blocklist and all my emails went straight to spam across the major providers (most bouncing actually). 

I raised a ticket with my email provider and they just ignored it so I was forced to switch platform just so my customers could hear from me again. 

When your neighbors are trashing the neighborhood, everyone's mail gets treated like junk.

That's when I learned: in email, you really do get what you pay for.

## Why We Chose $30

When I started Bento, I had a choice.

I could do what everyone else does. Raise venture capital. Offer a free tier. Try to get 100,000 users. Hope 2% convert. Play the volume game.

Or I could do something different.

I chose different.

Here's why:

**Free users aren't free.**

They cost money. Support tickets. Infrastructure. Development time. But they don't pay anything. So you need thousands of them to make the math work.

**Volume creates problems.**

When you need 100,000 users to make 2,000 customers work, you can't be picky. You take everyone. The good senders. The bad senders. The spammers. Everyone shares the same infrastructure.

**$30 is a filter.**

Not everyone will pay $30 for email. And that's the point.

The people who won't pay $30? They're probably not ready for serious email marketing anyway. They're testing. Experimenting. Playing around.

The people who will pay $30? They have skin in the game. They have customers. They have revenue. They care about deliverability.

$30 is the minimum amount that lets us:
- Maintain clean IP pools with only serious senders
- Provide real human support (not chatbots or canned responses)
- Include deliverability infrastructure that others charge extra for
- Build features for operators, not just beginners

When everyone on your platform is paying, you build for paying customers. You don't spend half your time building "upgrade nudges" or limiting features to push conversions. You just build good software.

## The Support Math Nobody Talks About

Let's do some quick math.

Platform A has 100,000 free users and 2,000 paid users at $50/month. That's $100,000 in monthly revenue supporting 102,000 users. Each support ticket costs them money they might never recoup. Your ticket gets lost in the noise.

Bento has 3,000 customers at an average of $45/month (hypothetical). That's $135,000 per month to support 3,000 users. Every single person contacting support is helping pay the bills and we have the budget to serve them. 

Guess who gets better support?

It's not even close.

When you email us, you're a customer. Not a user. Not a lead. A customer.

That changes everything.

## The People You Want as Neighbors

Here's who's using Bento right now:

SaaS founders. Ecommerce stores. Newsletter writers. Course creators. Agencies.

Real businesses. With real customers. And real revenue.

You know what these people have in common?

They can't afford to have their emails land in spam. They need their onboarding emails to reach trial users. Their revenue depends on cart recovery emails getting delivered. Their reputation relies on their newsletters hitting inboxes.

These are the neighbors you want. 

People who follow best practices because their business depends on it.

## What If $30 Feels Like Too Much?

If $30 per month feels like a big investment, you're probably not ready for Bento.

And that's okay.

Maybe you're still figuring things out. Maybe email isn't important to your business yet. Maybe you're just starting.

Use something else. Learn. Grow. Come back when you're ready.

We'll be here.

But if you're thinking "$30? That's nothing for good email infrastructure"...

Then you get it.

You understand that email is an investment, not an expense. You know that deliverability matters. You've felt the pain of bad infrastructure.

Welcome. You're exactly who we built Bento for.

## The Truth About "Free"

Nothing is actually free.

Free platforms make money somehow.

They limit features. They sell your data. They show ads. They charge crazy rates once you grow.

Or worst: they burn through venture capital and disappear. With your data.

Bento's model is simple.

You pay us. We provide infrastructure and support. No tricks. No games. No "contact sales for enterprise features."

Just honest business.

## What Your $30 Actually Buys

People think they're paying for software.

They're not.

You're paying for:
- IP addresses that aren't blacklisted
- Neighbors who don't spam
- Support from humans who care
- Infrastructure that works
- A business model that makes sense

You're also NOT paying for:
- World class support
- Deliverability tools (they're included, not add-ons)
- API access (unlimited, no extra fees)
- Advanced features (everything's included from day one)

Most platforms nickel and dime you for these things. Or don't offer them at all.

We just include them. Because they're not optional. They're the whole point.

## An Invitation

Here's the deal.

If you're serious about email marketing, if you understand that infrastructure matters, if you want support that actually helps—try Bento.

We have a 30-day free trial. Send some campaigns, set up automation, see what quality infrastructure feels like.

If it's not worth $30 to you after that, no hard feelings. At least you'll know what you're missing.

But if you see your emails landing in inboxes...

If you appreciate getting real answers to support questions...

If you like knowing your neighbors aren't destroying your reputation...

Then welcome to Bento.

We built it for people who take email seriously.

The $30 price tag ensures everyone here does.

That's not a bug. It's the whole point.

Bento's $30 starting price protects deliverability and ensures every customer gets the support they deserve.

Why Bento Starts at $30 (and Isn't Free)

The right affiliate partnerships can turn a blog from a side project into real income. Most bloggers still promote offers that don't match their audience, pay tiny commissions, or create compliance problems. This guide will shows you how to evaluate affiliate programs in 2025. It highlights top picks across categories and explains where Bento fits into your monetization workflow without losing reader trust.

## TL;DR: Affiliate Monetization Playbook
- __Start with fit__: Choose programs that match your audience's goals, not just the highest commissions.
- __Diversify offers__: Mix evergreen tools, niche digital products, and curated marketplaces so you're not dependent on one partner.
- __Automate delivery__: Use Bento segmentation and workflows to recommend relevant offers after subscribers engage with specific content.
- __Track ROI__: Tag subscribers by affiliate campaign and connect conversions back to your email funnels.
- __Stay compliant__: Disclose clearly, respect deliverability rules, and monitor link health to protect reader trust.

### Step 1: Evaluate Programs Before You Apply
If you use these criteria, you'll be able to find programs that work long-term.

__Audience Match__: Does the product solve a real problem for your readers? Think about what your audience wants and comes for to your blog. Great idea is to also get feedback through surveys or email replies.

__Commission Structure__: Check the rate, cookie length, and whether payouts are recurring or one-time. Calculate expected earnings based on your typical conversion rate.

__Payout Terms__: Look at minimum payout thresholds, payment frequency, and methods like bank transfer, PayPal, or wire.

__Conversion Assets__: Good programs will provide creative assets, funnels, webinars, or templates you can co-brand.

__Tracking Technology:__ Reliable programs use modern tracking like first-party cookies, coupon codes, and UTM resilience with real-time dashboards.

__Support__: Dedicated affiliate managers, resource hubs, and Slack communities show a partner that's invested in your success.

__Compliance__: Make sure partners allow email promotion, specify disclosure requirements, and honor refund policies that won't claw back all your commissions.

Document your findings in a comparison sheet so you can rank programs objectively.

### Step 2: Understand Affiliate Program Types
Different monetization goals need different program structures.

- Retail and ecommerce networks like Amazon Associates, LTK, and RewardStyle work great for product roundups and lifestyle bloggers. Commissions usually range from 1-20%, with short cookie windows between 24 hours and 30 days.

- Digital product and course platforms such as Gumroad, Podia, and Teachable offer 20-50% commissions with longer cookies. They're ideal for education-focused audiences.

- SaaS and B2B tools including Bento, ConvertKit, Notion, Ahrefs, and Semrush offer higher payouts at 20-50% recurring, but they need more targeted content and nurturing.

- Marketplaces and aggregators like ShareASale, Impact, CJ Affiliate, and Awin give you access to thousands of brands. You control which offers you promote.

- Fintech and services such as Brex, Gusto, and QuickBooks offer flat payouts or revenue share tied to financial products. They work well for business and finance blogs.

Mix at least one from each category that fits your readers to stabilize revenue.

### Step 3: Top Affiliate Programs for Bloggers (2025)
This list covers programs with strong reputations, competitive payouts, and solid support. Verify details before applying since terms can change.

| Program     | Best For     | Commission & Cookie     | Why Bloggers Love It     |
| ---------- | ---------- | ---------- | ---------- |
| Bento Partner Program       | Email-first marketers, SaaS and ecommerce operators       | 30% recurring revenue share, 90-day cookie       | Value-based pricing resonates with serious operators. Co-marketing materials available. Integrates directly into your email content.       |
| Amazon Associates       | Lifestyle, commerce, review blogs       | 1%-20% category-based, 24-hour cookie (extended for carts)       | Massive product selection, easy link creation, global reach.       |
| ShareASale Network       | Niche product and service bloggers       | Varies by merchant. Cookies 30-120 days       | One dashboard to manage hundreds of merchants, deep-link generator, real-time reporting.       |
| Impact.com       | Established blogs needing enterprise partners       | Custom commissions. Robust tracking       | Access to Fortune 500 brands, advanced contract options, reliable support.       |
| Awin       | International bloggers       | Avg. 5%-15%, 30-day cookie       | Strong European merchant coverage, intuitive dashboard, auto-deep linking.       |
| ConvertKit Creator Network       | Creator-oriented newsletters and bloggers       | 30% recurring on subscriptions       | Focused on creator tools, co-marketing webinars, premium templates.       |
| Shopify Affiliate Program       | Ecommerce educators       | Avg. $150 per referral, 30-day cookie       | High payouts, extensive training courses, exclusive landing page creative.       |
| Podia Partner Program       | Education and digital product bloggers       | 30% recurring, 90-day cookie       | Supports creators launching courses, built-in resources, transparent dashboard.       |
| Adobe Creative Cloud       | Design, photography, video blogs       | 8.33%-85% depending on product, 30-day cookie       | Recognized brand, strong creative community, special promos.       |
| Notion Affiliate       | Productivity and knowledge management blogs       | 50% credit toward plan upgrades, incentives       | Perfect match for workflow guides, flexible incentive structure, co-branded assets.       |
| Bluehost Affiliate       | WordPress and hosting tutorials       | $65-$130+ per signup      | High flat payouts, seasonal boosts, proven conversion funnels.       |
| Gusto Partner Program       | Small business and finance blogs       | $100-$200 per company       | Appeals to SMB readers. Co-branded webinars and resources.       |
| Canva Creators Affiliate       | Design and social media content blogs       | 25% commission, 30-day cookie       | High adoption among small businesses. Template demos drive conversions.       |

Keep a living spreadsheet with program terms, top performing content, and conversions so you can optimize over time.

### Step 4: Integrate Affiliate Offers into Bento
Affiliate revenue scales when it's embedded in your lifecycle marketing.

__Segment by interest__: Tag subscribers based on content they consume, like "monetization," "design tools," or "email automation."

__Trigger sequences__: After a reader downloads a relevant lead magnet (/lead-magnets-guide), launch a Bento workflow recommending related affiliate tools.

__Personalize content blocks__: Use conditional sections in your newsletter (/how-to-create-newsletter) to surface different offers to each segment.

__Automate follow-ups__: Send reminder emails to subscribers who clicked an affiliate link but didn't purchase. Many programs let you generate unique coupon codes for retargeting.

__Sync attribution__: Store affiliate link IDs or coupon codes in Bento custom fields so you can credit revenue to specific sequences.

__A/B test landing pages__: Use /landing-page-ab-testing to optimize affiliate mini-sites or resource pages before driving paid traffic.

### Step 5: Craft Affiliate Content That Converts
Bloggers do best when they balance value with promotion.

__Comparison guides__ analyze pros and cons, pricing, and use cases. They provide decision frameworks that help readers choose the right tool.

__Case studies__ share your own results or reader success stories using the product. Real examples build trust better than feature lists.

__Tutorials__ walk through setup and quick wins. Embed video or GIF walkthroughs to show the product in action.

__Resource libraries__ curate tools by category like email marketing, design, or analytics. Update them quarterly to keep content fresh.

__Newsletter features__ spotlight a partner in your weekly update. Include story-driven intros, not just links.

__Email sequences__ create nurturing sequences that educate before the pitch (/email-sequence-guide).

Always include clear disclosures at the top and near CTAs.

### Step 6: Track Performance and ROI
Affiliate success is data-driven. Build dashboards that combine site analytics with Bento metrics.

- __Top pages and traffic sources__ help you identify which posts drive clicks. Focus your promotion efforts on what's already working.

- __Click-through rate__ varies by format. Compare inline text links against buttons and comparison tables to see what converts best for your audience.

- __Conversion rate__ shows up in partner dashboards where you can view sales and commissions. Track this over time to spot trends.

- __Earnings per subscriber__ matters in Bento. Calculate revenue for segments exposed to affiliate campaigns to see which audiences are most valuable.

- __Refund and reversal rates__ reveal clawbacks. They signal misaligned offers that don't match what your readers actually need.

- __Deliverability impact__ shows up in open and spam rates. Promotional-heavy emails can trigger filters if you don't balance content with value.

Review reports monthly and prune underperforming links.

### Step 7: Stay Compliant and Protect Trust
Affiliate income disappears when readers feel misled.

__Disclosures__ must follow FTC guidelines. Place prominent notices like "This email contains affiliate links. We may earn a commission."

__Consent matters__. Make sure subscribers opted in for promotional emails. Bento records consent history for audits.

__Brand safety__ means vetting partners for ethical operations, data privacy, and product quality. Your reputation depends on who you promote.

__Link maintenance__ catches 404s or expired offers. Use link monitoring tools to keep everything working.

__Regional compliance__ requires adapting disclosures and tax reporting for EU, UK, Canada, and other jurisdictions. Rules vary by location.

Combine evergreen content with periodic reader surveys to make sure offers stay relevant.

## Affiliate Monetization Workflow Checklist
 - Audit your audience's top goals and pain points.
 - Shortlist affiliate programs using the evaluation criteria.
 - Apply and onboard. Collect tracking links, creative, and brand assets.
 - Build pillar content and resource hubs featuring your chosen partners.
 - Integrate offers into email sequences, newsletters, and landing pages via Bento.
 - Set up dashboards to monitor clicks, conversions, and revenue.
 - Review quarterly, replacing low performers and testing new partners.
 - Refresh disclosures, creatives, and offers to keep content current.

## Internal Linking and Next Steps
Pair this guide with /lead-magnets-guide to grow the top of your funnel. Keep subscribers engaged with targeted sequences from /email-sequence-guide. Optimize the landing pages hosting affiliate content using /landing-page-ab-testing. Convert new readers into loyal advocates via /email-marketing-funnels.

## Ready to Monetize Responsibly with Bento?
High-performing affiliate programs reward bloggers who respect their audience. Bento gives you the segmentation, automation, and analytics to recommend the right partner at the right moment while keeping deliverability strong. Build your monetization workflows in Bento today or book a strategy session to map revenue streams without compromising trust.


Compare top affiliate programs, evaluate payout models, and integrate affiliate offers into Bento-powered funnels that respect your readers.

Best Affiliate Programs for Bloggers: Monetize Your Audience

Your website gets 10,000 visitors this month. Great. But if 9,950 leave without joining your list, you basically lit that traffic on fire. A generic "Subscribe for updates" form in your footer? That's not working. Nobody cares about your updates. What they care about solving their problems.

You need email capture that actually works: forms that convert, popups that don't annoy, offers people actually want, plus the technical setup to handle it all without tanking your deliverability or breaking compliance rules.

This guide covers email capture tactics that work in 2025, from smart forms to in-product prompts. You'll learn what converts, what kills deliverability, and how to set it all up with Bento.

## TL;DR: Email Capture That Actually Works
__Quick wins for different situations:__

- __Content sites:__ Add inline forms with content upgrades (templates, checklists). Works 3x better than generic signups.
- __Ecommerce:__ Exit-intent popups with discount codes convert at 5-15%. Just don't overdo it.
- __SaaS products:__ Capture emails during onboarding. These users convert 4x better than cold leads.
- __B2B sites:__ Gated content (guides, tools, calculators) pulls in qualified leads who actually buy.

__What to watch:__ Too many popups hurt deliverability; bad leads trash your sender reputation; always connect forms to automation for instant follow-up.

## The Psychology of Email Capture (Why People Actually Sign Up)
People don't give out their email addresses for fun. They're trading their contact info for something specific and the better you understand this trade, the better your forms convert.

A software company tested two identical popups; one said "Get our newsletter." and the other said "Get the Excel template that saves 2 hours per week." They had same form, same placement and same timing, but the template offer converted 8x better. Why? Because it promised a specific outcome, not vague future value.

Your capture strategy needs three things to work. First is immediate value - people want something right now, not promises about future emails. Second are trust signals - privacy policies, testimonials, subscriber counts. The third one is minimal friction. This means every extra field cuts conversions by about 25%, so you should start with just an email field and get the rest later.

## Email Capture Methods That Convert

### Inline Forms (The Workhorses)
Inline forms sit right in your content. No popups, no interruptions. Just a form where it makes sense. These work best when the offer matches the content perfectly.

Say someone's reading your guide about Instagram marketing. Halfway through, you offer an Instagram hashtag analyzer tool. That's contextual. It's relevant. It converts at 2-8% versus 0.5% for generic newsletter signups.

Place inline forms after your introduction (catch the interested), in the middle of long posts (engaged readers), and at the end (completionists). Use different offers for each placement. Early forms get quick wins like checklists. End forms get comprehensive guides.

The copy matters more than the design. You should tell people exactly what they get: "Download the 2025 Instagram hashtag guide (PDF)" beats "Sign up for tips" every time. You should also add how many people already downloaded it as social proof and number work.

### Exit-Intent Popups (The Last Chance)
Exit-intent popups appear when someone moves their mouse to leave. They're your last shot at converting a visitor. Done right, they add 2-5% to your overall conversion rate, yet if you do them wrong, they will annoy everyone.

The secret is timing and relevance. Don't show popups to everyone, but only to people who spent 30+ seconds on your site, and those that will scrolled past 50% and check multiple pages. These signals mean they're interested but need a push.

Your offer needs to be better than your inline forms. If inline forms offer a checklist, popups offer the full guide. If forms give 10% off, popups give 15%. Make it worth the interruption.

Keep the form dead simple. Just email, with maybe first name, as every field more will kill the conversion. For example, one ecommerce site removed their "phone number" field and conversions jumped 31%, as people hate giving out their phone number.

### Slide-ins and Notification Bars (The Gentle Touch)
Slide-ins appear from the corner after specific triggers and notification bars stick to the top or bottom. Both convert without blocking content. They work great for time-sensitive offers or gentle reminders.

A recipe blog uses slide-ins brilliantly. After someone saves three recipes, a slide-in offers their meal planning template. It's triggered by behavior, not time. The conversion rate? 12%. Generic popups on the same site? 1.8%.

Notification bars work best for urgency. "Webinar starts in 2 hours" or "Sale ends tonight" or "3 spots left in the course." are great ones. Keep them short, one sentence max, but include a clear CTA button.

### Gamification and Interactive Captures
Quizzes, calculators, and tools capture emails while providing value. People complete them because they want the result. The email capture happens naturally at the end.

A fitness site created a "Find your perfect workout" quiz. Five questions, personalized results, email required to see the full plan. It converts at 43%. Their regular forms? 2%. The difference? People invested time and want their personalized answer.

Calculators work the same way. These include ROI calculators, pricing calculators and savings calculators. People input their data, you calculate the result, and they give their email to get the detailed report. One B2B company gets 67% of their leads from a single ROI calculator.

### Content Upgrades (The Perfect Match)
Content upgrades are bonuses directly related to the post someone's reading. Reading about Facebook ads? Offer a Facebook ad template. Reading about email marketing? Offer email swipe copy. The match between content and offer drives conversions.

These typically convert at 20-30% versus 2-3% for generic offers. Why? Because the visitor already showed interest by reading the content. The upgrade extends that value immediately.

Create one content upgrade for your top 10 posts. But make it just 10! Those posts probably drive 50% of your traffic anyway. Make the upgrades substantial - a one-page PDF won't cut it; think templates, tools, or detailed guides. It has to be something worth an email address.

## In-Product Email Capture (For Apps and SaaS)
Your product is your best email capture tool. Users already trust you and they're engaged. What they want is to succeed with your product. This is prime territory for email capture.

### Onboarding Captures

Capture emails during signup or onboarding, but be smart about it. Don't force marketing emails on everyone - make it optional with clear value.

"Get weekly tips for growing your store" works better than "Subscribe to our newsletter." One SaaS added an optional checkbox during signup: "Send me examples of successful campaigns." 73% check it and those users stick around 2x longer than ones who don't.

### Feature Unlocks and Upgrades
Gate certain features behind email capture. These should only be the features that make sense such as a project management tool which gates their templates gallery. Want templates? Enter your email. They get 10,000 emails per month this way.

The key is value exchange. People get something useful immediately and you get permission to email them. Everyone wins! What is important is just not to gate the core features as that pisses people off.

### Achievement and Milestone Emails
Trigger email capture at success moments. User hits 100 sales? Offer an advanced selling guide via email. Completed their first project? Send pro tips to their inbox.

These moments work because users are happy since they just succeeded. They're receptive to help getting even better. One learning platform captures emails when users complete their first course: "Get your certificate emailed plus weekly learning tips." 81% opt in.

## Technical Setup That Doesn't Break
Great forms mean nothing if your technical setup fails. You need forms that submit reliably, data that syncs properly, and automation that triggers instantly.

### Form Integration Basics
Your forms need to talk to your email platform immediately. No manual exports and no CSV uploads. Real-time sync or nothing.

Connect your forms to Bento through their API, Zapier, or native integrations. Every form submission should create or update a contact, trigger welcome emails, apply tags, and store the source. This happens in milliseconds, not hours.

Track everything about the signup: which form, which page, what offer, what time. This data drives your segmentation and personalization later. A generic "Newsletter Subscriber" tag tells you nothing. "Downloaded Instagram Guide from /instagram-marketing on Nov 10" tells you everything.

### Double Opt-in Decisions
Double opt-in means people confirm their email address before you can market to them. It's required in some places (hello, Europe). Optional in others (hey, USA).

The tradeoff is real. Double opt-in kills 20-30% of signups because people don't confirm, but the ones who do are more engaged. They open more, click more, buy more. Your list is smaller but stronger and that means more.

For B2B or high-value products, use double opt-in. Here quality matters more than quantity. For ecommerce or content sites, single opt-in will often work better and volume matters. You just need to clean your list aggressively.

### Welcome Automation Setup
Your welcome email needs to send instantly. Not tomorrow. Not in an hour. Now. People expect it. If it doesn't arrive, they think something broke.

Set up your welcome sequence before launching any capture forms. The sequence should deliver the promised asset, set expectations about future emails, provide quick value beyond the asset, and ask for preferences or profile data.

One ecommerce brand tested welcome email timing. Instant sends got 74% open rates. One hour delay dropped to 51%. Next day? 23%. Speed matters more than perfection.

## Compliance Without the Headache
Email law is complex and boring, but violations are expensive. Get the basics right and you'll avoid most problems.

GDPR requires explicit consent in Europe. No pre-checked boxes, no bundled consent. Tell people exactly how you'll use their email. Store proof of consent with timestamp and source.

CAN-SPAM in the US is easier. Don't mislead people and make sure to include your address. Make unsubscribing easy. That's basically it. Keep in mind that states like California are adding their own rules, so stay updated.

The safest approach works everywhere - be transparent about what people are signing up for and m,ake unsubscribing one click. Respect preferences immediately. Don't be shady. It's not that hard.

## Testing and Optimization
Your first forms won't be perfect and that's fine. Test, learn, improve, but test the right things in the right order.

Start with your offer as this drives the biggest improvements. Test different lead magnets, discounts, or free trials. One change here can double conversions. A marketing agency tested "Free consultation" versus "Free marketing audit." and the audit converted 3x better. Same service, different framing.

Next, test timing for popups and slide-ins. Too early annoys people, while too late misses them. Find your sweet spot through testing. Most sites do best with 30-45 second delays or 50% scroll depth.

Then test form fields. Every field you remove increases conversions. Yet some fields improve lead quality. Test to find your balance. B2B companies often keep "company name" despite lower conversions because it qualifies leads better.

Copy tests come next - headlines, button text, privacy assurances. These create 10-30% improvements. They are worth doing, but are not game-changing. "Get instant access" beats "Submit" for button text. "No spam ever" beats long privacy explanations.

Finally, test design and colors. These rarely move the needle much - there may be 5-10% improvements. Leave this for last and focus on the big stuff first.

## Measuring What Matters
Track the right metrics or you'll optimize for the wrong things. Conversion rate is obvious but not enough.

List growth rate tells you if you're actually growing. Subtract unsubscribes and bounces from new signups. If you're adding 1,000 people but losing 800, you have a problem.

Lead quality metrics matter more than quantity. Track how many captured emails actually open your welcome email (should be 50%+). Click something in the first 30 days (20%+). Make a purchase within 90 days (varies by business). If these numbers suck, your capture strategy attracts the wrong people.

Revenue per subscriber is the ultimate metric and you must calculate total email revenue divided by list size. This will tell you if your list building actually makes money. At the end of the day, growing a list of non-buyers is pointless.

You should monitor deliverability constantly and if open rates drop or spam complaints rise, your capture tactics might be attracting bad leads. One aggressive popup campaign can wreck months of reputation building.

## Common Mistakes That Kill Conversions
- __Asking for too much too soon.__ People don't trust you yet. Start with just email and get more info later through progressive profiling.
- __Generic offers nobody wants.__ "Newsletter" and "Updates" don't convert; Specific value does. "10 Photoshop shortcuts" beats "Design tips" every time.
- __Popups on mobile that break everything.__ Test your forms on actual phones as half your traffic is mobile. If forms don't work there, you're losing half your potential list.
- __No follow-through after signup.__ People sign up and nothing happens, then they forget you exist. Send that welcome email immediately. Deliver the promised value. Start the relationship right.
- __Ignoring list quality for quantity.__ A 100,000 person list means nothing if nobody opens your emails. Focus on engaged subscribers who actually want to hear from you.

## Advanced Strategies for Scale
Once basic capture works, level up with advanced tactics.

### Behavioral Targeting
Show different offers based on behavior. New visitors get broad lead magnets and returning visitors get specific tools, while people who viewed pricing get demos or trials.

One SaaS tracks everything visitors do. View three feature pages? Get a popup for a feature comparison guide. Check pricing twice? Slide-in offers a custom demo. This behavioral targeting doubles their conversion rate.

### Multi-step Forms
Break long forms into steps. This shows progress and reduces abandonment. The first step is just an email (low commitment), but the scond step asks for more as they're already invested.

A B2B company split their demo request form. Step 1: Email and name. Step 2: Company and role. Step 3: Specific needs. Completion rate jumped from 23% to 61%. Same fields, different psychology.

### Personalized Captures
Use data you already have. Returning visitor? Reference it. "Welcome back! Did you get the guide?" From a specific campaign? Mention it. "Since you clicked from our Facebook ad..."

Personalization can be simple. Use different forms for different traffic sources and different offers for different pages, as well as different timing for different user types. Small changes will lead to big results.

## Platform-Specific Implementation

### Shopify Email Capture
Shopify makes email capture easy, yet most stores do it wrong: they use the default popup with 10% off. But since everyone does this, it doesn't work anymore.

What is better approach is to use cart value triggers. Someone adds $100 to cart? Don't offer 10% off - offer free shipping. Someone's browsing sale items? Offer early access to the next sale. Match the offer to behavior.

Use Shopify's customer accounts for capture. During checkout, make account creation optional but valuable. "Create an account to track your order and earn rewards." 67% will do it. Now you can email them.

### WordPress Forms That Convert
WordPress has endless form plugin and, let's be frank, the most are overkill. You need forms that load fast, look good, and integrate with your email platform.

Skip the bloated builders and use lightweight plugins that don't slow your site. Every second of load time costs 7% in conversions. That fancy form animation isn't worth it.

Place forms using hooks, not widgets. Widgets are inflexible. Hooks let you control exactly where forms appear. After third paragraph. Before comments. Inside specific posts. Precision placement improves conversions.

### Custom-Built Captures
Building your own forms gives total control, but you need make sure not to overcomplicate it. A simple HTML form with JavaScript validation and API submission works fine.

Focus on speed and reliability. Forms should submit instantly, you should show clear success/error messages and handle edge cases like duplicate emails or network failures. The basics matter more than fancy features.

## Making It All Work Together
Email capture is just the start. What happens next determines success.

Connect every form to automation. Welcome sequences, nurture campaigns, segmentation rules. This should be automatic, not manual. Bento handles this through workflows that trigger on form submission.

Make sure to monitor quality constantly. If new subscribers don't engage, something's wrong - maybe your offer attracts the wrong people and maybe your welcome email sucks. Always also check if the forms are broken. Watch the data and adjust.

Test continuously but strategically. Don't test everything at once, just pick one element, test for statistical significance, implement the winner and thenn move to the next test. Systematic improvement beats random changes.

Keep the end goal in mind. Email capture isn't about growing a number. It's about building relationships with people who want to buy from you. Every form, popup, and offer should move toward that goal.

## Your Next Steps
Stop reading and start doing. Pick your best content page. Add an inline form with a relevant offer. Set up a welcome email. Launch it today.

Once that works, add exit-intent to your highest-traffic pages. Test different offers and see what converts, thenm build from there.

Email capture isn't complicated. It's about value exchange. Give people something worth their email address. Make sure to follow up immediately and to deliver on your promises. Do this consistently and your list will grow with quality subscribers who actually buy.

Ready to implement these capture strategies? Bento connects forms, automation, and deliverability tools in one platform. [Request a demo](https://savvycal.com/bento/demo?d=30) or email sales@bentonow.com to discuss your capture strategy!


Upgrade your email capture strategy with value-driven offers, smart popups, and Bento integrations that balance growth, compliance, and deliverability.

Email Capture Ideas: Forms, Popups, and Progressive Profiling

If you ask me what the best “all-in-one” marketing software is, my answer is “it depends.” 

Are you a SaaS company? An eCommerce brand? A professional services agency? An education business? A media company? 

And how do you sell? Direct to checkout? Phone sales? Demos?

The best marketing software *for you* will depend on what you sell and how you sell it. And also how much control you're willing to give up, for the sake of convenience.

We're going to help you think through that decision. We won't pretend to be impartial, because Bento **IS the best** all-in-one marketing software for *almost* every business model and sales process. And you're on OUR blog.

## TL;DR: Quick Picks by Niche/Business Type

Here are the mental “shorlists” people choose their email marketing service from, based on niche/business type:

  - B2B (consulting, services): Bento, Hubspot, ActiveCampaign, GoHighLevel
  - eCommerce: Bento, Klaviyo, Omnisend, Privy, Mailchimp
  - Online education (courses, coaching): Bento, Kit, ActiveCampaign, GoHighLevel
  - SaaS: Bento, Loops.so, Customer.io, Hubspot, Brevo
  - Affiliate & direct response marketing: Campaign Refinery, ActiveCampaign, GoHighLevel
  - Content creators: Kit, Substack, beehiiv 

This type of categorization makes sense. If you're a B2B that needs CRM and sales pipeline features, Hubspot is a better choice than Klaviyo. If you're a newsletter business that sells ads placements, beehiiv is a better choice than ActiveCampaign. Different email marketing services excel in different areas.

So why is **Bento** in every shortlist except Affiliate & Direct Response? That's easy. Because we're the only full-stack marketing platform with the necessary tools for every niche and business model. More on that in a minute.

![bento](//images.ctfassets.net/7154jijfbyeo/UkmTILUGISwVjk5ISQmdH/07c24a1df56806a53574e959142956e4/bento.png)

Why don't we allow affiliate marketers and direct response companies on our platform? It's because they tend to be extremely aggressive marketeers and they also tend to sell slop. And by slop I mean low-quality products or outright scams. That eventually leads to a poor email engagement and lot of spam complaints, which negatively effects deliverability for all our customers. 

And who wants that hassle, am I right?

## Why Marketing Software Choice Matters in 2026

### Convenience vs Control

Before you choose your marketing software you have to make a decision. Do you want convenience or do you want control?

MOST people prefer convenience because, let's face it, no one loves building, maintaining or scaling Frankenstein's ~~monster~~ tech stack. And marketing teams have more important things to do than waste time jumping between 15 different tools.

The thing is, though, all-in-one marketing platforms know this. And they charge accordingly. So, if you really want convenience, get comfortable with the idea of paying $7,500/month (or more, at scale) to send some emails, manage your sales pipeline, and schedule social media posts. *(Unless you're smart enough to use Bento.)*

On the other end of the spectrum are the tech-comfortable and tech-curious marketers. They want the control. Because they want to use the best tool for the job. And they don't mind getting their hands dirty and jury-rigging integrations to get the tools in their tech stack to play nice together.

These marketeers enjoy far lower technology costs and as a result, lower CPCs (cost per click) and CACs (cost to acquire a customer). But that comes at an additional cost (and operational load) of maintaining a cobbled-together system which can, and does, break often.

### Bad deliverability kills revenue

Email marketing is our specialty, so we're admittedly biased. But no matter what marketing software you use, your number one concern ought to be email deliverability. Your emails need to reach the inbox. Simple as that. If 10% more emails reach the inbox, you make 10% more from every campaign or book 10% more sales calls.

With many all-in-one marketing platforms, deliverability is an afterthought. Even if they pay lip-service to it in their marketing material. Hubspot, GoHighLevel, ActiveCampaign: 3 of the most popular all-in-one marketing software and all 3 notorious for poor email deliverability.

Not only that, many of these platforms don't offer built-in deliverability management tools. You're expected to manage that on your own, separately. This is fine if you're an email marketing expert and know what you're doing. But what about for everyone else who just want to email their list and make sure it gets to their contacts' inboxes?

*(FYI, Bento comes with several deliverability tools and guardrails out-of-the-box.)*

## Core Evaluation Criteria

### Deliverability infrastructure

You need SPF, DKIM, and DMARC set up from day one. Your provider should help you monitor reputation, control send speed, catch bad addresses. Bento includes all this stuff. No extra charges for basic inbox placement tools.

### Automation depth vs. usability

Complex workflows are great if someone can actually build them. You want branching logic, behavior triggers, personalization. But you also want to ship campaigns this week, not next quarter. Find platforms with visual builders and templates you can actually use.

Bento's new [AI-mode](https://bentonow.com/posts/ai-mode) lets you chat your automations to life.

### Pricing that rewards clean lists

Most platforms charge by total contacts. Got 100,000 contacts but only email 30,000 active ones each month? Too bad. You still pay for all 100,000. That's $800 monthly for people who never open your emails.

Bento charges for what you send, not what you store. Email your engaged 30,000 subscribers, pay for 30,000. Save 70% while your deliverability improves because you're not blasting cold contacts.

### Data flexibility and CRM connections

Your marketing platform needs to talk to other tools. Good APIs matter. Webhooks matter. Can you get your data out if you need to switch? Some platforms make exports painful on purpose. Check before you commit.

Bento offers native integrations to many of the most popular software tools used by eCommerce, B2B, SaaS, content, and online education businesses. And if we don't have a native integration for a tool you use, you can simply use Zapier to get it to talk to Bento.

## Platform-by-Platform Breakdowns

### Bento: Deliverability-first all-in-one

![bento](//images.ctfassets.net/7154jijfbyeo/owWYl4psczdBbWR2gLtKq/5677a499e07c920a30b615b93163208c/bento.png)

Bento puts marketing, product, and transactional email in one place. Deliverability tools come standard. Authentication setup, domain warming, send throttling, all included. You pay for what you send, not your total database size.

The automation builder handles onboarding sequences, drip campaigns, win-back flows. Real-time triggers fire based on what users actually do. Developers get solid APIs. Marketers get an interface that makes sense. Both can work without stepping on each other.

### ActiveCampaign: Marketing automation plus light CRM

![activecampaign](//images.ctfassets.net/7154jijfbyeo/55qOD3pkBeAVTyn0vCxsbg/b742fa50babc0fd7cd83097c00d92aed/activecampaign.png)

ActiveCampaign mixes email automation with basic CRM features. Deal tracking, lead scoring, pipeline management. The workflow builder gets complex fast. You can build 5 or 6 levels deep with branching logic everywhere.

It takes time to learn. Most teams need 2 to 3 weeks before they're comfortable. Pricing starts at $145 monthly for 10,000 contacts, then jumps to $350. Deliverability tools exist but you'll configure them yourself. Pick ActiveCampaign if you need CRM features and have patience to learn the system.

### Klaviyo: Ecommerce powerhouse

![klaviyo](//images.ctfassets.net/7154jijfbyeo/3fQsSSd26utDPkgJ3J5MMG/4ee7901ddb9ba35cc6ad27416f4b55be/klaviyo.png)

Klaviyo owns the Shopify space. Over 40,000 stores use it. The platform predicts customer lifetime value pretty accurately after just three purchases. Cart abandonment flows typically save 10 to 15% of lost sales.

But it's expensive. At 50,000 contacts you're paying $1,250 monthly. Doesn't matter if half those contacts never buy. If you're not running an online store with real product data, you probably don't need Klaviyo's complexity.

### HubSpot Marketing Hub: All-in-one for HubSpot CRM users

![hubpot](//images.ctfassets.net/7154jijfbyeo/10HCW7pMtqkD2xaXENvimj/73243e9b2771b9fd61f5cc07b68ee210/hubpot.png)

HubSpot makes sense if you already use their CRM. Marketing, sales, service teams all see the same data. Campaign automation, landing pages, reporting, it's all there. 

Pricing adds up fast though. Every add-on costs more. Deliverability features need manual setup. Still, if your whole company runs on HubSpot, the marketing hub fits naturally.

### MailerLite: Budget-friendly automation

![mailerlite](//images.ctfassets.net/7154jijfbyeo/767Cc78oqaVwxKfnXsYAK4/79ae598097fab3ab1c7b50e5b5ce2f88/mailerlite.png)

MailerLite gives you a decent free tier. Basic automation, segmentation, drag-and-drop editor. Good for small businesses getting started. The workflows aren't as powerful as pricier options. You'll need separate tools for deliverability monitoring. But for simple email marketing that doesn't break the bank, it works.

### Brevo (Sendinblue): Unlimited contacts on the free plan

![brevo](//images.ctfassets.net/7154jijfbyeo/16kg8VG3r4NeZGAXvYK9kk/aa72de609e4c2d4d3fbeb7e0726a4731/brevo.png)

Brevo limits daily sends, not contact count. Store a million contacts if you want. Just can't email them all at once. Good for businesses that email occasionally. Automation and transactional emails work fine. Deliverability help is mostly DIY. Pick Brevo if you send infrequently and want to avoid contact limits.

### ConvertKit (Kit): Creator-focused automation

![kit](//images.ctfassets.net/7154jijfbyeo/Oo9cToXDJBtoNSfOMQQRB/27745d2cacb6bd441289e58d1969dca1/kit.png)

ConvertKit works for creators, course sellers, newsletter writers. The tagging system makes sense. Easy to segment subscribers based on what they've bought or clicked. Paid newsletter features built in. Product launch sequences ready to go.

The automation isn't as deep as enterprise tools. Deliverability support comes from the community, not dedicated help. Fine for creators who want simplicity. Teams needing serious automation should look elsewhere.

### Customer.io: Product-led engagement

![customer dot io](//images.ctfassets.net/7154jijfbyeo/2vosiKYSk14BxZ3LNJBAgS/ac857d8650d75c659a8524fd6c0430c0/customer_dot_io.jpg)

Customer.io targets product teams at SaaS companies. Send emails, push notifications, in-app messages based on user behavior. Strong API for developers. 

You'll need engineers to set it up and maintain it. Pricing reflects that enterprise focus. Use Customer.io when you have technical resources and need messages across multiple channels.

### Other notable tools

Salesforce Marketing Cloud, Marketo, Oracle Eloqua. These serve huge companies with big budgets. Powerful? Yes. Six-month implementations? Also yes. Professional services bills? Definitely. 

Mid-market teams usually regret going enterprise too early. Start with something you can actually use today.

## Migration and Implementation Roadmap

### Audit your current workflows and deliverability health

List every automation you run. Every email list. Every transactional message. Check your deliverability scores in Google Postmaster Tools and Yahoo Postmaster. Know where you stand before you move anything. This baseline helps you prove the switch was worth it.

### Plan a phased rollout

Don't move everything at once. Start with your most important automations. Then regular campaigns. Save transactional emails for last since they're usually the most complex. 

Bento's send throttling helps warm up new sending domains without hurting delivery. Test everything before you switch completely. Set deadlines but be realistic.

### Train teams on the new process

Your team needs to know what's changing. Show operators the new workflow builder. Walk through the dashboards they'll monitor. Get developers involved early for API setup. Make sure sales knows how to access marketing data in their CRM. 

Write down the new processes. Record training videos if needed. A smooth switch depends on everyone knowing their part.

## Ready to Pick Your Marketing Platform?

Picking marketing software isn't about counting features. It's about emails reaching inboxes, automations that run themselves, teams that work together. All without burning cash on tools you barely use.

Bento includes deliverability infrastructure from the start. You pay for emails sent, not contacts stored. Everything works in one platform. [Book a walkthrough](https://bentonow.com/demo) or email sales@bentonow.com to see it in action.

For more comparisons, check out our guides on [best email marketing services](/posts/best-email-marketing-services), [email automation software](/posts/email-automation-software), and [Mailchimp alternatives](/posts/mailchimp-alternatives).

Discover marketing software that keeps deliverability, automation, and CRM in one operator-friendly stack so your team can move faster without risking inbox placement.

Best Marketing Software: One Platform for Email, Automation, and CRM

Learn why your emails are going to spam and how to fix inbox placement. Understand spam filters, reputation issues, and deliverability best practices.

Why Are My Emails Going to Spam? 


When teams look at delivery logs across various email sending platforms (ESP), they often see two numbers that appear interchangeable: accepted and delivered. On the surface they sound like synonyms, but anyone who has stared at a flatlined open rate after a “successful” send knows the difference matters.

An "accepted" status means a receiving server (often the server of the ESP) initially took the message from you. "Delivered" confirms that the message was successfully handed off to the recipient's mailbox. However, everything between those two checkpoints-filtering decisions, throttling, temporary deferrals-determines how many people actually see your email in their inbox.

This guide breaks down what those statuses really mean, why the distinction shows up in your performance metrics, and how to monitor them without getting lost in platform jargon.

## TL;DR: Accepted vs. Delivered

- **Accepted** = The ESP’s server said “sure, we’ll take it from here”.
- **Delivered** = The message was successfully transferred to the recipient's mailbox. This does *not* guarantee it landed in the inbox.
- A strong program tracks both so you can spot spam-filter detours or infrastructure issues quickly.

If you’re troubleshooting bigger delivery swings, bookmark [troubleshooting email delivery issues](/posts/troubleshooting-email-delivery-issues) and [monitoring email delivery and reputation](/posts/monitoring-email-delivery-reputation) for deeper dives.

## What Is Email Status?

Deliverability dashboards read like flight trackers: every status shows where a message is in transit. Providers name the steps differently, but the core milestones stay consistent. Messages sit in a send queue, move to “sent” once your platform hands them off, show up as “accepted” when the destination server takes responsibility, and ultimately land as “delivered” if nothing breaks along the way. 

Bounces and deferrals flag the exceptions-hard bounces for permanent failures, soft bounces or deferrals when the other side asks you to try again later. Knowing the vocabulary makes it easier to spot bottlenecks without guessing.

## Email Delivery Stages

Think of the journey in five beats. First, you hit your ESP with an API request to send an email. Second, it queues it to send from it's email servers. Third, the email server attempts to send the email. Fourth, the receiving server does its internal filtering and, assuming everything checks out, places the email in the inbox. 

If something goes wrong-bad address, policy violation, full mailbox-you’ll see a bounce instead. Mapping the flow like this keeps status reports from feeling abstract.

## Accepted vs Delivered

### Accepted

An accepted status is the ESP saying, “Got it, thanks.” That’s good news-your API keys work. It does not, however, promise the message reached someone’s inbox.

### Delivered

Delivered is the final handoff: the ESP placed the email in the recipient's mailbox. It's the last status an email provider can confirm. From this point on, mailbox providers like Gmail or Outlook can still filter the message to spam or other folders. If your accepted rate is strong but your open rates are lagging, you’re likely facing a filtering or engagement problem, not a transport issue.

## Other Email Statuses

### Bounced

Bounce events flag addresses you couldn’t reach. Hard bounces signal permanent issues-a non-existent mailbox or blocked domain-so suppress those contacts right away. Soft bounces point to temporary problems like a full inbox or a brief outage. Most providers will retry soft bounces automatically; keep an eye on repeated failures and clean them up if they persist.

For Bento, we'll automatically remove these from your list if the bounce indicates the email inbox no longer exists or is in operation. Reputation or network bounces we won't touch so you can try again.

### Deferred

Deferred messages sit in limbo because the receiving server asked you to slow down. Maybe you hit a rate limit, maybe they’re busy. Your provider will usually retry for a set window. If deferrals become a pattern, check your sending cadence-batching tools and better list hygiene often fix the bottleneck.

For Bento, we try extremely hard to avoid deferrals where we can but in instances we can't we'll continue to retry to get them into the inbox.

## How to Track Email Status

You don’t need a wall of dashboards to stay informed. Start with your provider’s analytics to understand accepted, delivered, and bounce trends. Layer in webhooks if you want delivery events piped into your own systems for alerts or custom reporting. Then review the outliers-campaigns with unusual gaps or spikes usually reveal authentication errors, list quality problems, or suddenly disengaged segments. Treat status data like an early-warning system rather than a vanity metric.

## Where Bento Helps

If you need a platform that takes status data seriously, Bento bakes the essentials in. Delivery logs show accepted, delivered, deferred, and bounced events in real time, and webhooks push those updates wherever your team wants them. More importantly, the infrastructure work that protects those numbers-SPF, DKIM, DMARC, reputation monitoring, batching controls-comes included. You can focus on the messages themselves instead of juggling tooling just to figure out where an email went.

## Next Steps

If accepted and delivered still feel interchangeable, start tracking them separately on your next send. Set a baseline for both metrics, wire up webhooks if you need faster alerts, and dig into any campaign where accepted outpaces delivered by a wide margin. Pair that with the resources below when you need deeper troubleshooting:

- [Troubleshooting email delivery issues](/posts/troubleshooting-email-delivery-issues)
- [Monitoring email delivery and reputation](/posts/monitoring-email-delivery-reputation)
- [Email bounces guide](/posts/email-bounces-guide)

The sooner you treat accepted vs. delivered as two distinct checkpoints, the easier it becomes to spot deliverability drift before revenue takes a hit.


Learn the difference between accepted and delivered email status. Understand email delivery stages, what each status means, and how to track email delivery.

Accepted vs Delivered: Understanding Email Status

Your email campaign just landed in spam. SPF looks good. DKIM is signing. DMARC passes. Something else is broken.

Finding that problem usually means hours of manual work. You check headers in one tool. Test authentication in another. Verify DNS somewhere else. Most email testing tools only do one thing, so you bounce between five different sites trying to figure out what went wrong.

AboutMyEmail changes that. Steve Atkins from Word to the Wise built this free tool that checks everything in one shot. Send an email to the unique address it gives you. Get back a report that covers authentication, headers, DNS, content, compliance, everything.

The timing is perfect. Yahoo and Google have started enforcing new sender requirements. One missing header or authentication issue can tank your deliverability. AboutMyEmail has a "Good Practice" section that specifically checks if you meet these new requirements. It catches problems before they hurt your campaigns.

## TL;DR: AboutMyEmail Quick Guide

**AboutMyEmail** is a free email testing tool from Word to the Wise that analyzes emails you send to a unique address. You get a comprehensive report covering authentication, headers, DNS, content, and compliance.

**What it checks:**
- **SPF, DKIM, DMARC**: Authentication pass rates and configuration
- **BIMI**: Logo verification and certificate details
- **Headers**: Both formatted and raw header analysis
- **DNS**: All relevant DNS queries for authentication
- **Content**: Links, images, MIME structure, HTML rendering
- **Compliance**: Yahoo and Gmail requirement checks
- **SMTP session**: Full delivery details including IP address and TLS

**How to use it:**
1. Go to aboutmy.email
2. Copy the unique email address it provides
3. Send your test email to that address
4. View the detailed report

**What to watch out for:** The reports are dense. If you're new to email headers or DNS records, the amount of data might feel overwhelming at first. But that detail is what makes it useful. You get the exact error, not just "something's wrong."

As a starting point, try to get to 9/9 for "Fully complies with Yahoo / Google requirements." (possible with Bento!).

![CleanShot 2025-11-10 at 16.04.40@2x](//images.ctfassets.net/7154jijfbyeo/7zuyU1zTi9dDhYMRWSaUbz/61bd00ceed0d0400bade458701fb4b15/CleanShot_2025-11-10_at_16.04.40_2x.png)

## What Is AboutMyEmail?

AboutMyEmail is a free testing tool Steve Atkins built at Word to the Wise. It works simply. The site gives you a unique email address. You send your test email there. You get back a complete analysis.

Most tools do one thing. MXToolbox checks your DNS. Mail-tester scores your spam likelihood. Header analyzers just show headers. You end up with tabs open everywhere trying to piece together what's happening. AboutMyEmail runs all these checks at once. Authentication, DNS, headers, content, images, links, compliance. One email, one report.

The tool gained popularity when Yahoo and Google announced their new sender requirements. Everyone scrambled to check if their emails were compliant. AboutMyEmail added a "Good Practice" section that runs through the entire checklist. Missing List-Unsubscribe header? It tells you. DMARC not set up? It flags that too.

This comprehensive checking matters because email deliverability has gotten complex. Your SPF might pass but your DKIM alignment could be wrong. Your authentication might be perfect but you're missing required headers. One small issue sends everything to spam. AboutMyEmail catches these problems before you send to real subscribers.

## What AboutMyEmail Checks

The tool runs over +30 different checks on your email. Some are basic (SPF pass/fail), others dig deep (image scaling warnings, MIME structure analysis). Here's what you get.

### Authentication Checks

Authentication gets the deepest treatment. The tool doesn't just tell you SPF passed. It shows the actual DNS lookup, what records it found, which IP it checked against, and the result. Same for DKIM. You see the selector, the public key, the signature verification, everything.

If you have BIMI set up (the logo that shows next to your email), it checks that too. Certificate valid? Image the right format? Most people don't even know BIMI exists, but if you have it configured wrong, AboutMyEmail tells you.

### Header Analysis

Email headers are like shipping labels on a package. They show where the email came from, how it traveled, and what's inside. Problem is, they're usually unreadable technical gibberish.

AboutMyEmail decodes them. You get both the pretty version (human readable) and the raw version (what actually got sent). It checks technical stuff like line length limits, character encoding, even whether you're using the right line endings. Small details that break emails when they're wrong.

### DNS Verification

DNS is where most email authentication lives. Your SPF record says which servers can send for you. Your DKIM selector points to your public key. Your DMARC policy tells receivers what to do with failed emails.

AboutMyEmail queries all these records and shows you exactly what it found. Not a summary, the actual DNS response. If your SPF record has "v=spfl" instead of "v=spf1" (common typo), you'll see it. If your DMARC record is on the wrong subdomain, you'll know.

### Content Analysis

Content analysis goes beyond just "here's your HTML." The tool extracts every link and tells you where it points. It finds every image, downloads it, checks the file size, measures the actual dimensions, then compares that to how you're displaying it. Loading a 2000x2000 image and scaling it to 200x200? That's wasting bandwidth and slowing load times.

You also get previews showing how your email looks on different screen sizes. What happens when images don't load? Does your alt text make sense? These previews catch problems that only show up in specific email clients.

### Compliance Checks

The "Good Practice" section is what everyone's using right now. Yahoo and Gmail published new requirements for bulk senders. You need proper authentication. You need one-click unsubscribe. You need to stay under spam rate thresholds.

AboutMyEmail runs through the checklist. Green checkmarks for what you're doing right. Red warnings for what needs fixing. It checks for List-Unsubscribe headers, List-Unsubscribe-Post support, proper From alignment, everything on the requirement list.

### SMTP Session Details

The SMTP session is the actual conversation between your email server and the test server. AboutMyEmail records the whole thing. Which IP sent the email? Was the connection encrypted? What commands were used?

This catches configuration issues. Maybe your emails claim to be from your domain but they're actually coming from your ESP's generic IP pool. Maybe TLS isn't working. The session log shows exactly what happened when your email was delivered. Plus you get the exact byte size of your email, which matters since Gmail clips messages over 102KB.

## How to Use AboutMyEmail

The process is dead simple. Go to aboutmy.email. The site generates a unique email address like test-abc123@aboutmy.email. Copy it. Send your test email to that address. Refresh the page. Your report appears.

Each test gets its own address, so you can run multiple tests without mixing results. Testing different subject lines? Different ESP settings? Send each version to a new test address.

Reports load directly on the webpage. No login, no download, just scroll through the results. The sections are clearly labeled: Authentication, Headers, Content, Compliance. Each section expands to show details. You can jump straight to problem areas or read through everything.

The amount of information can feel overwhelming at first. But when you're debugging a specific problem, that detail is invaluable. Instead of "authentication failed," you see "SPF failed because 192.168.1.1 is not in the include:sendgrid.net lookup." Exact problem, exact solution.

## Why AboutMyEmail Matters for Deliverability

Email deliverability is death by a thousand cuts. Your authentication passes but your IP reputation is low. Your reputation is fine but you're missing headers. Everything technical is perfect but your content triggers spam filters.

Most people find out about these problems after their campaign tanks. Open rates drop. Subscribers complain they're not getting emails. By then, the damage is done. Your sender reputation is hurt, and climbing back takes weeks.

AboutMyEmail lets you catch problems during testing. Run your email through before sending to your list. Fix the issues it finds. Then send with confidence.

The tool has become essential since Yahoo and Gmail tightened requirements. They want SPF, DKIM, and DMARC. They require one-click unsubscribe. Spam rates must stay below 0.3%. Miss any of these and your emails go straight to spam, or worse, get blocked entirely. AboutMyEmail's compliance section checks all these requirements at once.

## AboutMyEmail vs. Other Testing Tools

Mail-tester gives you a spam score. MXToolbox checks your blacklist status. Litmus shows rendering previews. Each tool does one thing well, but you need accounts everywhere and you're constantly switching between them.

AboutMyEmail does it all. One test gives you authentication results, header analysis, content review, compliance checking, rendering previews, the works. And unlike most comprehensive tools, it's completely free. No signup, no trial, no premium features hidden behind a paywall.

The depth of analysis sets it apart. When SPF fails, you don't just see "fail." You see the entire SPF record, the DNS lookups it triggered, which mechanism failed, and why. This level of detail used to require expensive enterprise tools or deep technical knowledge.

MailOps engineers love it because they get raw SMTP sessions and DNS queries. Marketers like it because the compliance section speaks their language: "Add List-Unsubscribe header to meet Gmail requirements." Both groups get what they need from the same report.

## Start Testing Your Emails Today

AboutMyEmail should be part of your pre-send checklist. Before any major campaign, before testing a new ESP, before changing your email templates, run a test through AboutMyEmail.

Head to aboutmy.email right now and send a test. Even if you think everything's working fine. You might be surprised what it finds. That newsletter you've been sending for years? It might be missing headers that Gmail now requires. Your transactional emails? They could have authentication issues you never noticed.

Start with the Authentication section when you get your report. If anything shows red there, fix it first. Authentication failures mean nothing else matters. Your emails won't even get a chance at the inbox. Next, check Compliance. The new Yahoo and Gmail requirements aren't suggestions. Miss one and your deliverability tanks. Then review Headers and Content for any warnings.

Make this a habit. Test before every campaign. Test when you change ESP settings. Test when you update DNS records. Small issues compound into big problems if you don't catch them early.

The tool costs nothing to use. Steve Atkins built it as a service to the email community. Word to the Wise has been helping people with deliverability for decades. This tool is their way of making expert-level diagnostics available to everyone.


Test email headers, authentication, and Yahoo/Gmail compliance with AboutMyEmail. Get detailed reports on SPF, DKIM, DMARC, BIMI, and more from this free tool.

AboutMyEmail: Free Email Testing Tool for Headers and Compliance

The List-Unsubscribe header enables one-click unsubscribe from email clients.

When you include List-Unsubscribe headers in emails, email clients (Gmail, Outlook, Apple Mail) display unsubscribe buttons that let recipients unsubscribe with one click. This improves user experience and reduces spam complaints.

List-Unsubscribe headers aren't just nice-to-have features. They're required by Gmail and Yahoo for bulk senders (5,000+ emails/day), and they improve deliverability by reducing complaints. Understanding List-Unsubscribe helps you comply with requirements and improve inbox placement.

This guide will explain what List-Unsubscribe headers are, how they work, and how to implement them. We'll cover everything from header format to compliance requirements to deliverability benefits.

Let's implement List-Unsubscribe headers.

## TL;DR: List-Unsubscribe Header Basics

The List-Unsubscribe header enables one-click unsubscribe directly from email clients. When you include it, email clients like Gmail and Outlook display unsubscribe buttons that let recipients unsubscribe without even opening your email.

If you're sending 5,000 or more emails per day to Gmail or Yahoo addresses, List-Unsubscribe headers are required. You need to include both the List-Unsubscribe header and the List-Unsubscribe-Post header, and you should provide both HTTP and mailto unsubscribe URLs. Gmail also requires that you process unsubscribes within 2 days (meaning they literally do not want to see you email that user after 48 hours from clicking that button). 

The benefits are straightforward. Making it easy to unsubscribe reduces spam complaints, which improves your deliverability. Lower complaint rates mean better inbox placement. Plus, one-click unsubscribe is just better user experience. And if you're a bulk sender, it keeps you compliant with Gmail and Yahoo requirements.

The main thing to watch out for is making sure you include both HTTP and mailto URLs, process unsubscribes quickly, and test that your unsubscribe links actually work. If recipients can't unsubscribe easily, they'll mark you as spam instead.

## How List-Unsubscribe Headers Work

The process is straightforward. You include List-Unsubscribe headers in your email headers with your unsubscribe URLs. When the email arrives at the recipient's inbox, email clients like Gmail, Outlook, and Apple Mail detect the header automatically.

Once detected, the email client displays an unsubscribe button directly in the email interface. When recipients click that button, the email client sends an unsubscribe request to your unsubscribe URL. Your application then processes that request and removes the recipient from your list.

The whole flow happens without the recipient needing to open your email. They see the unsubscribe button right in their inbox, click it, and they're done. This makes unsubscribing much easier than hunting through your email for an unsubscribe link, which improves user experience and reduces spam complaints.

## List-Unsubscribe Header Format

The basic format includes both an HTTP URL and a mailto URL. Here's what it looks like:

```
List-Unsubscribe: <https://example.com/unsubscribe?token=abc123>, <mailto:unsubscribe@example.com>
```

The HTTP URL enables one-click unsubscribe via POST request. The mailto URL provides an email-based unsubscribe option for clients that prefer it. You should include both because different email clients handle them differently.

For better security, you can also include the List-Unsubscribe-Post header. This tells email clients to use POST requests instead of GET requests, which prevents unsubscribe tokens from appearing in URLs:

```
List-Unsubscribe: <https://example.com/unsubscribe?token=abc123>
List-Unsubscribe-Post: List-Unsubscribe=One-Click
```

The mailto URL is technically optional, but it's recommended because some email clients prefer email-based unsubscribe. Including both gives you the best compatibility across different email clients.

## Gmail and Yahoo Requirements

Both Gmail and Yahoo have the same requirements for bulk senders. If you're sending 5,000 or more emails per day to Gmail or Yahoo addresses, you must include List-Unsubscribe headers in your emails.

The requirements are straightforward. Recipients must be able to unsubscribe with one click, and you need to process unsubscribes within 2 days. You also need to include the List-Unsubscribe header in all your emails.

Even if you're below the 5,000 emails per day threshold, including List-Unsubscribe headers is still a good idea. They improve deliverability by making unsubscribing easier, which reduces spam complaints. Lower complaint rates mean better inbox placement, so it's worth including them regardless of your volume.

## List-Unsubscribe-Post Header

The List-Unsubscribe-Post header tells email clients to use POST requests for one-click unsubscribe instead of GET requests. This improves security because POST requests don't expose unsubscribe tokens in URLs.

Here's the format:

```
List-Unsubscribe-Post: List-Unsubscribe=One-Click
```

When email clients see this header, they send POST requests to your unsubscribe URLs instead of GET requests. This prevents unsubscribe tokens from appearing in URLs, which is more secure.

You should use the List-Unsubscribe-Post header alongside the List-Unsubscribe header. It's not required, but it's a best practice for security. If someone intercepts a GET request, they could see the unsubscribe token in the URL. POST requests keep that information in the request body instead.

## How to Implement List-Unsubscribe Headers

The implementation process involves a few steps. First, create HTTP unsubscribe endpoints that can process unsubscribe requests. Make sure to include secure tokens in your URLs for authentication, so people can't unsubscribe others without permission.

Next, add the List-Unsubscribe headers to your email headers. Include both HTTP and mailto unsubscribe URLs for the best compatibility. Then add the List-Unsubscribe-Post header for secure POST-based unsubscribe.

When unsubscribe requests come in from email clients, handle them immediately. Process the unsubscribes right away and remove recipients from your lists. Don't make people wait or require additional confirmation steps.

Finally, test your implementation with different email clients. Send test emails to Gmail, Outlook, and Apple Mail accounts and verify that unsubscribe buttons appear correctly. Make sure unsubscribe requests are processed properly when recipients click those buttons.

The good news is that most email services handle this automatically. If you're using an email service provider, you typically just need to configure List-Unsubscribe in your settings. They'll add the headers and handle the unsubscribe processing for you.

## List-Unsubscribe Best Practices

Effective List-Unsubscribe implementation comes down to a few key practices. Include both HTTP and mailto URLs in your headers. HTTP URLs enable one-click unsubscribe, while mailto URLs provide email-based unsubscribe options for clients that prefer them.

Use the List-Unsubscribe-Post header for secure POST-based unsubscribe. It's not required, but it's more secure than GET requests because it doesn't expose tokens in URLs.

Process unsubscribes immediately when requests come in. Remove recipients from your lists right away. Gmail requires processing within 2 days, but the faster you process them, the better. Don't make people wait or require additional confirmation steps.

Use secure tokens in your unsubscribe URLs for authentication. Make sure tokens are unique and time-limited so people can't unsubscribe others or use old unsubscribe links maliciously.

Test your List-Unsubscribe headers with different email clients. Send test emails to Gmail, Outlook, and Apple Mail accounts and verify that unsubscribe buttons appear correctly. Make sure the buttons actually work when clicked.

Monitor your unsubscribe rates over time. If you see high unsubscribe rates, it might indicate issues with your content or targeting. Use that data to optimize your email strategy.

The key is making unsubscribing easy, processing requests quickly, and ensuring everything works correctly. Following these practices improves both user experience and deliverability.

## Where Bento Fits: List-Unsubscribe Included

If you're implementing List-Unsubscribe headers, Bento handles it automatically. You don't need to configure headers manually or build unsubscribe endpoints yourself. Bento automatically includes List-Unsubscribe headers in all your emails.

Bento also provides one-click unsubscribe functionality that works with email clients. Recipients can unsubscribe with one click directly from their email interfaces, and Bento processes those unsubscribe requests automatically. Recipients are removed from your lists immediately when they unsubscribe.

Bento ensures that List-Unsubscribe headers meet Gmail and Yahoo requirements, so you comply with bulk sender requirements automatically. You don't have to worry about header formats or compliance details.

Bento makes sense if you're sending emails and want List-Unsubscribe headers, one-click unsubscribe, and automatic processing handled for you. If you care about compliance and deliverability, Bento ensures your emails meet requirements without extra configuration.

Specialized tools make sense if you need advanced unsubscribe management from dedicated unsubscribe platforms, detailed unsubscribe analytics from specialized analytics platforms, or highly customized unsubscribe flows that require custom development.

Bento isn't trying to replace specialized unsubscribe tools. If you need advanced management or detailed analytics, those tools excel. But if you want email sending with List-Unsubscribe headers and one-click unsubscribe included, Bento provides that combination.

## Ready to Implement List-Unsubscribe Headers?

List-Unsubscribe headers are essential for email compliance and deliverability. If you're building this yourself, start by creating HTTP unsubscribe endpoints that can process unsubscribe requests. Include secure tokens in your URLs for authentication.

Next, add List-Unsubscribe headers to your email headers with both HTTP and mailto unsubscribe URLs. Include the List-Unsubscribe-Post header for secure POST-based unsubscribe. When unsubscribe requests come in from email clients, process them immediately and remove recipients from your lists.

Test your implementation with different email clients to verify that unsubscribe buttons appear correctly and that unsubscribe requests are processed properly. Then monitor your unsubscribe rates over time and use that data to optimize your email strategy.

If you're using an email service provider, check if they handle List-Unsubscribe automatically. Most modern email services include List-Unsubscribe headers by default, so you might just need to enable it in your settings.


Learn what the List-Unsubscribe header is and how to implement it. Understand email compliance requirements and how List-Unsubscribe improves deliverability.

List-Unsubscribe Header: Email Compliance Best Practices

Compare email outreach tools for cold sales vs marketing campaigns. Find platforms that actually deliver emails to inboxes with proven deliverability.

Best Email Outreach Tools: Cold Email vs Marketing Email Platforms

Good transactional emails are key to many businesses, making the difference between confused customers and happy ones. 

But what are transactional emails anyway? 

You certainly had experience with them - those are the order confirmations that actually tell you when your package arrives, the password reset that works on your phone, the receipt you can find later. What makes all these emails work is that they're clear, they load fast on mobile, and they give you exactly what you need.

Most people copy templates for transactional emails without understanding why they work. But you really need to understand the patterns first to make it work. Only then you can create emails that actually fit your business.

This guide breaks down real transactional email examples and shows you what makes them tick. You'll see order confirmations, password resets, receipts, and more. Plus you'll learn how to build your own.

## TL;DR: Transactional Email Examples
__The most important transactional emails:__

- __Order confirmations__: Show order details, payment info, tracking links
- __Password resets__: Include secure tokens, clear instructions, security warnings
- __Welcome emails__: Confirm signup, set expectations, show next steps
- __Receipts:__ Provide complete details, clean layout, PDF attachments
- __Shipping notifications__: Give tracking info, delivery dates, action links

__What makes them work:__

- Clear content that tells users what to do next
- Mobile-friendly design (most people read email on phones)
- Your brand colors and fonts throughout
- Fast delivery (within seconds of the trigger)
- Clean, professional layouts

__What to watch out for:__ Don't just copy templates blindly. Study why they work, then adapt them to your brand. Focus on making emails clear, mobile-friendly, and useful.

## What Makes Effective Transactional Emails?

The best transactional emails share a few key traits. First, they're crystal clear: when someone opens your order confirmation, they should instantly see their order number, what they bought, and when it arrives. No hunting around.

Second, they work on phones. Over 60% of emails get opened on mobile devices now. If your email breaks on a phone screen, you've lost your customer. Single-column layouts, big buttons, readable fonts - simple stuff that works.

Third, they arrive fast. When someone resets their password, they want that email now, not in 10 minutes. Speed builds trust, delays create support tickets.

Fourth, they give users something to do. Every transactional email needs a clear next step - track your package, reset your password, download your receipt. 

Finally, they match your brand: your transactional emails shouldn't look like they came from a different company. Same colors, same fonts, same feel. Customers notice when things look off.

###  Order Confirmation Email Examples

![CleanShot 2025-11-18 at 13.23.42@2x](//images.ctfassets.net/7154jijfbyeo/7JzxirJpX2aKVLork1gEF7/a9330ecd7eae0a6c1de95abcd8d2475d/CleanShot_2025-11-18_at_13.23.42_2x.png)

Order confirmations are probably the most (and fastest) opened transactional emails. People want details of their orders, such as if their order went through and when stuff arrives. People often don't trust web interfaces so will go to their inbox for proof.

A good order confirmation starts with the order number right at the top, big and bold. Then it should show what they bought in a clean table format with product names, quantities, prices.  

Next come payment details. Show the payment method (last 4 digits of the card is enough), the total amount, and any tax or shipping charges. Shipping information goes below that. Include the shipping address so they can double-check it's right. Remember to also add the estimated delivery date. If you have a tracking number already, include it with a big "Track Package" button.

IMPORTANT NOTE: Some brands EXCLUDE shipping information as a best practice to ensure that no PII ever leaks. You'll see large companies like Amazon, Walmart, etc do this. Customers can misspell their domain (gail instead of gmail) and that information can end up in the wrong hands.

The best order confirmations also include helpful links such as those that help customers view the order online, start a return or contact support. Put these in buttons, not just buried in text.

Like Uber, you can also include a main CTA to get value from the product you just charged them to help reduce churn.

Subject line tip: Keep it simple. Something like "Order #12345 confirmed" or "Uber Subcription Renewed" works better than clever copy. People search their email for order numbers later.

### Password Reset Email Examples

![CleanShot 2025-11-18 at 13.29.53@2x](//images.ctfassets.net/7154jijfbyeo/53Q2HLIu1EDKF46XSQNgds/bf810cb3b33ed908c89a9b26a5312349/CleanShot_2025-11-18_at_13.29.53_2x.png)

Password reset emails need to do two things: be secure and be fast. People locked out of their accounts don't have patience for confusion.

Start with a security warning right at the top. "If you didn't request this password reset, you can ignore this email." This prevents panic if someone gets the email by mistake.

Then get straight to the point: "Click the button below to reset your password." No long explanations needed. Put a big, obvious "Reset Password" button right there. Make it a button, not a text link especially as buttons work better on mobile.

You should always include an expiration time with lines such as "This link expires in 15 minutes" or "This link expires in 1 hour." Put this near the button so people see it. Nothing worse than clicking an expired link.

Add the reset link as plain text too, below the button. Some email clients block buttons, and people might need to copy-paste the link.

Subject line should be clear: "Reset your password for [Your App Name]". Skip the fancy stuff. Someone trying to get back into their account wants clarity, not creativity.

We also recommend including one or two interesting pieces of information in the email you're sending so that the user knows you are reaching out to them and they aren't subject to a phishing attempt. We've seen brands like LinkedIn do this often in their footers.

![CleanShot 2025-11-18 at 13.31.49@2x](//images.ctfassets.net/7154jijfbyeo/77Y3VUQY1b2FQ1MLDP8RkH/d562f14e23977c5b0c5104e7310401ef/CleanShot_2025-11-18_at_13.31.49_2x.png)

### Welcome Email Examples

![CleanShot 2025-11-18 at 13.33.57@2x](//images.ctfassets.net/7154jijfbyeo/iVE0YdOqF8wC7ftwlERyq/0161366d91714b36bd833357254edcdb/CleanShot_2025-11-18_at_13.33.57_2x.png)

Welcome emails set the tone for your whole relationship. Get it right and you've got an engaged user; mess it up and they might never come back.

Start with a warm greeting using their name if you have it. "Welcome to [Product], Sarah!" feels better than generic greetings. Then confirm what just happened: "Thanks for signing up."

You should set expectations early. Tell them what kinds of emails you'll send and how often. Weekly newsletters? Product updates? Special offers? Be honest. If they know what's coming, they're less likely to unsubscribe later.

Show them one clear next step. Not five things, not ten features, but only one thing. Maybe it's completing their profile, maybe it's browsing products, maybe it's reading your most popular content - pick the action that creates the most value fastest.

If your product has key features or benefits, highlight 2-3 of them, possibly with images or icons if they help. But don't overwhelm readers and save the full tour for later emails.

Finally, put some helpful links such as FAQ, support and quick start guide. Put these in the footer where they're available, but not distracting.

Subject line: "Welcome to [Product]!" still works best. People expect it and look for it.

Also, don't feel the need to go crazy with the content. You can keep it simple, like the team at Turbopuffer do: 

![CleanShot 2025-11-18 at 13.35.05@2x](//images.ctfassets.net/7154jijfbyeo/wMa8wIwseKoxSfXFnhEef/e5aae061e142fd90b9f268a96433f2a9/CleanShot_2025-11-18_at_13.35.05_2x.png)

### Receipt Email Examples

![chewy-email-receipt-e1540988386206](//images.ctfassets.net/7154jijfbyeo/7jRKFxB7mnByeiYGrXWoLq/dd58e06e455379ccb6cd64b679dae768/chewy-email-receipt-e1540988386206.png)

Receipts are boring but important. People need them for expense reports, taxes, and records. Therefore, you want to make them easy to find and use.

Put the receipt number and date right at the top. Use a clear format like "Receipt #R-2024-12345" and "December 15, 2024" that will help with searching later.

Show what they paid for in a clean table that includes item names, quantities, individual prices, subtotal, tax and total. Include also full payment details which means payment method, last 4 digits if it's a card, transaction ID and payment date. These are important as some companies need this for accounting. Use the same format every time as consistency matters for financial documents.

Always offer a PDF version. You can either attach it to the email or include a download link. PDFs are easier to save and forward than HTML emails and many accounting systems prefer them.

At the end, add your business details too such as company name, address and tax ID if applicable. This stuff matters for business customers claiming expenses.

Subject line should be searchable: "Receipt for order #12345" or "Your receipt from [Company] - December 15". People search for receipts months later.

### Shipping Notification Email Examples

![63e5dedfdb0855815710a083 gPcF4CB8eOe-e4BA7KQAJmo301rkVYY6SmmmS-Uwiq772Nn8FcIn4bqe 49UtCPSyw2fk4n5IQUGoKkORn9zDxsYQMhVRZgTNoO](//images.ctfassets.net/7154jijfbyeo/2mbXA7hp0IE277yiriF5oj/09a3fd72011f7b680284f0ffdfb5e86d/63e5dedfdb0855815710a083_gPcF4CB8eOe-e4BA7KQAJmo301rkVYY6SmmmS-Uwiq772Nn8FcIn4bqe_49UtCPSyw2fk4n5IQUGoKkORn9zDxsYQMhVRZgTNoO.png)

Shipping notifications might be the most anticipated transactional emails as people want to know their stuff is on the way.

Lead with the good news: "Your order has been shipped!" and then immediately show the tracking number and carrier. Make the tracking number big and easy to copy, or better yet, make it a link that goes straight to the carrier's tracking page.

Next should be the estimated delivery date prominently. "Expected delivery: Tuesday, December 17" is what people care about most. If you have a delivery window ("between 2-6 PM"), include that too.

Confirm the shipping address - this prevents panic when someone suddenly wonders if they used the right address. Show it clearly but don't make it the focus.

It’s always good to include a brief reminder of what's coming. You don't need full order details (they have the confirmation for that), but "Your order of 2 items" or listing the main products helps people know which order shipped.

The focus should be a big "Track Package" button. Make this the primary action since it is something people will click on multiple times before delivery.

Subject line: "Your order #12345 has shipped" or "Your [Product Name] is on the way". Both work, but including the order number helps with multiple orders.

## Transactional Email Design Patterns

Good design isn't only about looking pretty, it's first and foremost about making emails that work. Here are the patterns that matter.

First, create a visual hierarchy. The most important stuff should be at the top. As we mentioned in the examples, these are things such as order number, tracking number and password reset button. Whatever the email is about goes first, big and bold, while less important stuff goes below, smaller and lighter.

Make content scannable keeping in mind people don't read emails word by word but skim through it, looking for what they need. Use short paragraphs (2-3 sentences max) and add spacing between these sections. Bullet points when listing things are very useful tool, and you should also bold important words like dates, amounts, and action items.

Buttons need to be obvious and tappable. Use contrasting colors that stand out and write clear button text: "Track Package" beats "Click Here" every time. On mobile, they will be minimum 44 pixels tall and you should test your buttons on an actual phone.

Keep your branding consistent, but subtle. Your logo at the top, your colors in the buttons and links - but don't go overboard. Transactional emails are about function, not marketing.

We mentioned that today over 60% of email opens happen on phones, which is essentially to design emails with mobile interface in mind. Use a single column layout, make text at least 14 pixels, put important info in the first 320 pixels (what shows in preview), make buttons big enoch and test everything on a real phone, not just your desktop browser's mobile view!

## Where Bento Fits: Transactional Email Templates

If you're building transactional emails, Bento gives you templates that actually work, plus the infrastructure to get them delivered.

You get pre-built templates for all the standard transactional emails: order confirmations, password resets, shipping notifications, receipts. They're already mobile-optimized and tested across email clients, you can just add your content and brand colors.

The templates are flexible, which means you can change colors, fonts, and layouts to match your brand and you can add custom fields for your specific data. You're not stuck with generic designs, but can use these templates as a basic start for designing your transactional emails.

Here's the real value: deliverability infrastructure comes built in. Authentication setup (SPF, DKIM, DMARC), reputation monitoring, send rate controls. This stuff usually costs extra or requires separate tools, but with Bento it's just included.

Therefore, Bento makes sense when you want professional transactional emails without building everything from scratch - you get templates, customization, and deliverability in one package.

If you use some specialized tools, they still have their place. If you need pixel-perfect email design control, use a dedicated design platform or iIf you want deep analytics on every email element, specialized analytics tools do that better. But Bento gives you what you need to start and, most importantly, keeps your emails out of spam folders.

## Ready to Build Better Transactional Emails?

Now you've seen what works. Time to build your own!

Start by auditing your current transactional emails. Which ones confuse customers? Which ones generate support tickets? Fix those first. A clear order confirmation saves more support time than any fancy automation.

Pick one email type to improve. Maybe password resets if you get lots of "can't log in" tickets or maybe shipping notifications if customers keep asking where their orders are. Start with the email that causes the most problems.

Then this guide comes to play - use the patterns we have listed here! Make sure you go though all the important points: clear hierarchy, mobile-first design, obvious buttons, fast delivery and testing. 

Once you send your transactional emails into the wild, measure what matters. Open rates for transactional emails should be around 80%+. Click rates vary by email type, and password resets should see 40%+ clicks. If your numbers are way off, something's broken. Make sure also to watch support tickets for confusion patterns as small improvements add up.

Good transactional emails reduce support tickets, increase customer satisfaction, and build trust. Start with one email. Make it better. Then move to the next.


Learn from transactional email examples and best practices. Understand what makes effective transactional emails and how to design emails that engage users

Transactional Email Examples: Best Practices and Templates

Learn what DKIM is and how to set it up for email authentication. Understand DKIM signatures, DNS records, and how DKIM improves email deliverability.

DKIM: What It Is and How to Set It Up for Email

Discover the best MailChimp alternatives that fit your needs and budget. In this guide we will offer you comparison of platforms that scale without breaking the bank or limiting growth, and help you with steps for migration from MailChimp.

MailChimp Alternatives: Find the Right Email Platform

You're here because you searched for "bento email alternative" or "bento competitor" on the big G or on ChatGippity.

Maybe you're doing some due diligence on us before you make the switch. Maybe you heard about us from a friend or business partner.

However you found us, I want to talk about some of the other posts ranking in Google search for "bento alternative" and "bento reviews" currently.

## The "Alternative" Post Playbook

There's a specific kind of blog post that exists purely to leech traffic from other brands like ours. You've probably seen them. "Top 8 {brand} Alternatives for 2025!" They follow a predictable formula:

1. Write a post targeting "{competitor} alternative"
2. Invent some problems with that competitor
3. List yourself as the #1 solution
4. End every FAQ with "that's why you should use us instead"

We've counted at least three posts ranking for "Bento alternative" written by companies who have never signed up for Bento. 

Never sent an email through our platform. 

Never looked at our automation builder or tested our deliverability infrastructure.

They just... made stuff up. 

They are not properly reviews. 

They are lies.

One post claims Bento has "limited automation flexibility." Another says we have "weak personalization features." A third suggests our "pricing isn't always justifiable" and they're 3x our price.

These would be valid criticisms if they were true. 

But they're not. 

They're invented problems designed to make their product look like the solution. 

## The Tells

You can spot these posts from a mile away:

**They always list themselves first.** The company writing the "alternatives" post somehow always ends up as the #1 pick. What a coincidence.

**They publish across multiple domains.** One company we found is running the same "Bento alternatives" article across multiple web properties. Double the keyword coverage. Same recycled content.

**Every FAQ is a sales pitch.** "What's the best alternative to Bento?" Their answer: themselves. "Does Bento have better automation?" Their answer: no, use them instead. It's like asking a Ford dealer if you should buy a Toyota.

**The "problems" don't match reality.** They'll claim Bento lacks features we've had for years. They'll say we're expensive when our pricing is public, competitive (we price match), and we're often cheaper. They haven't done the homework because they don't need to. They just need to rank.

## What They Got Wrong

Let's get specific. Here are the posts and the claims they made:

### Encharge's Misleading Post

![CleanShot 2025-12-03 at 14.15.12@2x](//images.ctfassets.net/7154jijfbyeo/2BpvBY7QQDb5KEWXvIkm2r/d09228f1ca8f76df8f6b285a70c8e7e7/CleanShot_2025-12-03_at_14.15.12_2x.png)

Encharge, an objectively weaker competitor to Bento, has a post titled "Top 8 Bento Alternatives" which lists four reasons to leave Bento. Let's go through them:

**"Limited Automation Flexibility"** - Bento's automation builder handles all types of triggers, multi-step sequences, branching logic, custom events, multiple ways to trigger an automation, and dynamic personalization all throughout.

We built it specifically for operators who need real automation, not just scheduled newsletters. 

Our main feedback from customers is that our flow product is TOO POWERFUL.It's about as advanced as you can get without requiring a PhD in email marketing. 

The email nerds LOVE it. 

Encharge's team wouldn't know this because they've never used our platform or even created an account. 

**"Weak Personalization Features"** - We support dynamic content, Liquid, merge tags, conditional blocks, behavioral segmentation, and even have a load of AI features baked in. You can personalize based on what people actually do in your product, not just what form fields they filled out. 

Personalization gets richer and richer with the more integrations you add and the more data you have. 

Again, they wouldn't know this because they've never used Bento.

They just like writing lies. 

**"Pricing Isn't Always Justifiable"** - It took me awhile to get Encharge's pricing page and website to load, but when it did, it was clear they love to twist reality. 

As of December 3rd 2025 on Encharge's official pricing page they list $75/mo for 2,000 subscribers. 10,000 subscribers you're looking at $239 — and that's on their cheapest plan. "Talk to enterprise" if you have over 50k???? 50k isn't enterprise level! 

![CleanShot 2025-12-03 at 14.19.47@2x](//images.ctfassets.net/7154jijfbyeo/1nMBoscFX2CO2CvcSDC071/e423889c9af5d730f37c5b6d2889fabb/CleanShot_2025-12-03_at_14.19.47_2x.png)

You're looking at almost double that for "Premium".

Surely they're just mistaken and maybe it's Encharge's pricing that isn't justifiable? 

What a joke. 

**"Lacks Native Integrations"** - We have a public API, SDKs in every major language, Zapier, Make.com, SureTriggers, Segment, and native integrations with the tools SaaS and ecommerce businesses actually use. If you can send a webhook, you can integrate with Bento.

I searched for "encharge ruby sdk" they don't have it. Nor do they have a Python, Ruby, or other SDKs. Horrible choice for a SaaS company. It's 2025, you need to be able to integrate with your tools.

### Martechs Post

It seems that Encharge may have distributed the post across multiple websites to rank for the same phrases in Google or improve their existing post. 

We see multiple instances of their posts being reposted on this "marketing" website. 

![CleanShot 2025-12-03 at 14.27.28@2x](//images.ctfassets.net/7154jijfbyeo/3Zom8mb8UiKxzABVp0qDe8/3b70327a68d4ae633bdda062f6c1f676/CleanShot_2025-12-03_at_14.27.28_2x.png)

Two domains, same content, double the keyword coverage. 

Classic SEO play.

![CleanShot 2025-12-03 at 14.47.11@2x](//images.ctfassets.net/7154jijfbyeo/QTLsgJmpqQiUUCTAWjkYh/bdce36f2735a53b1378271677cea35ad/CleanShot_2025-12-03_at_14.47.11_2x.png)

It's unlikely that this site just wrote this on their own accord and it was an SEO link campaign. 

### Userlist's Post

[Userlist's alternatives page](https://userlist.com/alternatives/bento/) takes a different approach. They've got a nice little feature comparison table with checkmarks and X marks. Very official looking.

Their conclusion? "Bento is a tool for anyone who wants to track their website visitors... Userlist is deeply focused on SaaS customers after they sign up, which makes it much easier to use."

Let's unpack that.

**"Bento isn't focused on SaaS"** - Bento was built from day one for SaaS companies and I'd estimate that the total revenue we earn from SaaS companies far exceeds their total revenue from all their customers. 

User onboarding sequences, product newsletters, churn prevention, subscription renewals. It's in our DNA. 

Sure, we also serve ecommerce and digital product creators, but SaaS is a core segment we dedicate a lot of resources to serving.

**"Userlist is easier to use"** - Based on what? 

They've never used Bento. 

Our visual automation builder is designed to be powerful without being overwhelming. 

It's a far cleaner UI and workflow builder than what they have.

**The Feature Table** - They've got this comparison grid implying Bento lacks certain features. The main thing that we miss is company profiles but from our experience no one uses or needs them, and we actually did have it at one point but deprecated it because it was a bad user experience/confusing. 

The other features like "In-app messages (web applications)" we leave to our integrations and partners to handle.

### GoCustomer's Post

GoCustomer published a post titled "Ditch Bento? These AI-Driven Email Marketing Alternatives Are Changing the Game" that lists six reasons to look beyond Bento.

Here's what's funny about this one: GoCustomer is a cold email outreach tool. It's designed for LinkedIn prospecting and sales outreach. Bento is a marketing automation platform for product, marketing, and transactional email.

They're not even in the same category. It's like a shoe company writing a "Why You Should Ditch Wearing Hats" post.

But let's go through their claims anyway:

**"Steep Learning Curve for Non-Technical Users"** - Our visual automation builder uses drag-and-drop. You can see your entire workflow visually. We've had customers with zero technical background building sophisticated automations within their first week.

Is there a learning curve? Sure, if you want to use advanced features. But the basics are straightforward. They wouldn't know this because they've never logged in.

**"Confusing Automation Features"** - Bento has one automation system. You create flows. Flows have triggers, actions, and conditions. That's it.

The fact that we support many types of triggers and actions doesn't make it "confusing and disorganized." It makes it flexible. Our customers love the power. The only confusion here is GoCustomer's understanding of our product.

**"Limited Built-in Integrations"** - We have SDKs in Ruby, Python, Node, Go, PHP, and more. We have Zapier, Make.com, SureTriggers, and Segment integrations. We have native integrations with Shopify, WordPress, and the tools our customers actually use.

GoCustomer? I checked. Their integrations page lists a handful of options. But sure, we're the ones with "limited" integrations.

**"Costly Pricing Structure"** - This one is rich. Our products aren't even comparable. 

**"Absence of a Forever Free Plan"** - This one is actually true. We don't have a forever-free plan.

Here's why: Because we don't want spammers on our platform. 

**"Occasional Bugs and Stability Issues"** - We have a 99.9%+ uptime track record. Our infrastructure handles millions of events daily. We have customers who've been with us for years sending at scale without issues.

Do bugs happen? In any software, yes. But "occasional bugs" as a reason to switch platforms? That's reaching.

The best part? GoCustomer lists themselves as the "#1 Author's Pick" alternative to Bento. A cold email prospecting tool as the top alternative to a marketing automation platform.

They've never used Bento. They don't compete with Bento. They just wanted to rank for "Bento alternative" and figured nobody would notice.

We noticed.

Oh and one last thing, they have a testimonial from Dolores. We're not sure that Dolores even exists (we searched our database and users around that time and couldn't find anything), and if that is true then did they write that review? 

## When You Should Use Bento

We're obviously biased. But here's an honest breakdown:

**Bento makes sense if you:**

- Care about deliverability and want infrastructure that helps you land in inboxes
- Need product, marketing, and transactional email in one platform
- Want behavioral automation without hiring a marketing ops team
- Like having direct access to the team building the product

**Bento is built for:**

- SaaS companies running user onboarding, product adoption, and retention campaigns
- Ecommerce businesses that want product-based automation (cart abandonment, browse behavior, post-purchase flows)
- Digital product creators who need more than basic newsletters
- Teams that take email seriously and want tools that match

## When You Might Actually Need Something Else

And here's the honest part those other posts skip: Bento isn't for everyone.

**You might need a different tool if:**

- You're testing email marketing for the first time and just need a landing page and newsletter (if that's the case pick Mailchimp or Convertkit, not the brands we mentioned earlier)
- You need a full CRM with sales pipeline management, not just email (we like Close.com for this)
- Your budget is extremely limited and you need a completely free option (Mailchimp or Klaviyo here)
- You need an all-in-one marketing suite that includes social media, paid ads, and everything else (don't pick a platform like this)

We don't pretend to be everything. We're an email marketing, marketing automation, and transactional email platform. We do those things well. If you need something we don't do, use a tool that does.

## The Irony Isn't Lost on Us

Yes, we're aware that this is Bento writing a "Bento alternative" post. 

The difference? We've actually used the product. We know what it does. We built it.

If you're going to write about Bento, at least sign up first. Send a few emails. Test the automation builder. Look at the analytics. Then tell people what you think. 

Until then, take those competitor comparison posts with a grain of salt. 

They're not reviews. 

They're SEO plays.

## Try It Yourself

You don't need to trust us. You don't need to trust those competitor posts either.

Sign up for Bento. Send some emails. See if the "problems" those posts describe actually exist, or if they were invented by marketing teams who needed content to rank.

We're confident in what we've built. And we'd rather you find out for yourself than take anyone's word for it.

---

*If you found this post while searching for a Bento alternative and you're genuinely evaluating tools, we respect that. Do your research. Test multiple platforms. Just know that not every comparison post is written in good faith. Some of them are just trying to steal traffic from brands they've never used.*

Most 'Bento alternative' posts are written by competitors who've never used us. Here's what they get wrong, and an honest take on when Bento is right for you.

Bento Alternative: The Truth About Other Review Posts

Compare Klaviyo vs Mailchimp for ecommerce. Find which platform delivers better automation, segmentation, and ROI for your online store's email marketing.

Klaviyo vs Mailchimp: Which Email Platform Fits Your Ecommerce Store?

Even in today's world of various different platforms, newsletters still beat social feeds for building real relationships with readers. But nobody wants recycled blog posts or stale sales pitches in their inbox. People stick around when you deliver a strong point of view, useful insights, and a consistent experience. This guide shows you how to plan, write, design, automate, and grow a newsletter worth reading, and how Bento makes the whole process faster for your team.

## TL;DR: Newsletter Launch Checklist

**Start with positioning.** Figure out who is your audience and what do you want to say to them. Pick a format that works for both you and your readers.

**Build a system you can stick to.** Plan your sections, schedule, and who does what. Get this sorted before issue one.

**Design for people who scan through emails.** Most people quickly skim emails without reading it throughout. This is why you need to use clear headings, short paragraphs, and make the most important points stick out. Keep in mind to build mobile-friendly layouts.

**Automate the boring stuff.** Bento is great for automation and it can help you set up workflows for scheduling, personalization, and triggered follow-ups based on reader behavior.

**Track what actually matters.** Monitor growth, engagement, and revenue. Your newsletter needs to support real business goals.

## Step 1: Define Positioning and Purpose

Fuzzy positioning kills newsletters. You need clarity on three things.

First, who is this for? Go deeper than job titles and basic information. Think about what your readers’ desire and what keeps them up at night. What are they trying to achieve? What pressures are they under? For example, if you're targeting ecommerce managers, they probably care about conversion rates, customer acquisition costs, and keeping up with platform changes, so this is something you want to refer to and offer them help with.

Second, what problem does it solve? This is where offering the help part comes in - your newsletter needs to help people do something better. Maybe you help them stay current on industry changes. Maybe you give them templates they can use right away. Or maybe you share tactics that actually work, not just theory.

Third, why should people read you instead of someone else? Create something that will make your newsletter stick out. You might have exclusive data nobody else shares. Or you might write from years of hands-on experience. Some newsletters win through curation, others through humor. Find what makes you different.

Write this down in one sentence. Here's an example: **"A weekly briefing for ecommerce operators who want proven retention tactics they can implement in under an hour."** That's clear. People know exactly what they're signing up for.

Your newsletter also needs to connect to business goals. Are you trying to get more product signups? Generate qualified leads? Keep customers engaged? Pick one main goal that is key for your business and growth. This is also something which will help you measure success later on.

## Step 2: Pick Your Format and Cadence
Consistency beats perfection. Pick something you can actually stick with.

**How often will you send?** Weekly works for most companies. Daily can work if you're aggregating news or have tons of content. Monthly is fine for deep analysis pieces. The key is setting clear expectations and meeting them. If you say weekly, send weekly. Missing issues breaks trust and can tank deliverability.

**How long should it be?** Short newsletters (500-800 words) work great for quick updates and curated links. Longer ones (1500+ words) work when you're teaching something or telling stories. Pick based on what your readers want, what suits your brand and what you can consistently produce.

**What sections will you include?** Repeatable sections save you time and help readers know what to expect. You might have a main story, three quick tips, and a resource of the week. Or maybe you lead with data, follow with analysis, and close with action items. Whatever you choose, stick with it.

**How will you write?** Decide on your voice early. Are you formal or casual? Do you use industry jargon or plain English? Write down examples of phrases you'd use and ones you'd avoid. This keeps your newsletter sounding consistent, even if multiple people write it.

Set up a template in Google Docs or Notion with your section headers already in place. You'll write faster when you're not starting from scratch every time.

## Step 3: Build Your Editorial Calendar
You don’t want to scramble your newsletter evening before sending, making it messy and unengaging. This is why you should always plan ahead.

Start by brainstorming topics for the next three months. Pull ideas from customer questions, support tickets, and keyword research. Look at your product roadmap for upcoming features to highlight. Check what competitors write about. Build a backlog organized by theme: how-to guides, case studies, product updates, customer stories.

Connect each topic to business goals. If you're launching a new feature next month, plan content that prepares people for it. If you're trying to reduce churn, focus on success stories and best practices. Every issue should serve a purpose beyond just filling inboxes. Keep also seasons and possible holidays in mind, as some of them may directly impact what you send and offer to readers.

If you have a team that deals with email marketing, make it clear who does what. Who writes the first draft? Who edits? Who approves? Who builds it in your email tool? When everyone knows their job, things move smoothly.

Work backward from your send date to set deadlines. Here's how the schedule of work on the newsletter should roughly look:

- **6 days before:** Topic approved, outline done
- **4 days before:** First draft complete
- **2 days before:** Edited and fact-checked
- **1 day before:** Built in Bento, images added
- **Send day:** Final review and hit send

Track everything in whatever tool your team already uses. Notion, Asana, Linear, even a spreadsheet works. Once your newsletter is live, use Bento's shared inbox to manage replies and collect feedback for future issues.

## Step 4: Write Value-Driven Content
Respect your readers' time. Give them something useful right away.

Your opening lines matter most. Skip the small talk. Tell readers what they'll learn and why it matters. If your newsletter is about email marketing, don't start with "Email marketing is important." Start with "Here's how Company X doubled their conversion rate with one simple email change."

Focus on one main idea per issue. You might touch on other topics, but everything should support your central point. This makes your newsletter easier to remember and act on.

Keep in mind that stories stick better than advice. Instead of saying "personalization improves open rates," share how a specific company personalized their emails and what happened. Use real numbers when you can, show screenshots and make it concrete.

It’s good also to give readers something they can use immediately, such as templates they can copy or step-by-step instructions. People subscribe to newsletters that make their job easier.

Link to helpful resources, but don't overdo it. Include links to your own content when it genuinely helps (like our guides on [email marketing funnels](/email-marketing-funnels) or [lead magnets](/lead-magnets)), but too many links make emails feel like ads and it can influence deliverability.

End with a clear next step. What do you want readers to do? Reply with feedback? Try a tactic? Book a demo? Pick one action and make it obvious.

## Step 5: Design for Readability and Brand Consistency
Email clients are weird and each is different. Gmail displays things differently than Outlook, dark mode can mess up design, and mobile layout can look completely different than desktop one. This is why you want your design to be simple and effective.

Stick to single-column layouts - they work better on phones, and most people read email on their phones. Two-column designs might look fancy, but they often break on small screens.

Fonts that you use must work for everyone. This means you want to use some of the system fonts, like Arial, Georgia, or Helvetica.  Custom fonts might not load, leaving your carefully designed email looking broken. Make sure there's enough contrast between text and background - light gray text on white backgrounds is hard to read.

Headings are really important as they not only help email look good, but make it more readable. As most of the readers scan emails for the important information, this will make it easier for them. Add white space between sections and include bullet points for lists. Drop in divider lines to separate topics. Make it easy for someone to skim and still get value.

Images should load fast, so compress them before uploading. Always add alt text that describes what the image shows as this helps when images don't load and makes your emails accessible to people using screen readers. Test how your email looks with images turned off, because some email clients block them by default.

Include your logo, use your brand colors, but don't sacrifice readability for style. A plain text email that's easy to read beats a beautiful one that's confusing. For those information that you put in all emails, Bento's editor lets you save content blocks you use often. Build your header once, save it, and reuse it every week. Same for footers, dividers, and any sections you repeat. This keeps your design consistent and saves time.

## Step 6: Set Up Bento Automations
Automation makes your newsletter reliable without extra work, so you definitely want to use this feature of Bento. You can start by building your newsletter template. We offer different tools for designing emails, so you can use the visual builder if you prefer drag-and-drop, or paste in HTML if you've coded a template. Add placeholders for any content that changes week to week.

Personalization goes beyond "Hi {{ visitor.first_name }}." Use merge tags to mention their company, reference their plan type, or include location-specific content. Set up conditional blocks to show different sections to different people. Customers might see advanced tips while trial users see upgrade prompts.

Segment your list to send the right version to the right people. For example, your paying customers probably want different content than your free users. New subscribers might need more context than longtime readers. Build these segments in Bento and send tailored versions automatically.

New subscribers will usually need special attention. Set up a welcome sequence that triggers when someone signs up. This should include your best past issues and explanation what to expect. Ask them to reply with what they want to learn about. Check out our [email sequence guide](/email-sequences) for templates.

Timing also matters for engagement. Some people read emails at 6 AM, others at lunch, others late at night. Bento can track when each subscriber engages and automatically send at their best time, simply pick a standard time based on your overall engagement data.

Don't let replies disappear into the void. Route them to your shared inbox so your team can respond. Reader replies are gold for understanding what resonates and what doesn't.

Compliance is also an important part, but this is covered by Bento! Our platform automatically includes unsubscribe links and manages preference centers. It syncs suppression lists across all your campaigns so you never accidentally email someone who opted out.

## Step 7: Launch and Grow Your Audience
If no one reads your newsletters, you might as well keep a diary - therefore, take some time to build your following and get subscribers. 

You want to have a dedicated landing page for signups. This is beside the form on the homepage, which is not enough. Create a page that explains exactly what subscribers get, show sample content and include testimonials from current readers. Make the value crystal clear.

In order to get people to subscribe, offer something valuable upfront. People need a reason to hand over their email address. For example, if you write about email marketing, you can offer an email template pack. Deliver it through Bento and mention your newsletter in the follow-up. Our [lead magnets guide](/lead-magnets) has more ideas.

The signup forms need to be somewhere where people will see them, such as your most popular blog posts and at the end of the relevant content. You also must share newsletter snippets on social media.  If you create carousel posts for Instagram, mention that there is more to be learned in the newsletter and explain where they can sign up. Don't give everything away on social media, or there's no reason to subscribe. When subscribers sign up, tag them based on where they signed up so you can send relevant content.

Partner with other newsletters in your space. Find ones with similar audiences but different angles. Recommend each other's newsletters and run cross-promotions. Sponsor relevant newsletters to get in front of their readers.

If people share your newsletter, reward them for it. This can be done through tricks such as exclusive content or early access for the referral. You can create a community for your most engaged readers as well.  This will make subscribers which you have share a newsletter and do marketing for you, additionally engaging with the content. 

Test paid ads if you have a budget. Target people interested in your topic and track performance by tagging subscribers with their source in Bento. However, make sure you are calculating the lifetime value to see if ads pay off in order not to waste money.

If you have a product, you must promote your newsletter there. This means adding a signup prompt to your app and including it in onboarding emails. Your existing users are often your best subscribers as they are already interested in your product.

## Step 8: Measure Performance and Iterate
Metrics are not the only goal you want to achieve - you need to measure business results as well.  This can be achieved by a few tactics. 

**Track growth beyond just total subscribers.** Where are people signing up? Which sources bring the most engaged readers? What's your landing page conversion rate? Understanding these patterns helps you focus on what works and develop it more.

**Engagement tells you if people actually read your content.** Open rates are a start, but click-through rates matter more. To track this, you need to look at which links people click and check how many people reply. You also need to follow how many subscribers become customers. See if newsletter readers have higher lifetime values and whether engaged readers renew more often. Bento's click maps show exactly where readers engage, and this features will help you to gather data that explains what works.

What also matters is if your readers forward emails - this means your content is share-worthy and that it had even bigger reach. Whatever you are doing, you are doing it well! These soft metrics often predict future growth.

**Watch quality indicators.** High unsubscribe rates mean something's wrong and spam complaints can hurt your deliverability. If these numbers spike, figure out why immediately, You can even ask support to help you out where things went wrong. Maybe you're sending too often or maybe your content shifted. Whatever it is, it indicates a problem that needs fixing. 

Set up a simple dashboard in Bento to track these numbers. Review growth and engagement weekly and do a deeper analysis monthly. You always need to look for trends, not just snapshots as it shows the wider picture. Keep also in mind that when you test something, you do it one thing at a time so you know what actually moves the needle.

## Step 9: Keep the Operation Tight
As you might realize by now, you want to stay organized when it comes to newsletters. In order to have a good overview of things, you need to document everything in a shared space your team can access. Write down your production workflow step by step, create a style guide with voice examples and list your QA checklist. This will ease the process for you and your team, but also help you a lot if someone new joins as they can pick up things quickly.

Good idea is to build a library of reusable assets. Save email templates for different types of content and keep a swipe file of great subject lines. Store design blocks for common sections. The more you can reuse, the faster you'll produce each issue.

There also needs to be a clear review process. Too many reviewers slows everything down.  Everyone needs to know exactly what they are supposed to do and no step should be skipped.Find the right balance for your team.

Always stay ahead of schedule. Good practice is to have two issues written before you need them. This buffer saves you when someone gets sick, holidays hit, or news breaks. You also want to double check facts, data, links and images you are using, as well as their sources, The mistakes happen, but they can damage trust and it is hard to rebuild. 

When you finish all and send out newsletter, you need also to keep in mind that responses of your readers matter This is why you also want to ask them what they think. Good practice is to send a survey every few months asking about topics, frequency, and format. Set up automated NPS surveys in Bento to track satisfaction over time and use this feedback to improve.

## Newsletter QA Checklist
Run through this before you hit send. Every time.

- [ ] Subject line matches the content (no bait and switch)
- [ ] Preview text adds value (not just repeating the subject)
- [ ] All links work and include tracking parameters
- [ ] Personalization has fallback values (no "Hi ," appearing)
- [ ] Images are compressed and include descriptive alt text
- [ ] Email looks good in dark mode
- [ ] Mobile preview looks right (most people read on phones)
- [ ] Desktop preview works in Outlook, Gmail, and Apple Mail
- [ ] Text has enough contrast to read easily
- [ ] Unsubscribe link works and is easy to find
- [ ] Physical address appears in footer (legally required)
- [ ] Key stakeholders have reviewed and approved
- [ ] Test email sent to your seed list
- [ ] Copy saved in your archive for future reference

## Ready to Ship Your Newsletter with Bento?
A good newsletter becomes your most reliable marketing channel. It works when you nail the positioning, respect readers' time, and keep making it better based on data.

Bento handles the technical side so you can focus on content. We give you the automation tools to send consistently, the segmentation features to personalize without extra work and the analytics to see what resonates. Most importantly, we have a high deliverability infrastructure that will make your emails actually reach inboxes.

You bring the ideas and voice and we'll handle the workflows that make it sustainable. [Start building your newsletter in Bento today](https://bentonow.com/signup), or [book a call](https://bentonow.com/demo) if you want help planning your newsletter strategy.


Plan, write, and ship a high-performing newsletter with Bento, covering strategy, content, design, automations, and growth.

How to Create a Newsletter That Readers Love

We're excited to announce that we have successfully achieved **SOC 2 Type II compliance**, demonstrating our commitment to maintaining the highest standards of security and data protection for our customers.

## What is SOC 2?

SOC 2 (System and Organization Controls 2) is a compliance framework developed by the American Institute of Certified Public Accountants (AICPA) that evaluates an organization's information systems relevant to security, availability, processing integrity, confidentiality, and privacy.

A SOC 2 Type II report specifically assesses the effectiveness of these controls over a defined period, providing assurance that our security practices are not just designed well, but are operating effectively.

## Our SOC 2 Journey with OneLeet

We partnered with [OneLeet](https://oneleet.com) to streamline our SOC 2 compliance journey. Their platform helped us implement robust security controls and prepare for the audit process efficiently.

Our SOC 2 Type II audit was successfully completed with **zero exceptions**, covering our systems and controls over a 12-month observation period.

## What This Means for You

This certification reinforces our commitment to:

- **Data Security**: Your data is protected by enterprise-grade security controls
- **Reliability**: Our systems are monitored and maintained to ensure consistent availability
- **Privacy**: We handle your information with the utmost care and in compliance with best practices
- **Transparency**: Our security practices are independently verified and documented

## Obtaining Our SOC 2 Report

Current and prospective customers can request a copy of our SOC 2 Type II report by contacting our security team. We're also happy to complete any security questionnaires you may have.

## Looking Forward

Achieving SOC 2 Type II compliance is not a destination but a continuous journey. We remain committed to maintaining and improving our security posture to earn and keep your trust.

As we continue to grow and serve more customers, security will remain at the core of everything we do. This certification is just one of many steps we're taking to ensure we can be your trusted partner for years to come.

---

**Have questions about our SOC 2 compliance or need to request our report?** Contact our security team at support@bentonow.com.

We're excited to announce that Bento has successfully completed a SOC 2 Type II audit to further demonstrate our commitment to security.

SOC-2

Bento is now SOC 2 Type II Compliant

SendGrid is the vanilla ice cream of email service providers. Fine, you'll have it for dessert if it's all that's being served. But it's not your favourite and given any other option you wouldn't bother. 

The good news is you have options: cheaper options, options with better transactional email deliverability, options that handle transactional and marketing emails in a better way. This guide breaks down the alternatives worth considering and helps you pick the right one.

## TL;DR: Quick Picks by Use Case

If you need to pick fast, here's what each service does best:

**Bento** - Good for apps that need deliverability tools built in. You get API access, SMTP, reputation monitoring, and batching controls. Usually costs less than SendGrid.

**Mailgun** - Built for sending lots of emails. Has tracking tools, SDKs for every language, and enterprise features. Costs about the same as SendGrid.

**Postmark** - When your transactional emails absolutely have to arrive fast. Emails land in seconds. Keeps marketing separate from transactional. Costs more but worth it for critical emails.

**Amazon SES** - Cheapest option if you're on AWS - pay 10 cents per 1,000 emails. Takes more work to set up but saves money at scale.

**Resend** - Clean, modern API that developers actually enjoy using. Great docs, easy integration. Newer service but growing fast.

**What to watch out for:** Some services only do transactional email (Postmark). Others do both marketing and transactional (Bento, Mailgun). SES saves money but needs more setup. Pick what fits your situation.

For more on transactional email, read our [best transactional email services](/posts/best-transactional-email-services) guide. To understand deliverability better, see [email deliverability tools](/posts/email-deliverability-tools).

## Why Look for SendGrid Alternatives?

SendGrid works, but it has issues. Here's why people switch:

**Price goes up fast.** SendGrid starts at $19.95/month for 50,000 emails. That jumps quickly as you grow. Amazon SES costs 75% less. Bento often beats SendGrid's pricing too.

**Emails land in spam.** SendGrid shares IP addresses between customers. If someone else sends spam, your reputation suffers. Services like Postmark and Bento handle deliverability better.

**Jack of all trades, master of none.** SendGrid does both transactional and marketing email. But it's not great at either. Postmark beats it for transactional. Marketing platforms beat it for campaigns.

**Developers don't love it.** The API works, but it's not fun to use. Documentation could be clearer. Services like Resend and Bento make integration easier.

SendGrid does the job. But you might find something that fits better. Price, deliverability, features, developer experience. Pick what matters most to you.

## How SendGrid Alternatives Compare

### Pricing

**Note on Bento:** Unlike the others, Bento charges by **contact (subscriber)**, not by the number of emails sent. You can send unlimited emails to your contacts. The price listed below assumes you have 3,000 contacts or fewer (the minimum tier).

| Provider | Free Tier (Monthly) | Starting Paid Plan | Cost for ~50,000 Emails | Best For |
| :--- | :--- | :--- | :--- | :--- |
| **Bento** | 30-day free trial | $30/mo (up to 3k contacts) | **$30.00*** | CRM & Automation |
| **Amazon SES** | 3,000 emails (for 12 mos) | Pay-as-you-go | **$5.00** | Lowest absolute price |
| **Resend** | 3,000 emails | $20/mo (includes 50k) | **$20.00** | Developer Experience (DX) |
| **Mailgun** | 5,000 emails (1 mo trial) | $15/mo | **$35.00** | High Volume & Analytics |
| **Postmark** | 100 emails (Developer) | $15/mo (10k emails) | **$55.00** | Speed & Deliverability |

### Bento: Email API with Deliverability Built In

![bento](//images.ctfassets.net/7154jijfbyeo/UkmTILUGISwVjk5ISQmdH/07c24a1df56806a53574e959142956e4/bento.png)

**Who it's for:** Apps that need emails to actually reach the inbox.

**What makes it different:** Most email services just send your emails. You handle deliverability yourself. Bento includes the tools you need: authentication setup, reputation monitoring, batching controls. All in the base price.

The API works with all major languages. Transactional emails stay separate from marketing emails, so one doesn't hurt the other's reputation.

**Pricing:** You pay $0.01 for users/contacts you store, starting with $30.

**Pick Bento if:** You want deliverability tools included. You're tired of emails landing in spam. You want to pay less than SendGrid without sacrificing features.

**Stick with SendGrid if:** You're already deep into their platform. You need a specific SendGrid feature that Bento doesn't have.

### Mailgun: Built for Big Senders

![mailgun-by-sinch](//images.ctfassets.net/7154jijfbyeo/3Cncb1R8f2GX0hpnoMrXx4/44ffa67076392903deaff9800f139a6e/mailgun-by-sinch.png)

**Who it's for:** Companies sending millions of emails daily.

**What makes it different:** Mailgun handles massive volume without breaking a sweat. SDKs for every language (Node.js, PHP, Go, Java, Ruby). Tracking tells you everything: who opened, who clicked, what bounced.

The API handles errors well. Documentation actually helps. Analytics show exactly how your emails perform.

**Pricing:** About the same as SendGrid, it starts at $15/month for 10,000 emails to start. Since price is similar, pick based on features.

**Pick Mailgun if:** You send tons of email, you need detailed tracking, you want SDKs for multiple languages.

**Stick with SendGrid if:** You like SendGrid's interface better. The services are similar enough that switching might not be worth it.

### Postmark: When Speed Really Matters

![postmark-by-activecampaign](//images.ctfassets.net/7154jijfbyeo/yOaVs2BuyI1HaHB2b3B3X/0b4e12fd1a9ce8aaadd246986eb7b451/postmark-by-activecampaign.png)

**Who it's for:** Apps where slow emails hurt the business.

**What makes it different:** Postmark only does transactional email. No marketing. This focus means emails arrive in seconds, not minutes. Uptime is incredible. Your password resets and order confirmations stay separate from marketing campaigns.

Clean API that works. Good docs. Libraries for Rails, Ruby, .NET, Java, PHP, and Node.js.

**Pricing:** Costs  $15/month for 10,000 emails. But remember, this is just for transactional - you'll need another service for marketing.

**Pick Postmark if:** Your transactional emails are critical - a delayed password reset means lost customers. The extra cost is worth the reliability.

**Stick with SendGrid if:** You want one service for everything. You can't justify the higher price for speed.

### Amazon SES: Cheap If You're Technical

![amazon-ses](//images.ctfassets.net/7154jijfbyeo/q9JJNhn6ZZxvnabpZ7H9L/218f6cdd9b224eeb68e1e6c0f257d027/amazon-ses.png)

**Who it's for:** AWS users who can handle setup themselves.

**What makes it different:** SES costs way less than anything else. Ten cents per 1,000 emails. No monthly fees. First year gives you 3,000 free emails monthly.

If you use AWS already, SES fits right in. CloudWatch for monitoring. Lambda for automation. Everything connects.

**Pricing:** SendGrid charges $19.95 for 50,000 emails. That's 40 cents per 1,000. SES costs 10 cents per 1,000. Four times cheaper.

**Pick SES if:** You're on AWS. You know your way around infrastructure. You want the lowest price possible.

**Stick with SendGrid if:** AWS confuses you. You want someone else to handle the technical stuff. You need features SES doesn't have.

### Resend: Built for Developers

![resend](//images.ctfassets.net/7154jijfbyeo/454lXLKBxSAN80lcutw82W/73f481177c8794f84510cd5316ffd209/resend.png)

**Who it's for:** Developers who care about good APIs.

**What makes it different:** Resend feels modern. The API makes sense. Documentation actually helps. Integration takes minutes, not hours.

You get templates, webhooks, and solid delivery. It's newer than the others, but developers like it.

**Pricing:** Similar to SendGrid. Free tier exists. Paid plans start around $20/month.

**Pick Resend if:** You want an API that's actually nice to use. You value developer experience over having every possible feature.

**Stick with SendGrid if:** You need specific enterprise features. You prefer established services with longer track records.

## Key Differences: SendGrid vs Alternatives

Here's how they stack up:

**Price:** Amazon SES costs 75% less at scale. Bento usually beats SendGrid too. Postmark and Mailgun cost about the same.

**Getting to the inbox:** Postmark wins for transactional email delivery. Bento includes tools to help. Mailgun does well. SendGrid is okay but nothing special.

**Features:** Mailgun has the most enterprise stuff. Postmark focuses only on transactional. Bento includes deliverability tools. SendGrid tries to do everything.

**Developer happiness:** Resend has the best API. Bento's docs are solid. Mailgun is powerful but complex. SendGrid works but feels dated.

Each service does something well. Pick based on what you need most.

## Migration Considerations

Switching from SendGrid? Here's what to expect:

**You'll need to update your code.** Every service has a different API. Plan a few days for updating and testing. Most services have migration guides to help.

**Not every feature will exist.** Check that your must-have SendGrid features exist in the new service before switching.

**Do the math first.** Pricing structures vary. Some charge per email, others per contact. Calculate your actual costs before committing.

**Your delivery might dip temporarily.** When you switch, email providers need time to learn your new sending patterns. Watch your metrics closely for the first few weeks.

Migration takes work but it's doable. Most companies can switch in a week or two with proper planning.

## Where Bento Fits: SendGrid Alternative with Deliverability Built In

Thinking about switching from SendGrid? Here's what Bento offers.

**Email API that works.** Send emails from your code with our REST API. Get webhooks for delivery events. SDKs for all major languages. Works just like SendGrid but often easier to implement.

**SMTP too.** Need SMTP? We have servers ready. Port 587 with STARTTLS. Authenticate with API keys. Drop it into your existing mail setup.

**Deliverability tools included.** Other services make you figure out deliverability yourself. We include authentication setup, reputation monitoring, and batching controls. No extra charges. No separate tools to buy.

**Better pricing for most.** You pay for emails sent, not contacts stored. As you grow, this saves money compared to SendGrid's model.

**Pick Bento if:** You want deliverability tools without extra cost. You're tired of emails landing in spam. You want to pay less than SendGrid.

**Stay with SendGrid if:** You need specific SendGrid features we don't have. You're too deep in their ecosystem to switch easily.

We're not trying to be SendGrid. If SendGrid works for you, great. But if you want better deliverability tools and pricing, we can help.

## Ready to Choose Your SendGrid Alternative?

First, figure out what matters most. Is it price? Getting emails delivered? Features? Developer experience? Once you know that, picking gets easier.

Run the numbers. Calculate what each service costs at your volume. SES wins on price. Bento often beats SendGrid. Postmark and Mailgun cost about the same.

Think about deliverability. Postmark is best for transactional. Bento includes the tools you need. Mailgun does well. SendGrid is average.

Check the features you actually use. Mailgun has enterprise features. Postmark only does transactional. Bento includes deliverability tools. SendGrid tries to do it all.

Try before you buy. Most services have free trials. Test the API. Send some emails. See what works.

**More guides:** Read our [best transactional email services](/posts/best-transactional-email-services) comparison. Learn about [email deliverability tools](/posts/email-deliverability-tools). Compare [SMTP email services](/posts/best-smtp-email-services).

The right SendGrid alternative depends on your needs. Consider price, deliverability, features, and developer experience. If you want to learn more about Bento, [reach out](https://bentonow.com).

Find SendGrid alternatives for email sending. Compare email API services, SMTP providers, and platforms that offer better pricing, features, or deliverability.

SendGrid Alternatives: Compare Email API Services

Data breach notification. Product recall. Legal notice. Sometimes you have to email everyone, including people who unsubscribed years ago.

You need to send these high-stakes, legally mandated emails without destroying your sender reputation. This guide follows [M3AAWG's industry best practices](https://www.m3aawg.org/SendingMandatedEmailsBP) to get you through it.

## Quick Summary: What You Need to Know

Mandated email essentials:
- Coordinate with your ESP before you send anything (that means us as Bento). 
- Use separate infrastructure that keeps risk away from production traffic.
- Authenticate every message with SPF, DKIM, DMARC, and TLS.
- Keep content short and free from marketing language.
- Never spin up a brand-new domain for this work.

Mandated emails break every email marketing rule. You have to send them by law, even to people who hate getting emails from you. Get this wrong and your reputation suffers for months. Get it right and you minimize the damage.

**The golden rule:** Treat mandated emails as emergency communications, not marketing opportunities.

## What Are Mandated Emails?

Mandated emails are messages you're legally required to send, even though they'll perform poorly. Think of them as emergency broadcasts for email.

### Common Types of Mandated Emails

Breach notifications with language such as "Your data may have been compromised". Product recalls sent as "Stop using this product immediately". Privacy policy changes that say "New legal requirements affect you". Health and safety notices that share important safety details. Account security alerts that warn about suspicious activity.

### When You Must Send to Everyone

These situations override normal email preferences. Data breaches that require notification by law. Product recalls affecting consumer safety. Court-ordered communications. Regulatory compliance notifications. Emergency safety alerts.

When Equifax was breached in 2017, they had to notify all affected customers, including those who had opted out of marketing emails years earlier. That's the reality of mandated emails.

## Why Mandated Emails Are Risky

These emails perform poorly for obvious reasons. Recipients don't recognize you anymore. The content sounds urgent or scary. You're emailing addresses that haven't been active in years. People panic and hit the spam button. Legal language confuses recipients.

The reputation damage compounds quickly. Gmail and Outlook see your volume spike suddenly. They notice you emailing users who previously reported you as spam or unsubscribed. High bounce rates signal poor list hygiene. Spam complaints hurt your future deliverability. Your regular marketing emails suffer for months afterward.

## Before You Send: Critical Preparation

### Step 1: Notify Mailbox Providers First

Contact ISPs before sending anything. Look at your email list and figure out which providers will get the most emails. Contact each one and tell them you're sending a mandated email. Ask them to whitelist your domain and IP for the campaign duration.

Contact these postmaster addresses:
- Gmail: `postmaster@gmail.com`
- Yahoo: `postmaster@yahoo.com`  
- Outlook: `postmaster@outlook.com`
- Major ESPs: Check their postmaster pages

Send them something like this:
```
Subject: Advance Notice: Mandated Email Communication - [Your Company]

Dear Postmaster Team,

[Your Company] is required to send a mandated email notification regarding [breach/recall/legal notice] to our entire user base on [date].

Details:
• Sending volume: [X emails over Y days]
• Sending infrastructure: [IP ranges/domains]
• Reason: [Legal requirement/safety notice]
• Content: [Brief description, sample attached]

We understand this may result in elevated complaints and bounces. We are following M3AAWG best practices for mandated communications.

Please let us know if you can whitelist our domain/IP for the duration of the email campaign.

Contact: [Your email and phone]
```

### Step 2: Set Up Dedicated Infrastructure

Never use your regular marketing setup for mandated emails. Create a new subdomain like `legal.yourcompany.com` or `security.yourcompany.com`. Talk to your ESP about using a separate IP pool if possible. Set up dedicated authentication with SPF, DKIM, DMARC, and TLS. Prepare for bounce rates that are much higher than normal. Most importantly, send as slowly as you possibly can.

Separate infrastructure matters because it isolates reputation damage from your regular sending. It makes tracking easier. It prevents cross-contamination between mandated and marketing emails. It signals to ISPs that this isn't regular marketing.

### Step 3: Configure Authentication (Essential)

Authentication is non-negotiable for mandated emails. Set up SPF to include your sending IPs. Sign all messages with DKIM. Set a strict DMARC policy. Enable TLS for security.

Your authentication might look like this:
```
notices.yourcompany.com:
SPF: "v=spf1 include:_spf.yourcompany.com ~all"
DKIM: Selector: mandated._domainkey
DMARC: "v=DMARC1; p=reject; rua=mailto:dmarc@yourcompany.com"
```

## Content Guidelines: Less Is More

### Subject Line Best Practices

Clear, honest subject lines work best. Try something like `Important Security Notice from [Company Name]` or `[Company Name]: Required Safety Information` or `Action Required: [Company Name] Account Security`.

Avoid subject lines that scream spam. Skip the all-caps `URGENT: IMMEDIATE ACTION REQUIRED!!!` approach. Don't write `You've Been Breached - Click Here Now`. Never use `Final Notice` when it's actually the first notice.

### Email Body Guidelines

Keep the email body minimal and factual:

```
From: Company Name Security Team <notices@company.com>
Subject: Important Security Notice from Company Name

Dear [Name/Customer],

We are required to notify you that [clear explanation of situation].

What happened: [Brief, factual description]
What we're doing: [Steps being taken]  
What you should do: [Clear instructions]

For more information, log into your account at company.com 
or call us at 1-800-XXX-XXXX.

Sincerely,
Company Name Security Team

This is a required notification. You are receiving this regardless
of your email preferences due to [legal requirement/safety concern].
```

Follow these content rules strictly. No marketing content whatsoever. Use minimal tracking pixels. Limit links to essential destinations only. Stick with plain text or simple HTML. Include a clear reason for sending the email.

## Sending Strategy: Slow and Steady

### Volume Management

Spread your sends over multiple days or even weeks. Start with the most engaged users on day one. Send to active subscribers on day two. Reach the rest of your valid addresses on day three. Hold previously bounced addresses until day four or later, and only email them if the law requires it.

If possible, spread the send over a month. This prevents volume spikes with any single ISP. When you must send quickly, prioritize engaged lists first. Then spread inactive lists over several weeks.

Slow sending works because it reduces ISP alarm bells. You have time to monitor and adjust. You can respond to issues as they arise. The reputation impact spreads out instead of hitting all at once.

### Audience Segmentation

Send to your audiences in this order. Start with current customers since they're most likely to expect emails from you. Move to active subscribers who have engaged recently. Then inactive subscribers with no recent engagement. Follow with unsubscribed users who opted out but still need notification. Finally, send to previously bounced addresses only if legally mandated.

## Managing the Aftermath

### Monitor Everything

Watch these key metrics closely. Expect bounce rates 10-30% higher than normal. Complaint rates might hit 2-5 times your usual rate. Track delivery rates by ISP. Monitor support ticket volume.

Set up alerts for critical thresholds. Alert when complaint rate exceeds 1%. Alert for bounce rates over 15%. Watch for delivery failures to major ISPs. Check for blacklist additions immediately.

### Damage Control

If things go wrong, follow this timeline. Stop additional sends within the first hour if you can. Contact the affected ISPs during hour two. Assess reputation damage on day one. Adjust future sending practices during week one. Resume normal sending gradually in month one.

Common issues have straightforward fixes. High bounce rates mean you need to clean your list for future sends. Spam complaints require clearer explanations in future emails. Blacklist issues need direct contact with operators. Most are reasonable about delisting when you explain the situation professionally. Delivery blocks require working with ISP postmaster teams.

## Real-World Examples

### ✅ Good: Financial Institution Breach Notice

```
From: "SecureBank Security Team" <security@securebank.com>
Subject: Important Security Update from SecureBank

Dear Account Holder,

We are required by law to notify you of a security incident 
that may have affected your account information.

What happened: On [date], we discovered unauthorized access 
to our customer database.

What was accessed: Names, email addresses, phone numbers. 
No financial information or account numbers were accessed.

What we're doing: We've secured the vulnerability, contacted 
law enforcement, and are providing free credit monitoring.

What you should do: 
1. Monitor your accounts for suspicious activity
2. Consider changing your online banking password
3. Call us at 1-800-XXX-XXXX with questions

Visit securebank.com/security-update for detailed information.

This notification is required by state and federal law. You are 
receiving this regardless of your communication preferences.
```

This works because it has clear sender identification. The tone is factual, not alarmist. It provides specific information. Next steps are clear. It explains why everyone received it.

### ❌ Bad: Tech Company "Emergency" Update

```
From: "TechCorp URGENT" <emergency@newdomain-tech.com>
Subject: CRITICAL: Your Account is at RISK!!!

ATTENTION ALL USERS!!!

YOUR ACCOUNT MAY BE COMPROMISED! CLICK HERE IMMEDIATELY 
to secure your information before it's too late!

We've discovered a MASSIVE security breach and need you 
to ACT NOW! Don't wait - CLICK THE LINK BELOW:

>>> SECURE MY ACCOUNT NOW <<<
(Goes to suspicious-looking domain)

This is an EMERGENCY communication! Forward to friends!
```

This fails spectacularly. It looks exactly like phishing or spam. The new domain raises immediate suspicion. All caps creates unnecessary panic. The links look suspicious. There's no clear company identification.

## Advanced Strategies for Large Organizations

### Multiple Communication Channels

Email shouldn't be your only channel for mandated communications. Use website banners prominently. Send SMS notifications to verified numbers. Mail postal letters for serious breaches. Post on social media channels. Work with traditional media for major recalls.

### Risk-Based Segmentation

Tailor your approach based on user risk level:

High-risk users are the people who have been active recently. Email them immediately with minimal content. Medium-risk users are inactive but still valid. Email them with added context and explanations. Low-risk users are long inactive or have bounced. Consider alternative communication methods for them.

### Legal Coordination

Your legal team needs to be involved throughout the process. They'll help with required language and disclaimers. They know timing requirements by jurisdiction. They'll ensure proper documentation for compliance. They can suggest alternative communication methods when appropriate.

## Tools and Resources

### Email Authentication Checkers
- [AboutMyEmail](https://aboutmy.email/): Complete email testing
- [MXToolbox](https://mxtoolbox.com/): DNS and blacklist checking
- [DMARC Analyzer](https://www.dmarcanalyzer.com/): Authentication monitoring

### M3AAWG Resources
- [M3AAWG Best Practices for Sending Mandated Emails](https://www.m3aawg.org/SendingMandatedEmailsBP)
- [M3AAWG Sender Best Common Practices](https://www.m3aawg.org/documents/en/m3aawg-sender-best-common-practices-version-30)
- [M3AAWG Email Authentication Best Practices](https://www.m3aawg.org/sites/default/files/m3aawg-email-authentication-recommended-best-practices-09-2020.pdf)

## Implementation Checklist

### ✅ Pre-Send Checklist

Technical setup needs to be perfect. Configure your dedicated subdomain. Set up SPF, DKIM, and DMARC. Enable TLS on sending servers. Arrange a separate IP pool if available.

Coordination prevents surprises. Consult your legal team early. Notify ISPs at least 48 hours ahead. Prepare your support team for inquiries. Have alternative communication channels ready.

Content must be clear and minimal. Write a factual subject line. Include only essential content. Remove all marketing or promotional content. Clearly explain why you're sending the email. Include multiple contact methods.

### ✅ During Send Checklist

Monitor everything in real-time. Watch delivery rates constantly. Set bounce and complaint rate alerts. Track support ticket volume. Check ISP delivery status frequently.

Manage volume carefully. Spread sending over multiple days. Send to priority audiences first. Keep pausing capability ready. Adjust throttling as needed.

### ✅ Post-Send Checklist

Assess the damage honestly. Analyze final delivery and bounce rates. Measure reputation impact across ISPs. Check blacklist status immediately. Maintain ISP relationships.

Plan your recovery strategy. Adjust regular sending schedule. Complete thorough list cleaning. Document lessons learned. Plan process improvements for next time.

## The Bottom Line

Mandated emails are necessary but painful. You can't avoid sending them. You can minimize damage by treating them as emergency communications, not marketing. Coordinate with ISPs before sending. Use separate infrastructure to isolate impact. Keep content minimal and factual. Monitor everything and respond quickly.

The goal isn't perfect deliverability. It's getting legally required information to people while minimizing long-term reputation damage.

When in doubt, choose transparency and simplicity. Your recipients' safety matters more than your open rates.

---

*Based on M3AAWG Best Practices for Sending Mandated Emails to Large Audiences. For the latest guidance, visit [www.m3aawg.org](https://www.m3aawg.org/SendingMandatedEmailsBP).*

Data breach? Product recall? Legal notice required? Sometimes you have no choice but to email everyone—including people who unsubscribed years ago. Here's how to send those high-stakes, legally mandated emails without tanking your sender reputation.

How to Send Mandated Emails Without Destroying Your Reputation

If you send bulk email to Outlook, Hotmail, or Live.com, Microsoft has new rules starting May 5, 2025. If you miss them, your emails will struggle to reach inboxes. Some may be rejected.

## Quick Summary: What's Happening?

Starting **May 5, 2025**, Microsoft will reject emails from bulk senders, 5,000 or more per day, that do not meet authentication requirements. This affects anyone sending to:
- @outlook.com
- @hotmail.com  
- @live.com

**The good news:** If you already comply with Gmail and Yahoo rules from 2024, you are close. Only a few Microsoft-specific tweaks are needed.

**The great news for Bento customers:** We already have this covered. Open the DNS dashboard and confirm your records are green.

## Why This Matters

Email authentication is like showing ID at a secure building. Without it, you do not get in. From May 5, Microsoft will enforce this strictly.

**If you ignore this:**
- Your emails get rejected with error: `550; 5.7.515 Access denied`
- Your customers don't receive important emails like password resets, order confirmations, or marketing emails
- Your email reputation suffers
- You lose revenue from failed email campaigns

## Who This Affects

You are a bulk sender if you send **5,000 or more emails per day** to Microsoft consumer domains. This includes:

- **All emails from your domain count together.** If marketing@company.com sends 3,000 and support@company.com sends 2,500, that is 5,500 total.
- **Bounced emails count too.** Failed deliveries still add to your total.
- **Business emails like company@microsoft365.com are not affected** yet.

### Real Example:
An e-commerce company with multiple departments:
- Marketing team: 2,000 emails/day
- Order confirmations: 1,500 emails/day  
- Customer support: 1,000 emails/day
- Abandoned cart reminders: 800 emails/day
**Total: 5,300 emails/day = bulk sender**

## The Requirements: Explained Simply

### 1. SPF (Sender Policy Framework)
**What it is:** A list of servers and IPs allowed to send email for your domain.

**Think of it like:** A guest list at an exclusive party. If Microsoft does not see your server on the list, you do not get in.

**What you need to do:** Update your SPF record to include every provider that sends email for you. 

**For Bento customers:** If you added your DNS records, this is already handled. Our setup will not clash with your existing SPF record.

### 2. DKIM (DomainKeys Identified Mail)  
**What it is:** A digital signature proving your email hasn't been tampered with.

**Think of it like:** A wax seal on a letter. If the seal is broken, someone tampered with it.

**What you need to do:** Set up signing keys in your DNS and configure your email system to sign messages.

**For Bento customers:** If you added your DNS records, this is already handled. 

### 3. DMARC (Domain-based Message Authentication)
**What it is:** Instructions telling Microsoft what to do if your email fails SPF or DKIM.

**Think of it like:** Instructions to the bouncer: "If someone claims to be from my company but isn't on the list, don't let them in."

**What you need to do:** Create a DMARC policy with at least p=quarantine that aligns with SPF or DKIM.

## Timeline: Mark Your Calendar

```
📅 May 5, 2025
├─ Authentication requirements enforced
├─ Non-compliant emails REJECTED (not just filtered)
└─ Error: 550; 5.7.515 Access denied

⏰ NOW
└─ Start preparing immediately
```

## Step-by-Step Compliance Checklist

### ✅ Step 1: Check Your Current Status
Use free tools to verify your authentication:
- [AboutMyEmail](https://aboutmy.email/)
- [DMARC Analyzer](https://www.dmarcanalyzer.com/)
- [MXToolbox](https://mxtoolbox.com/emailhealth.aspx)

### ✅ Step 2: Set Up SPF (not required for Bento customers)
1. List all services that send email for you (ESP, CRM, etc.)
2. Create SPF record: `v=spf1 include:spf.protection.outlook.com -all`
3. Add to your DNS as a TXT record
4. Test using: `nslookup -type=txt yourdomain.com`

### ✅ Step 3: Configure DKIM (not required for Bento customers)
1. Generate DKIM keys (your email provider usually helps)
2. Add public key to DNS
3. Enable DKIM signing in your email system
4. Verify signatures are working

### ✅ Step 4: Implement DMARC
1. Start with: `v=DMARC1; p=none; rua=mailto:dmarc@yourdomain.com`
2. Add as TXT record to `_dmarc.yourdomain.com`
3. Monitor reports to ensure alignment
4. Gradually increase to p=quarantine or p=reject

### ✅ Step 5: Additional Best Practices
- **Valid From and Reply-To addresses:** Avoid "noreply@". Use real, monitored addresses, and fix bounces quickly. This is important.
- **Easy unsubscribe:** Clear, visible unsubscribe links in every marketing email
- **List hygiene:** Remove bounced and inactive addresses regularly
- **Honest subject lines:** No clickbait or misleading headers

## Common Mistakes to Avoid

### ❌ "I'll just use noreply@ addresses"
Microsoft wants real addresses that can receive replies. Consider using
- `hello@company.com`
- `support@company.com`
- `feedback@company.com`

### ❌ "My ESP handles everything"
Even if you use Mailchimp or SendGrid, you must set up DMARC in your DNS.

### ❌ "I'll wait until May to start"
Authentication setup can take weeks to properly configure and test. Start now.

## What Happens If You Are Not Ready

Starting May 5, 2025, non-compliant emails will see:
```
550; 5.7.515 Access denied, sending domain [YourDomain.com] 
does not meet the required authentication level.
```

Your emails won't reach recipients. Period.

## Tools & Resources

### Testing Tools:
- **SPF Check:** [SPF Record Checker](https://mxtoolbox.com/spf.aspx)
- **DKIM Validator:** [DKIM Record Checker](https://mxtoolbox.com/dkim.aspx)
- **DMARC Tester:** [DMARC Record Checker](https://mxtoolbox.com/dmarc.aspx)

### Email Service Provider Guides:
- [SendGrid Authentication Guide](https://docs.sendgrid.com/ui/account-and-settings/how-to-set-up-domain-authentication)
- [Mailchimp Authentication Guide](https://mailchimp.com/help/set-up-custom-domain-authentication-dkim-and-spf/)
- [Amazon SES Authentication Guide](https://docs.aws.amazon.com/ses/latest/dg/send-email-authentication.html)

If you are a Bento customer, open your dashboard and click "Sender Authentication" to follow the tailored guide.

## FAQs

### Q: Do these rules apply to transactional emails?
**A:** Yes, if you send 5,000 or more emails per day in total. One-click unsubscribe is required for marketing emails only. We still recommend adding it to all emails for safety.

### Q: What if I send less than 5,000 emails/day?
**A:** You are not required to comply, but these practices improve deliverability.

### Q: Can I get an extension past May 5?
**A:** No. Microsoft has been clear about the deadline.

### Q: Do subdomains count separately?
**A:** No. Email from news.company.com and support.company.com counts together toward the 5,000 limit.

## Quick Wins: Start Here

If you're overwhelmed, start with these three actions today:

1. **Check your current authentication across every provider you use** using AboutMyEmail.
2. **Contact your email service provider** about their Microsoft compliance.
3. **Set up DMARC monitoring** even at p=none to see who is sending as you. If you use a DNS provider like Cloudflare, this can be a one-click setup.

## The Bottom Line

Microsoft's new requirements are about making email safer for everyone. By implementing proper authentication, you avoid rejection, build trust with recipients, and protect your brand.

**Remember:** May 5, 2025 is a firm deadline. Start preparing now.

---

*Need help? Most email service providers offer authentication setup assistance. Do not wait until the last minute to ask for help. If you're a Bento customer, you can book a call anytime to step through it.* 

If you send bulk emails to Outlook, Hotmail, or Live.com addresses, Microsoft has new rules starting May 5, 2025. Miss these requirements, and your emails will struggle to reach your customers' inboxes (some may be rejected entirely).

Microsoft's New Email Rules for 2025: What You Need to Know (And Do)

Microsoft has new email rules starting May 5th

Google just updated their email guidelines with specific rules about display names. Get this wrong, and your emails may struggle to reach Gmail inboxes—even if everything else is perfect.

Here's what you need to know, explained simply.

## Quick Summary: What's Happening?

Google now enforces strict rules about email display names (the "From" name recipients see). Break these rules, and your deliverability suffers—especially for commercial and bulk emails.

**The key rule:** Your display name must identify WHO you are, not WHAT you're saying.

**The good news:** These changes are easy to implement—just update your email settings, especiall if you're a Bento customer.

## Why Should You Care?

Your display name is the first thing recipients see. Google's cracking down on senders who abuse this space to trick people into opening emails.

**What happens if you ignore this:**
- Lower deliverability to Gmail accounts
- Emails land in spam instead of inbox
- Damaged sender reputation
- Lost revenue from failed campaigns

## The Rules: What's Allowed vs. What's Not

### ✅ GOOD Display Names
These clearly identify the sender:
- `Acme Corporation`
- `Sarah from Acme`
- `Acme Support Team`
- `Acme Newsletter`

### ❌ BAD Display Names
These try to trick or mislead:
- `Important Update ---------- From Acme`
- `TIME IS RUNNING OUT (SALE)`
- `[Product/News] Alert`
- `URGENT REQUEST`
- `Last Chance`

## The Three Cardinal Sins

### 1. Don't Put Subject Lines in Display Names
**Why people do it:** To grab attention in crowded inboxes.
**Why it's bad:** It's deceptive and breaks Gmail's guidelines.

**Examples to avoid:**
- `FINAL NOTICE - Company Name`
- `50% OFF TODAY ONLY`
- `Action Required: Your Account`

**Do this instead:**
- Use your actual company/sender name
- Put urgent info in the subject line where it belongs

### 2. Don't Pretend It's a Personal Message
**Why people do it:** To increase open rates by faking familiarity.
**Why it's bad:** It's misleading and erodes trust.

**Examples to avoid:**
- `[recipient's first name] <info@company.com>`
- `User (2)` (implying multiple messages)
- `Re: Your Question` (when it's not a reply)

**Do this instead:**
- Use consistent sender names
- Build real relationships, not fake ones

### 3. Don't Use Weird Characters or Emojis
**Why people do it:** To stand out visually.
**Why it's bad:** It looks spammy and unprofessional.

**Examples to avoid:**
- `🔴 LATEST UPDATE`
- `★★★ Special Offer ★★★`
- `M̲A̲I̲L̲ M̲E̲` (underlined characters)
- `[1] New Message` (fake notification badges)

**Do this instead:**
- Use clean, professional display names
- Let your content quality drive engagement

## Real-World Examples: Before & After

### E-commerce Store
❌ **Before:** `🛍️ SALE ENDS TODAY - ShopName`
✅ **After:** `ShopName`

### SaaS Company
❌ **Before:** `[Action Required] BillingAlert`
✅ **After:** `Acme Billing Team`

### Newsletter
❌ **Before:** `📰 Daily News You Need`
✅ **After:** `TechNews Daily`

### Customer Support
❌ **Before:** `URGENT: Ticket #12345`
✅ **After:** `Acme Support`

## Implementation Checklist

### ✅ Step 1: Audit Your Current Display Names
Check all your email streams:
- Marketing campaigns
- Transactional emails
- Support messages
- Automated notifications

### ✅ Step 2: Update Non-Compliant Names
In your email service provider:
1. Go to sender settings
2. Update "From Name" field
3. Remove any subject-like content
4. Keep it simple and honest

### ✅ Step 3: Create Naming Standards
Document your approach:
- `[Company Name]` for general emails
- `[Name] from [Company]` for personal outreach
- `[Company] [Department]` for specific teams

### ✅ Step 4: Test Your Changes
Send test emails to:
- Your own Gmail account
- Team members
- Email testing tools

## Common Mistakes to Avoid

### ❌ "But my open rates will drop!"
Good display names build long-term trust. Tricks might boost short-term opens but damage your reputation.

### ❌ "Everyone else does it"
Google's actively enforcing these rules. What worked yesterday might fail tomorrow.

### ❌ "It's just marketing emails"
These rules apply to ALL emails—transactional, marketing, and support.

## Quick Wins: Fix These Today

1. **Remove ALL CAPS** from display names
2. **Delete emojis** and special characters
3. **Remove action words** like "URGENT" or "IMPORTANT"
4. **Standardize names** across all email types

## The Psychology Behind Good Display Names

**Build Trust:** `Acme Corporation` feels legitimate
**Set Expectations:** `Acme Newsletter` tells them what it is
**Create Recognition:** Consistent names build brand awareness

## Tools to Test Your Display Names

- Send test emails to Gmail and check how they appear
- Use AboutMy.email to check rendering of your email
- Monitor your sender reputation dashboards

## The Bottom Line

Google's display name guidelines aren't about limiting creativity—they're about honesty in email. By using clear, accurate display names, you're not just following rules; you're respecting your recipients and building a sustainable email program.

**Remember:** Your display name is your digital handshake. Make it firm, professional, and honest.

---

*Pro tip: When in doubt, ask yourself: "Does this display name honestly identify who I am?" If the answer is no, change it.* 

Google just updated their email guidelines with specific rules about display names. Get this wrong, and your emails may struggle to reach Gmail inboxes—even if everything else is perfect.

Google's New Email Display Name Rules: Don't Let Your Name Tank Your Deliverability

Google has new email display name rules

Starting with a new domain for email? Finally got the new .com? Planning to ramp up your email volume significantly? Then domain warming isn't optional—it's essential.


Domain Warming: The Complete Guide to Building Email Reputation (2025)

How to warm up a new domain

Learn transactional email best practices to improve deliverability and user experience. Understand what makes effective transactional emails and how to design them.

Transactional Email Best Practices: Complete Guide

You know those emails your app sends. Password resets. Order confirmations. Account alerts. If they don't reach your users, you get support tickets. One bad experience could be enough to lose you a customer.

Picking a transactional email provider isn't like choosing other tools. Price matters, sure. But if your emails don't reach inboxes, the cheapest provider becomes the most expensive one. You need to think about deliverability, API quality, and what happens when things break at 3 AM.

This guide walks through everything you need to consider when choosing a transactional email provider. We'll cover the technical stuff (APIs, deliverability), the business stuff (pricing, support), and help you compare the major players.

## TL;DR: Quick Picks by Use Case

**Key factors that actually matter:**
- **API quality**: You'll be coding against this API for years. Bad docs cost developer time.
- **Deliverability**: Authentication setup, reputation monitoring, inbox rates
- **Reliability**: What's their actual uptime? Not the marketing number.
- **Speed**: How fast emails hit inboxes (seconds matter for password resets)
- **Pricing**: Total cost including overage fees, not just the starting price
- **Support**: Can you reach a human when your emails stop sending?

**Quick provider recommendations:**
- **Postmark** — Speed matters more than price. Great for password resets.
- **SendGrid** — Need both transactional and marketing emails. Solid middle ground.
- **Mailgun** — High volume senders who need enterprise features
- **Amazon SES** — You're already deep in AWS. Cheapest option if you handle setup.
- **Bento** — Want deliverability tools included without extra fees

**What to watch out for:** The cheapest provider often ends up costing more. Bad deliverability means emails in spam. That means angry users, support tickets, and lost customers.

For comparing transactional email services, see our [best transactional email services](/posts/best-transactional-email-services) guide. For understanding email APIs, check [what is email API](/posts/what-is-email-api).

## What Actually Matters When Choosing a Provider

After helping dozens of companies pick providers, here's what actually moves the needle:

### API Quality

You're going to live with this API for years. A bad API costs developer time every single day.

Spend 30 minutes testing their API before committing. Send a test email. Check how they handle errors. Read their docs. If the getting started guide takes more than 10 minutes, that's a red flag.

The best APIs have SDKs in your language, clear error messages, and docs with actual code examples. Not marketing fluff. Real code you can copy and run.

Here's a quick test: Can you send your first email in under 5 minutes? If not, multiply that friction by every feature you'll build.

### Deliverability

Here's the truth: if your emails don't reach inboxes, nothing else matters.

Every provider claims "great deliverability." Most are lying. Or at least stretching the truth. Real deliverability means your provider handles SPF, DKIM, and DMARC setup. They monitor your reputation. They throttle sends when needed. They have relationships with inbox providers.

Ask providers for their actual inbox placement rates. Not delivery rates (which just means the email left their servers). Inbox rates. If they won't share numbers, walk away.

Some providers include deliverability tools. Others charge extra. Factor that into your pricing comparisons.

### Reliability

When your transactional emails fail, users can't reset passwords. They don't get order confirmations. Your support team gets flooded.

Every provider promises 99.9% uptime. But check their actual status page. Look at the last 90 days. Count the incidents. Read the post-mortems. That tells you more than any SLA.

Also check what happens during an outage. Do they queue emails and retry? Or do emails just disappear? Some providers have automatic failover. Others don't. Know which one you're getting.

### Speed

Password reset emails that take 5 minutes feel broken. Users click "resend" multiple times. Your inbox gets flooded with duplicates.

Test actual delivery times yourself. Send emails to Gmail, Outlook, and Yahoo. Time them. Do this at different times of day. Peak hours matter.

Some providers optimize for speed (Postmark delivers in seconds). Others batch sends for efficiency (can take minutes). Know what you're getting. For password resets and order confirmations, seconds matter.

### Pricing

Most companies focus too much on per-email costs. The real cost includes overage fees, deliverability tools, dedicated IPs, and developer time.

Run the numbers at your current volume, 2x volume, and 10x volume. Pricing tiers can surprise you. That cheap starter plan might become expensive fast.

Watch for hidden costs. Some providers charge extra for link tracking, opens tracking, or webhook events. Others include everything. Add it all up before comparing.

**Note on Bento:** Unlike the others, Bento charges by **contact (subscriber)**, not by the number of emails sent. You can send unlimited emails to your contacts. The price listed below assumes you have 3,000 contacts or fewer (the minimum tier).

| Provider | Free Tier (Monthly) | Starting Paid Plan | Cost for ~50,000 Emails | Best For |
| :--- | :--- | :--- | :--- | :--- |
| **Amazon SES** | 3,000 emails (for 12 mos) | Pay-as-you-go | **$5.00** | Lowest absolute price |
| **Resend** | 3,000 emails | $20/mo (includes 50k) | **$20.00** | Developer Experience (DX) |
| **SendGrid** | 100 emails/day (~3k/mo) | ~$19.95/mo (includes 50k) | **$28.00** | Marketing + Transactional Mix |
| **Mailgun** | 5,000 emails (1 mo trial) | $35/mo (includes 50k) | **$35.00** | High Volume & Analytics |
| **Postmark** | 100 emails (Developer) | $15/mo (10k emails) | **$55.00** | Speed & Deliverability |
| **SparkPost** | 500 emails (Test account) | ~$20-$30/mo | **~$20.00** | Enterprise Compliance |
| **Bento** | 30-day free trial | $30/mo (up to 3k contacts) | **$30.00*** | CRM & Automation |

### Support

Your emails stop working on a Friday night, or during Black Friday, or right after a product launch. Can you reach someone who can actually help?

Test support before you need it. Send them a technical question. See how long it takes to get a real answer - not a canned response, a real solution.

Good providers have engineers on support. Bad ones have salespeople reading scripts. You'll know the difference immediately.

## How to Actually Compare Providers

Forget comparison matrices. Here's how to really evaluate providers:

**Step 1: Know your non-negotiables.** Start with deal-breakers. Need sub-second delivery? That eliminates half the field. Must have phone support? That's another filter. Already using AWS? Maybe SES makes sense.

**Step 2: Test with real emails.** Sign up for free trials, send actual transactional emails and time them. Check how they look in different clients. Test the edge cases. What happens with attachments? Unicode characters? High volume bursts?

**Step 3: Read the incident reports.** Go to their status page and read the last year of incidents - not just the count, but the details. How did they handle problems? How fast did they communicate? How often do the same issues repeat?

**Step 4: Talk to their support.** Before you have a problem, ask a technical question and see if you get an engineer or a salesperson. Check response times. This tells you what to expect when things break.

**Step 5: Calculate the real cost.** Include everything:  per-email costs, overage fees, deliverability tools, dedicated IPs, support tiers, developer time for integration. The cheapest sticker price rarely wins.

## The Major Players (and What They're Actually Good At)

After testing all the major providers, here's the real story:

### Postmark

![postmark-by-activecampaign](//images.ctfassets.net/7154jijfbyeo/yOaVs2BuyI1HaHB2b3B3X/0b4e12fd1a9ce8aaadd246986eb7b451/postmark-by-activecampaign.png)

**Best for:** Companies where every second counts. SaaS apps with demanding users.

**The reality:** Postmark is the Ferrari of transactional email. Emails hit inboxes in 1-2 seconds. Their API is clean. Documentation is excellent. Support actually knows what they're talking about.

**The catch:** You'll pay for that speed. $15/month for 10,000 emails. No marketing features at all, just transactional.

**When to use:** Your users expect instant password resets. You can afford the premium. You don't need marketing emails.

### SendGrid

![sendgrid-by-twilio](//images.ctfassets.net/7154jijfbyeo/01PmW3Gx01vaGf2HM8PPly/cdc72fbf85c6b07ff9667f88cd66fb53/sendgrid-by-twilio.png)

**Best for:** Startups that need both transactional and marketing email.

**The reality:** SendGrid tries to do everything and they mostly succeed. The API is solid. Deliverability is good (not great). You get both transactional and marketing features. It's the Honda Civic of email. Reliable, affordable, gets the job done.

**The catch:** Jack of all trades, master of none. Not the fastest, not the cheapest, not the best at anything specific.

**When to use:** You need one tool for all email. Budget matters but isn't critical. You're okay with "good enough."

### Mailgun

![mailgun-by-sinch](//images.ctfassets.net/7154jijfbyeo/3Cncb1R8f2GX0hpnoMrXx4/44ffa67076392903deaff9800f139a6e/mailgun-by-sinch.png)

**Best for:** Developers who want control. High-volume senders.

**The reality:** Mailgun is built for developers. Powerful API. Great routing features. Solid infrastructure. You can do almost anything. But you'll need to figure out how.

**The catch:** More complex than others. Documentation assumes you know what you're doing. Pricing gets expensive at scale.

**When to use:** You're sending millions of emails. You need advanced routing. Your developers want flexibility.

### Amazon SES

![amazon-ses](//images.ctfassets.net/7154jijfbyeo/q9JJNhn6ZZxvnabpZ7H9L/218f6cdd9b224eeb68e1e6c0f257d027/amazon-ses.png)

**Best for:** Companies already deep in AWS. Cost-conscious high-volume senders.

**The reality:** SES is stupid cheap: $0.10 per 1,000 emails. If you're already using AWS, integration is straightforward. But you're on your own for everything else.

**The catch:** Bare bones. No fancy UI. Minimal support. You handle deliverability yourself. Getting off the sandbox takes time.

**When to use:** You're already in AWS. Price is everything. You have engineers who can handle the complexity.

### Bento

![bento](//images.ctfassets.net/7154jijfbyeo/owWYl4psczdBbWR2gLtKq/5677a499e07c920a30b615b93163208c/bento.png)

**Best for:** Companies that want everything included and no surprise fees.

**The reality:** Bento includes what others charge extra for. Deliverability monitoring, reputation tools, batching controls - all in the base price. The API is clean. Documentation is solid.

**The catch:** Newer player. Not as many features as enterprise platforms. Fewer integrations.

**When to use:** You want predictable pricing. Deliverability matters. You're tired of add-on fees for basic features.

## Where Bento Fits in Shortlist

Here's our pitch, straight up.

Bento does transactional email. We also do marketing email, but that's another story. For transactional, we're different in one key way: deliverability tools are included: not an add-on, not a premium tier, just included.

Our API works like you'd expect. REST endpoints, webhooks for events, SDKs in the usual languages. Nothing fancy, it just works.

**When Bento makes sense:** You want deliverability handled for you. You're tired of surprise add-on fees. You like predictable pricing. You might want marketing emails later.

**When to pick someone else:** Need the absolute fastest delivery? Postmark. Absolutely must have the cheapest price? Amazon SES. Need every enterprise feature imaginable? Mailgun or SendGrid.

We're not trying to be everything to everyone. We're good at email deliverability, reasonable pricing, and not nickel-and-diming you for features that should be standard.

## Quick Integration Reality Check

Before you commit to a provider, know what you're getting into:

**DNS setup complexity.** You'll need to add SPF records, DKIM keys, and maybe DMARC policies. Some providers walk you through it, others hand you a text file and say \"good luck.\" If you don't control your DNS, this gets complicated fast.

**Template management.** Where do templates live? In your code? Their dashboard? Both? Figure out your workflow before you have 50 templates scattered everywhere.

**Testing in development.** Some providers have sandbox modes. Others don't. You might need a separate test account or you might accidentally email real users from your dev environment. Ask about this.

**Webhook handling.** Bounces, complaints, opens, clicks - you'll want these events. That means setting up webhook endpoints, handling retries and signature verification. It's more work than you think.

**Rate limiting reality.** Every provider has limits - 10 emails per second, 1,000 per hour, whatever. Know your limits. Know what happens when you hit them. Some queue nicely. Others just reject.

## Common Mistakes to Avoid

Before you make your final decision, watch out for these traps:

**Ignoring the sandbox period.** Many providers start you in a sandbox. Limited sending. Restricted features. Getting out can take days or weeks. If you need to send immediately, ask about this upfront.

**Not testing at scale.** That provider who handles 100 emails per day might choke at 10,000. Test at realistic volumes before committing.

**Forgetting about compliance.** GDPR, CAN-SPAM, CCPA. Some providers help with compliance. Others leave you on your own. Know which you're getting.

**Overlooking migration pain.** Switching providers means updating code, migrating templates, handling DNS changes. Factor in the switching cost before you pick the cheapest option.

**Believing the marketing.** Every provider claims 99% delivery rates. Most are measuring the wrong thing. Delivery means it left their server. Inbox placement means it reached the inbox. Big difference.

## Making the Actual Decision

Pick your deal-breakers first. Must have sub-second delivery? Must integrate with your stack? Must stay under a certain price? Start there.

Then test the survivors. Really test them. Send emails. Break things. Talk to support. Check their status pages. Calculate the real costs.

Don't overthink it. You can usually migrate later if needed. But switching providers is annoying, so do enough homework to get it right the first time.

**More guides that might help:** 
- Compare providers in detail: [best transactional email services](/posts/best-transactional-email-services)
- Understand the technical side: [what is email API](/posts/what-is-email-api)
- Fix delivery problems: [email deliverability tools](/posts/email-deliverability-tools)

If you want to test Bento, grab a free trial at [bentonow.com](https://bentonow.com). We'll help you send some test emails and see if we're a good fit.

Pick the wrong transactional email provider and watch support tickets pile up. Here's what actually matters: API quality, real deliverability, and honest pricing.

How to Choose a Transactional Email Provider: Complete Guide

The **BEST** email “design” for transactional emails is plain text (cannot hyperlink). The next best is rich text (can hyperlink). This is because it doesn't matter how pretty your email looks if it ends up in the spam folder. For those who don't want to use either plain text or rich text because they're obsessed about being “on brand”, this email design guide will help you.

Good design makes every email easy to read, simple to act on, and impossible to mistake for spam. Most companies treat transactional emails like an afterthought. The ones who get it right see fewer support tickets, better engagement, and customers who trust their brand.

Bento gives you the ability design transactional emails using our visual editor or via our [transactional email](https://bentonow.com/transactional-email) API. Our templates are already mobile optimized and tested across all major email clients.

## TL;DR: Design Rules That Work in Every Inbox

**Mobile-first always wins.** Over 60% of emails get opened on phones. Single columns, 16px text minimum, buttons at least 44px tall. If it works on mobile, desktop is easy.

**Make the important stuff obvious.** People scan emails in seconds. Put the main message up top, the action button where they expect it, and supporting details below. White space is your friend.

**Test like your business depends on it.** Because it does. Check Gmail, Outlook, Apple Mail. Test dark mode. Turn off images and see if it still makes sense. A broken email in one client means lost customers.

## The Non-Negotiable Foundation

### Start With Mobile

Here's the truth: if you design for desktop first, mobile users suffer. But if you design for mobile first, everyone wins.

Single-column layouts work best. They're simple to code, load fast, and adapt to any screen size. Keep your email width between 320px and 600px. Body text needs to be at least 16px, preferably 18px for better readability. Headlines should be 22-24px minimum.

Buttons need real estate. Apple recommends 44x44px minimum touch targets, but 50px gives you breathing room. Put padding around buttons so fat fingers don't miss. Make the whole button clickable, not just the text inside.

Space between elements matters more on mobile than desktop. Add at least 20px padding between sections. Give paragraphs room to breathe as dense emails feel overwhelming on small screens.

### Create Visual Hierarchy That Guides the Eye

People don't read emails word by word - they scan. Your job is to make scanning productive.

Start with a clear headline that explains what happened. "Your order shipped" beats "Update from YourStore." Follow with one sentence that gives context. Then add your primary call-to-action button. Everything else comes after.

Use font sizes to create hierarchy. Headlines should be at least 1.5x your body text size. Subheadings need to be 1.2x. Keep it consistent across all your transactional emails.

Bold text draws attention but use it sparingly. Bold the order number, the delivery date, the account username. Don't bold entire paragraphs or you lose the effect.

Color helps too, but be careful. Your primary brand color should highlight buttons and important links. Use a secondary color for less critical actions. Stick to black or dark gray for body text. Colored body text is harder to read, especially on mobile.

### Make Your Brand Recognizable

Every transactional email is a chance to reinforce your brand, but branding isn't just slapping a logo on top.

Your emails should match what customers see in your app or website. Same fonts, same colors, same button styles. When someone gets a receipt, they should instantly know it's from you, not wonder if it's phishing.

Put your logo in the header, but keep it reasonable - 150-200px wide works for most brands. Link it to your homepage as this small detail helps when people forward emails or save them for reference.

Your footer needs the essentials: company name, physical address (CAN-SPAM requires this), and an unsubscribe link if you mix marketing with transactional content. Add social icons if you want, but they're not critical for pure transactional emails.

### Build for Everyone (Accessibility Matters)

About 15% of people have some form of disability. Accessible emails aren't just nice to have. They're good business.

Alt text on images is mandatory. Describe what the image shows, don't just repeat the headline. "Graph showing 50% increase in sales" beats "Sales chart." If an image contains text, include that text in the alt attribute.

Color contrast needs to hit 4.5:1 for normal text, 3:1 for large text. Black text on white background is foolproof. Gray text might look elegant but fails accessibility tests. Test your colors with a contrast checker before shipping.

Use semantic HTML. Screen readers understand `<h1>`, `<h2>`, `<p>`, and `<table>` tags. They struggle with divs pretending to be headings. Proper HTML structure helps everyone, not just screen reader users.

Links need descriptive text. "View your order" beats "Click here." Screen reader users often navigate by jumping between links. "Click here" tells them nothing.

### Make Actions Crystal Clear

Your call-to-action (CTA) is why the email exists so don't bury it.

Put your primary CTA above the fold. That means within the first 600px of your email. Repeat it at the bottom for longer emails. Some people scroll, some don't. Cover both.

Button text should describe the action. "Reset password" not "Continue." "View invoice" not "Click here." Be specific about what happens when they click.

Always include a text link backup. Some email clients block images and styled buttons. A plain text link ensures everyone can take action. Put it right below your button: "Button not working? Copy this link: https://..."

Secondary actions get text links, not buttons. "Update preferences" or "Contact support" work fine as regular links. Save buttons for the main event.

## The Technical Side of Design

### HTML Tables Still Rule Email

Web development moved past tables decades ago, but email hasn't. Tables provide the most consistent layout across email clients, especially Outlook.

Keep your HTML simple. Inline CSS is more reliable than external stylesheets. Many email clients strip out `<style>` tags or ignore them completely. Put your styles directly on elements.

Avoid JavaScript entirely. No email client supports it for security reasons. Animated GIFs work if you need movement, but remember they increase file size.

### Image Optimization Is Critical

Heavy emails load slowly and might get flagged as spam. Keep your total email size under 100KB if possible, definitely under 250KB.

Host images on a reliable CDN. Don't embed them directly in the email. Use absolute URLs (https://yourdomain.com/image.png) not relative paths.

Compress images before uploading. JPEGs for photos, PNGs for graphics with transparency. Tools like TinyPNG can cut file sizes by 70% without visible quality loss.

Consider whether you need images at all. Text-based emails often perform better for transactional messages. They load instantly, work everywhere, and feel more personal.

### Dark Mode Changes Everything

Over 30% of users have dark mode enabled. Your beautiful white email might look terrible on a black background.

Test how your email renders in dark mode. Some email clients invert colors automatically, while others respect your color choices. Gmail, Outlook, and Apple Mail all handle dark mode differently.

Transparent PNGs work best for logos and icons. They adapt to any background color. Avoid images with white backgrounds unless you add a white container behind them.

Use semantic colors in your CSS. Instead of `color: #000000`, use `color: black`. Some email clients can translate semantic colors better in dark mode.

## Testing: The Step Everyone Skips (Don't)

### Email Client Testing

You can't test in just Gmail and call it done. Different clients render HTML differently.

At minimum, test in:
- Gmail (web, iOS, Android)
- Outlook (2016, 2019, 365, Outlook.com)
- Apple Mail (macOS, iOS)
- Yahoo Mail
- Samsung Mail (huge Android market share)

Use a tool like Litmus or Email on Acid if you can. They show your email across dozens of clients instantly. Manual testing works too but takes longer.

### Load Time and Spam Filters

Slow emails frustrate users and trigger spam filters. Run your email through a spam checker before sending. Most ESPs have this built in.

Common spam triggers to avoid:
- Too many images, not enough text
- All-caps subject lines or body text
- Excessive exclamation points
- Spam trigger words (FREE, WINNER, URGENT)
- Missing unsubscribe links
- No physical address in footer

Page weight matters. Google penalizes slow-loading emails just like slow websites. Keep it lean.

### Device and Network Testing

Test on actual devices when possible. Emulators miss edge cases.

Test on slow connections since not everyone has 5G or fiber internet. Your email should load reasonably fast on 3G.

Test with images disabled. Many corporate email systems block images by default. Your email should still make sense without them.

## Real Examples That Work

### Order Confirmation Emails

The best order confirmations answer three questions immediately: What did I buy? When will it arrive? How much did I pay?

Put order details in a clear table format. Product name, quantity, price per item, total. Include product images if you have them, but keep them small (100x100px is plenty).

Add the delivery address and estimated arrival date prominently. People screenshot these for reference.

Include a big "Track Order" button that goes straight to tracking. Add order number and customer service contact below.

### Password Reset Emails

Speed matters most here. Someone locked out wants back in now.

Keep it minimal - one sentence explaining someone requested a reset. "Reset Your Password" as the subject and headline is good; so is a big button saying "Reset Password." That's it.

Add a security note: "If you didn't request this, ignore this email." Include an expiration time: "This link expires in 1 hour."

Never include the new password in the email. Always link to a secure reset page.

### Welcome Emails

First impressions stick. Welcome emails get 4x the open rate of regular emails.

Confirm what they signed up for. "Welcome to YourProduct" followed by their email address or username. This confirms they're in the right place.

Set expectations and tell them what emails they'll get and how often. Give them a clear way to adjust preferences.

Provide one clear next step - complete your profile, explore features, read the getting started guide. One action, not five.

## Measuring What Matters

### Key Metrics for Transactional Email

Open rate tells you if your emails reach the inbox. Transactional emails should see 40-60% opens minimum. Under 20% means deliverability problems.

Click rate shows engagement. Password resets should see 50%+ clicks. Order confirmations around 30%. Welcome emails vary widely based on your product.

Delivery rate should be 95%+ for transactional email. High bounce rates mean data quality issues or blacklisting.

### Using Data to Improve

Heat maps show where people click. You might discover they're trying to click non-clickable elements. Make those clickable or make them look less interactive.

A/B test carefully with transactional emails. You can test button color, CTA text, or layout, but keep variations small as dramatic changes confuse users.

Monitor support tickets mentioning email. "Didn't receive" or "can't find button" tickets point to design problems.

Track email client and device data. If 60% of users open on iPhone, optimize for that first.

## Common Mistakes to Avoid

**Overdesigning kills performance.** Your marketing emails might have beautiful graphics and animations. Transactional emails need speed and clarity. Save the fancy stuff for campaigns.

**Mixing marketing with transactional confuses everyone.** A receipt shouldn't pitch new products. A password reset shouldn't include a sale banner. Keep them separate or risk spam filters and angry customers.

**Forgetting about forwarding breaks things.** People forward receipts to accounting, confirmations to partners, tickets to friends. Make sure forwarded emails still work and make sense.

**Ignoring international users causes problems.** Currency symbols, date formats, time zones matter. Use clear formats: "$100 USD" not just "$100". "January 15, 2025" not "1/15/25".

## Where Bento Helps With Design

Bento gives you a head start on transactional email design. Templates are already mobile-optimized, accessible, and tested across major email clients. You can simply add your brand and ship.

The platform handles the technical parts. Authentication (SPF, DKIM, DMARC) is automatic and reputation monitoring catches problems before they hurt deliverability. Batching spreads large sends to maintain high delivery rates.

Analytics show you what's working. Track opens, clicks, and bounces in real-time. See which email clients your users prefer. Find out where they're clicking. Use webhooks to pipe data into your own analytics.

The visual editor means designers can work without touching code. Developers can use the API for complete control. Both approaches produce emails that work everywhere.

## Your Design Checklist

Before you send any transactional email, run through this list:

1. **Know the goal.** What should users do after reading this email? Make that action obvious.

2. **Design mobile-first.** Create your layout on a 320px canvas. Scale up from there.

3. **Test the hierarchy.** Can someone understand the email in 5 seconds? If not, simplify.

4. **Check your code.** Inline CSS, table-based layout, no JavaScript. Old school but reliable.

5. **Optimize images.** Under 100KB total email weight. Images hosted externally. Alt text on everything.

6. **Test across clients.** At least Gmail, Outlook, and Apple Mail. More is better.

7. **Verify accessibility.** Color contrast passing, semantic HTML, descriptive link text.

8. **Add fallbacks.** Text links below buttons. Email still makes sense with images off.

9. **Monitor performance.** Track opens, clicks, and delivery rates. Iterate based on data.

10. **Stay consistent.** Every transactional email should feel like it comes from the same company.

## Ready to Design Better Transactional Emails?

Great transactional emails do their job and get out of the way. They load fast, work everywhere, and help users complete tasks without frustration.

Start with one email type. Pick your password reset or order confirmation. Redesign it following these principles. Test it thoroughly. Ship it. Monitor the metrics. Then move to the next one.

For more specific examples, check out our [transactional email best practices](https://bentonow.com/posts/transactional-email-best-practices) guide. It covers the technical setup and delivery side in detail.

Remember: every transactional email is a chance to build trust. Make them count.

Learn email design best practices for transactional emails. Understand what makes effective email design and how to create emails that engage users.

Email Design Guide: Create Effective Transactional Emails

People have been saying email is dead since 2010. Then they said it in 2015... and in 2020... and in 2025. Yet, in 2026, email marketing is still the most profitable marketing channel that exists. 

My morning still starts with coffee and email and yours probably does too. While studies on email checking frequency vary, with some older research suggesting the average person checks their email about 15 times a day, more recent data indicates this number is likely much higher for many professionals in today's connected world.[^1] [^2] Your customers are in their inbox right now.

Email isn't sexy. It doesn't go viral like TikTok and doesn'r have prett pictures like Instagram. But email drives more revenue than social media channels.[^3] For every dollar you spend on email, you can expect an average return of around $36—a figure that showcases a thriving, powerful channel.[^4]

The problem is when businesses use email wrong, like sending the same "20% off!" blast to everyone and then their unsubscribe rates climb. Or they write great emails that die in spam folders because they ignored the technical stuff, so nobody sees their work.

If you're just starting with email marketing or you're looking for ways to improve your results, this guide shows what works. And we KNOW what works because we run an email marketing software company and see what our most profitable customers do.

## The Quick Version (Because We're All Busy)

If you're scanning this between meetings, here's what matters:

**Email isn't just newsletters.** Good programs combine marketing campaigns, product updates, and transactional messages. The receipt email after a purchase matters as much as the promo that drove the sale.

**Deliverability kills more campaigns than bad copy.** Companies with perfect targeting and brilliant writing fail when they ignore the technical side. Starting in 2024, Google and Yahoo began enforcing stricter authentication rules. Forgetting them is not an option.[^5]

**Generic blasts died years ago.** Sending the same message to everyone stopped being effective long ago. You need to know your audience, what they want, and when they want it.

**Tools make the difference.** The right platform (like Bento) handles infrastructure so you focus on strategy. Bad tools waste your time on technical problems instead of customer conversations.

## What Email Marketing Actually Looks Like Today

### Beyond the Newsletter

Most people think email marketing means newsletters and maybe sale announcements. However, that's missing 90% of what email can do.

Real email marketing happens when someone abandons their cart at 2 AM and gets a reminder one hour later. It's the onboarding sequence that turns confused trial users into paying customers. It's bringing back customers you lost six months ago.

One ecommerce client was losing $240K annually from bad cart abandonment emails. They waited 24 hours to send them and used generic copy. We changed the timing to one hour, showed the actual products left behind, and added customer reviews. Their recovery rate hit 28%.

Welcome emails are another massive opportunity. Most say "Thanks for subscribing! Here's 10% off!" Boring. The ones that work are far more powerful; data shows that, on average, welcome emails generate **320% more revenue per email** than other promotional messages.[^6] They tell your story, set expectations and give people a reason to open the next email.

Smart companies connect every email into a system. Each message builds on the last and everything pushes toward one goal: trial conversions, repeat purchases, course completions. Whatever pays the bills.

## Why Smart Teams Double Down on Email

Email never changes its algorithm.

Your list belongs to you and no platform can take it. No algorithm can hide your messages and nobody charges you to reach people who already want to hear from you. Social platforms rent you attention, but email lists are an asset you own.

Email automation works while you sleep. Set up a welcome series once and it runs forever. Build cart abandonment flows, as they recover sales at 3 AM. A course creator I know has one automated sequence that's made $2M over three years and she hasn't touched it in 18 months.

Social media can feel like gambling: some posts blow up, but most vanish. With email, you can establish a baseline. Send to 10,000 people, get 2,000 opens, generate 100 clicks and make 10 sales. You can forecast email revenue with a degree of confidence that is difficult to achieve with the volatility of social feeds.

## The Deliverability Reality Check Nobody Wants to Hear

### Your Amazing Content Means Nothing If It Lands in Spam

Your perfect email campaign with the clever subject line and beautiful design doesn't matter if it lands in spam.

The technical stuff isn't optional. Google and Yahoo rolled out new rules in February 2024 that all senders must follow. For those sending over 5,000 emails a day (bulk senders), the requirements are even stricter. At a minimum, you need to have **SPF or DKIM** authentication in place. If you're a bulk sender, you need **SPF, DKIM, and a DMARC policy**.[^5]

Think of them this way:
*   **SPF (Sender Policy Framework)** is like a public list of all the servers authorized to send email on your domain's behalf.[^7]
*   **DKIM (DomainKeys Identified Mail)** provides a digital "signature" that verifies the email is authentic and hasn't been tampered with.[^7]
*   **DMARC (Domain-based Message Authentication, Reporting & Conformance)** is a policy that tells receiving servers what to do if an email fails SPF or DKIM checks—for example, to send it to spam or reject it entirely.[^7]

### The Reputation Game You Can't Afford to Lose

Email providers remember everything. Send one campaign with high complaints? They remember. Email dead addresses? They remember. Keep sending to people who don't open? They *really* remember.

The numbers that matter:

*   **Spam Complaint Rate:** Keep this below **0.1%** (one complaint per 1,000 emails). If your rate approaches or exceeds **0.3%**, you are in the danger zone and risk having your emails blocked.[^5]
*   **Bounce Rate:** A bounce rate above **2%** is a red flag that can harm your reputation. If it consistently exceeds 5%, you face a critical risk of being blacklisted by providers.[^8]
*   **Open Rates:** While metrics are heavily influenced by Apple's Mail Privacy Protection, consistently low open rates (e.g., below 15% for cold campaigns) can still be an indicator of a deliverability problem.[^9]

Clean your list constantly. Stop emailing unengaged subscribers. Set up proper authentication. Warm up new domains slowly. Bento automates most of this, but you still can't do stupid things like buying lists or writing "V1AGRA" in subject lines.

## Building an Email Strategy That Actually Works

### Start With the End in Mind (Or You’ll End Up Nowhere)

"We want to do email marketing."
"Cool, why?"
"..."

Companies know they should do email. but they don’t know what success looks like. They send random newsletters when someone remembers, and when nothing happens they wonder why.

Skip the vanity metrics. Open rates don't matter if revenue stays flat. Open rate reporting has been inflated by Apple's privacy changes.[^10]

For many SaaS companies, a key goal is getting new users to complete a critical action within the first week. For ecommerce, a successful campaign should drive a significant revenue lift.

### The Segmentation Secret That Changes Everything

Your list isn't one group. It's dozens of smaller audiences with different needs. New users need help getting started. Power users want advanced features. Dormant users need reasons to come back.

Behavioral triggers beat demographics every time. Someone hitting their usage limit is far more likely to upgrade than someone with a similar company size. Someone who just contacted support has a different set of needs. These moments matter more than any demographic data.

### Automation: Your 24/7 Revenue Machine

Someone signs up at 11 PM Friday. Do they wait until Monday for their welcome email? Someone abandons a cart at lunch. Do they get a reminder while they still want to buy, or three days later after buying from your competitor?

Good automation feels personal with perfect timing and perfect message. Behind the scenes, it's just triggers and workflows running while you sleep.

## Choosing Tools Without Losing Your Mind

### The Email Platform Maze

Shopping for email platforms is like dating apps: everyone says they're perfect, but most disappoint.

What actually matters:

Getting emails into inboxes comes first. Everything else is worthless if you fail here. Most platforms treat deliverability like an add-on, but that's like selling cars where brakes cost extra.

### Why We Built Bento Differently

Full disclosure: I'm writing for Bento, so yes, I think it's great. Here's why we built it this way.

We got tired of needing three tools for marketing emails, transactional emails, and automation. We also got tired of deliverability being an expensive extra and tired of platforms that need a manual to send an email.

We put everything in one place: marketing campaigns, product emails, transactional messages. Deliverability infrastructure is included from day one, there is an interface that makes sense to marketers and developers and the best value for money you'll get compared to any other email marketing platform on the market.

With Bento you pay one simple price and get access to __ALL__ of our features. We don't hide our best features behind more expensive tiers.

## Measuring What Matters (And Ignoring What Doesn't)

### The Numbers That Keep You Up at Night

**Crisis metrics that will kill you:**

*   **Bounce Rate:** If your bounce rate hits **5%**, your domain is at critical risk of being blacklisted.[^8] One bad list upload and you're explaining to the CEO why password resets aren't working.
*   **Spam Complaints:** If your spam complaint rate reaches **0.3%**, drop everything. You have crossed a critical threshold set by major providers like Google and Yahoo.[^5] Your sender reputation is dying.

**Money metrics that count:**

*   **Revenue Per Email (RPE):** This shows if you're sending gold or garbage. While it varies, industry averages often fall in the range of **$0.08 to $0.20** for ecommerce.[^11] Consistently falling below this range may mean you have a bad list or ineffective emails.
*   **Email-Attributed Revenue:** For many healthy ecommerce businesses, email should drive **20–30%** of total revenue.[^12] Less means you're likely wasting the channel or tracking it incorrectly. More than 40% can be risky, indicating over-dependence on a single source.

**Engagement (still useful but changing):**

*   **Open Rates:** These vary widely by industry. Recent data shows averages around **31% for B2B** and **30% for Ecommerce**.[^13] But remember, Apple's iOS 15 Mail Privacy Protection inflates these numbers by pre-fetching images, meaning an email can be marked "opened" even if the user never read it.[^10] For this reason, it's crucial to track clicks, replies, and conversions—metrics that reflect real engagement.

### The Testing Trap You're Probably In

Everyone tests subject lines. "Should we use an emoji? How about CAPS LOCK?"

Other variables to test: 
- Send times
- Sender names (personal vs. brand)
- Offer
- Email length (short vs long)
- Plain text vs heavily-designed template

The biggest mistake people make when performing marketing tests is not achieving Statistical Significance. That's a fancy way of saying you know the difference in results is because of your test and it's not random.

## Your Next Move

Email marketing isn't going anywhere. While everyone chases viral platforms, email keeps generating revenue for people who take it seriously.

You can keep blasting your entire list. Keep ignoring deliverability until Gmail blocks you and keep juggling three different tools that don't talk to each other.

Or you build an email program that works - one that reaches inboxes, drives revenue, and doesn't need a team of experts to run.

Ready to get serious? [Try Bento](https://bentonow.com/signup). We built it for operators tired of the usual email marketing mess. It has everything you need, nothing you don't, and deliverability that just works.

Want more? Read about [transactional email](https://bentonow.com/posts/transactional-email-best-practices) (the revenue driver everyone ignores), [email marketing for ecommerce](https://bentonow.com/posts/ecommerce-email-marketing-strategy) (physical products have different rules), or [comparing email services](https://bentonow.com/posts/best-email-marketing-services) (if you're still looking).

---

## Footnotes

[^1]: Kushlev, K., & Dunn, E. W. (2015). Checking email less frequently reduces stress. *Computers in Human Behavior*, 43, 220-228.

[^2]: WTOP. (2014, June 18). *Study finds people check email an average of 74 times daily*.

[^3]: McKinsey & Company. (2013). *Email marketing: Think inside the new inbox*.

[^4]: Forbes Advisor. (2026, February 2). *49 Top Email Marketing Statistics*.

[^5]: Google. (n.d.). *Email sender guidelines*. Google Workspace Admin Help.

[^6]: Campaign Monitor. (n.d.). *How Effective Are Welcome Emails? [Infographic]*.

[^7]: Cloudflare. (n.d.). *What are DMARC, DKIM, and SPF?*.

[^8]: Mailtrap. (n.d.). *Email Bounce Rate: Definition, Benchmark, Best Practices*.

[^9]: SalesHive. (2025, March 17). *Open Rate Tracking: Metrics Every B2B Team Needs*.

[^10]: Apple. (n.d.). *Mail Privacy Protection on iPhone*. Apple Support.

[^11]: OpenSend. (2025, April 27). *7 Revenue per Email Subscriber Statistics For eCommerce Brands*.

[^12]: BlueStout. (n.d.). *Is 30% of Your Revenue Coming From Email? If Not, Ask These Questions*.

[^13]: Mailchimp. (2023, December). *Email Marketing Benchmarks & Industry Statistics*.

Understand the fundamentals of email marketing, why deliverability is non-negotiable, and how teams use Bento to run marketing, product, and transactional emails in one place.

What Is Email Marketing? Complete Guide for Product and Marketing Teams

Your transactional email subject lines need to work harder than any other part of the message. You get about 40 characters to tell someone their password was reset, their order shipped, or their payment failed, especially on mobile devices[^1]. No room for mistakes.

People are much more likely to look for and open transactional emails - their credit card got declined, they can't log in, a shipment is late... Your subject line needs to tell them exactly what the email contains so they can fix their problem fast.

## TL;DR: Subject Lines That Do Their Job

**The basics:** Write clear subject lines that tell people what happened. Include order numbers or account details when it helps. Keep it under 50 characters so nothing gets cut off on most devices[^2].

**What works:** `Order #4821 shipped` or `Reset your password`. Simple, clear, no confusion.

**What to avoid:** Vague marketing language, excessive capitalization, and multiple exclamation points. Focus on clarity and reputation over avoiding specific "trigger words."

## Core Principles

### Clarity over cleverness

Write subject lines that people understand immediately. `Password reset requested` tells them everything. `We've got you covered!` tells them nothing.

Good transactional subject lines answer one question: what is this email about? Write `Order #4821 confirmed`, not `Great news about your recent purchase`. Write `Payment failed for subscription`, not `Uh oh, there's a problem`.

Your customers scan their inbox looking for specific information. Make it easy for them to find.

### Front-load important details

The most important information has to go first. Mobile devices can cut off subject lines, with some showing as few as 33-48 characters[^1]. Desktop email clients aren't much better.

Compare these two options:
- `Your order has been shipped (#4821)` gets cut to `Your order has been shi...`
- `Order #4821 shipped` stays intact

The second version survives truncation and the customer sees their order number even on the smallest screen. This matters when someone has multiple orders or needs to reference a specific transaction.

### Keep it short

Six to nine words is a good guideline[^2]. Aim for under 50 characters total. That's your target.

Short subject lines work better because they display fully on more devices. They're easier to scan and they get to the point faster. Count the characters in these examples:

- `Password reset` (14 characters)
- `Order #4821 shipped` (19 characters)
- `Payment received - Invoice #3847` (32 characters)
- `Your subscription renewal failed` (32 characters)

All are well under the 50-character recommendation and are completely clear about their purpose.

### Align subject and body

Your subject line makes a promise and the email body needs to deliver on it.

If your subject says `Password reset instructions`, the email better contain a reset link, not a sales pitch for your premium features. If it says `Order shipped`, include tracking information, not a request for reviews.

Mismatched subject lines frustrate customers and can harm your sender reputation. Email providers track when people mark messages as spam after opening them. Too many complaints and your deliverability tanks[^3].

### Adopt a consistent naming pattern

Pick a format and stick with it. Your customers will learn to recognize your emails faster.

Some patterns that work:
- `[Action] - [Details]` like `Shipped - Order #4821`
- `[Company]: [Action]` like `Bento: Password reset`
- `[Status] [Object]` like `Confirmed order #4821`

Whatever format you choose, use it for every transactional email. Customers who receive regular invoices, shipping notifications, or account updates will appreciate the consistency. They can spot your emails instantly, even in a crowded inbox.

### Personalize with purpose

While using a recipient's first name can sometimes feel like a waste of valuable characters, it can also improve open rates when used appropriately[^4]. The decision should be based on A/B testing and audience preferences. For many brands, the benefit of a personal touch outweighs the character cost.

Good personalization examples:
- `New login from iPhone (Seattle, WA)`
- `Invoice for Acme Corp - March 2024`
- `Subscription renewed: Pro Plan`

Bad personalization examples:
- `Sarah, your payment was processed!` (unless A/B testing proves this works for your audience)
- `Good news, valued customer!`
- `Thanks for your order, friend!`

Save the overly friendly tone for marketing emails unless you have data to back it up. Transactional emails need facts, not personality.

### Avoid spammy phrasing

While the idea of a static list of "spam trigger words" is largely outdated, certain phrasing and formatting choices can still negatively impact deliverability. Modern spam filters use complex algorithms that analyze sender reputation, user engagement, and email authentication, not just keywords[^5].

However, it's still wise to avoid:

- ALL CAPS anywhere in the subject
- Multiple exclamation points!!!
- Deceptive phrasing or marketing language

These patterns can still contribute to a negative perception from both spam filters and human recipients. A subject line reading `URGENT: Verify your account NOW!!!` looks like a phishing attempt, not a legitimate security notice.

## Example Templates

Good subject lines follow predictable patterns. Here are templates that work across different industries:

**Account and security:**
- `Reset your [Company] password`
- `Verify your email address`
- `Your [Company] login code: 482193`
- `New device login: [Device] in [Location]`
- `Security alert: unusual activity detected`

**Orders and shipping:**
- `Order #[Number] confirmed`
- `Order #[Number] shipped via [Carrier]`
- `Order #[Number] delivered`
- `Return received for Order #[Number]`
- `Refund processed: $[Amount]`

**Payments and billing:**
- `Payment received - Invoice #[Number]`
- `Payment failed for [Plan/Product]`
- `Subscription renewed: [Plan name]`
- `Your receipt from [Company]`
- `Payment method updated successfully`

**Appointments and bookings:**
- `Appointment confirmed: [Date] at [Time]`
- `Reminder: [Service] tomorrow at [Time]`
- `Booking cancelled: [Reference number]`
- `Reschedule your appointment`

Notice how each template states exactly what happened. No mystery. No marketing speak. Just facts.

## Testing and Optimization

Testing transactional subject lines requires care. You can't spam your users with password reset emails just to test open rates, but you can still optimize.

**Safe testing methods:**

- **Start with new user flows.** Test welcome email subject lines since every new user gets one. Try `Welcome to Bento` versus `Confirm your Bento account` to see which drives more engagement.
- **Use order confirmation emails for e-commerce testing.** Every purchase triggers one, giving you regular test opportunities without annoying anyone.
- **Monitor natural variations.** If you send invoices monthly, compare open rates between `Invoice for [Month]` and `[Company] Invoice #[Number]`. Track patterns over time.

**What to measure:**

Open rates tell you if the subject line worked. But for transactional emails, also track:

- **Time to open** (faster is better for urgent messages)
- **Complaint rates** (high complaints mean confused users)
- **Reply rates** (confused users often reply to transactional emails)
- **Support tickets** (bad subject lines generate questions)

**Segment your tests:**

Business customers and consumers have different expectations. Test subject lines separately for:

- B2B versus B2C customers
- Mobile versus desktop users
- New versus returning customers
- Different geographic regions (if you operate globally)

**When to roll back changes:**

If open rates drop significantly, investigate immediately. If complaint rates rise above 0.1%, you should roll back the change, as this is a critical threshold for many email providers[^3]. If support tickets increase, your new subject line likely confused people.

Remember: transactional email deliverability affects all your emails. A high complaint rate on your transactional mail can damage your sender reputation, which can in turn harm the deliverability of your marketing emails sent from the same domain[^6].

## Common Mistakes to Avoid

**Using marketing language in transactional subjects**

`Amazing news about your order!` sounds like a sales email, not a shipping notification. Users might ignore it when they actually need the tracking information inside.

**Being too vague**

`Update from Bento` could mean anything. Did my payment fail? Did my order ship? Is there a security issue? Vague subject lines create anxiety and reduce trust.

**Forgetting about mobile users**

Test your subject lines on actual phones. What looks fine on desktop might be useless on mobile. `Your order from yesterday has been...` tells the mobile user nothing.

**Including unnecessary variables**

`Order #4821 for 3 items totaling $47.99 has shipped from our warehouse` wastes space. `Order #4821 shipped` conveys the same essential information in 19 characters instead of 89.

**Mixing transactional and promotional content**

Never use transactional emails to promote products. If someone requested a password reset, they want to reset their password, not learn about your summer sale. Keeping transactional emails purely transactional is a legal and deliverability best practice, as mixed-content emails may be subject to CAN-SPAM regulations[^7].

## Special Considerations for Different Email Types

### Password resets and security alerts

Speed matters most here as users need these emails immediately. Use the simplest possible subject: `Reset your password` or `Security alert`. Skip personalization unless multiple accounts exist.

Include time sensitivity when relevant: `Password reset link expires in 1 hour` helps users prioritize opening the email.

### Order confirmations and receipts

Include the order number prominently. Users often search their inbox for these emails months later when they need to reference a purchase. `Order #4821` is searchable. `Your recent purchase` is not.

For subscriptions, include the plan name: `Pro Plan renewed` or `Basic subscription cancelled`. This helps users with multiple subscriptions track which one changed.

### Shipping notifications

State the current status clearly. Don't make users guess whether the email contains tracking information or delivery confirmation. Use specific terms:
- `Shipped` means it left the warehouse
- `Out for delivery` means it arrives today
- `Delivered` means it arrived
- `Delayed` means there's a problem

Include the carrier name when possible: `Order #4821 shipped via FedEx` helps users know where to track their package.

### Failed payment notifications

Be direct but not alarming. `Payment failed for subscription` is clear without being scary. Include what happens next if space allows: `Payment failed - retrying tomorrow`.

Never use shame or pressure tactics. `URGENT: Fix your payment NOW` creates unnecessary stress. These are service messages, not collections notices.

## Where Bento Fits

Bento handles the technical complexity of transactional email so you can focus on crafting perfect subject lines. Our platform provides:

**Dynamic content insertion:** Pull order numbers, customer names, and other data directly into subject lines. Set up once, personalize forever.

**A/B testing capabilities:** Test different subject line formats without affecting deliverability. Bento automatically picks winners based on your success metrics.

**Deliverability monitoring:** Track open rates, complaint rates, and spam placement by template. Know immediately if a subject line causes problems.

**Template management:** Store and version your subject line templates. Test new versions while keeping proven ones as fallback options.

**Segmentation tools:** Send different subject lines to different user segments. B2B customers can get formal subjects while B2C users see casual ones.

The best part? Bento's deliverability infrastructure means your carefully crafted subject lines actually reach the inbox. No point writing perfect subject lines if they land in spam.

[Start your free 30-day trial today](https://bentonow.com/signup) or [book a demo](https://savvycal.com/bento/demo?d=30&sid=35275ec3-8671-4251-9315-3f286456e08b) with our team.

## Subject Line Checklist

Run through this list before sending any transactional email:

1. **State the event in plain language.** Can someone understand this subject without opening the email?
2. **Insert key identifiers when useful.** Include order numbers, invoice numbers, or account references that help users.
3. **Keep it under 50 characters.** Count carefully. Test on mobile devices.
4. **Match the tone and content of the email body.** Subject and body should feel like the same message.
5. **Validate that dynamic data renders correctly.** Test with real data, not placeholders.
6. **Test across devices and clients.** What works in Gmail might fail in Outlook.
7. **Review for spam-like signals.** While modern filters are complex, avoid ALL CAPS, excessive punctuation, and overly promotional language that can still appear suspicious to both filters and recipients.
8. **Ensure searchability.** Will users be able to find this email later by searching their inbox?

For more email best practices, check out our guides on [transactional email best practices](https://bentonow.com/posts/transactional-email-best-practices) and [email design guide](https://bentonow.com/posts/designing-modern-email).

## Make Every Character Count

Transactional email subject lines don't need to be creative. They need to be clear. Tell users exactly what happened and what they need to do, nothing more, nothing less.

Your customers will thank you with higher open rates, fewer support tickets, and better deliverability. And in the world of transactional email, that's what actually matters.

---

[^1]: EmailToolTester. (2023). *The Perfect Email Subject Line Length: A 2023 Study*. [https://www.emailtooltester.com/en/blog/email-subject-lines-character-limit/](https://www.emailtooltester.com/en/blog/email-subject-lines-character-limit/)
[^2]: Mailchimp. (n.d.). *Best Practices for Email Subject Lines*. [https://mailchimp.com/help/best-practices-for-email-subject-lines/](https://mailchimp.com/help/best-practices-for-email-subject-lines/)
[^3]: Google. (n.d.). *Email sender guidelines*. [https://support.google.com/a/answer/81126?hl=en](https://support.google.com/a/answer/81126?hl=en)
[^4]: Campaign Monitor. (n.d.). *The New Rules of Email Personalization*. [https://www.campaignmonitor.com/resources/guides/personalization/](https://www.campaignmonitor.com/resources/guides/personalization/)
[^5]: Suped. (2025). *Are spam trigger word lists accurate and should I be concerned about them?* [https://www.suped.com/knowledge/email-deliverability/technical/are-spam-trigger-word-lists-accurate-and-should-i-be-concerned-about-them](https://www.suped.com/knowledge/email-deliverability/technical/are-spam-trigger-word-lists-accurate-and-should-i-be-concerned-about-them)
[^6]: Postmark. (n.d.). *Should I use a separate domain for my marketing and transactional email?* [https://postmarkapp.com/support/questions/should-i-use-a-separate-domain-for-my-marketing-and-transactional-email](https://postmarkapp.com/support/questions/should-i-use-a-separate-domain-for-my-marketing-and-transactional-email)
[^7]: Federal Trade Commission. (2003). *CAN-SPAM Act: A Compliance Guide for Business*. [https://www.ftc.gov/business-guidance/resources/can-spam-act-compliance-guide-business](https://www.ftc.gov/business-guidance/resources/can-spam-act-compliance-guide-business)

Learn transactional email subject line best practices to improve open rates. Understand what makes effective subject lines and how to write subject lines that get opened.

Transactional Email Subject Lines: Best Practices for Opens

Every time you fire off a test email to a real address, email providers like Gmail and Outlook are watching. If they see an email that nobody opens, nobody clicks, nobody cares about, it's not a good look. Do this enough times and your domain reputation drops.

The thing is, test emails themselves aren't the problem - it's where you send them that matters. Send test emails to real inboxes that sit untouched, and you're basically telling email providers your messages are unwanted. But there's a simple fix: use the right testing methods and your reputation stays intact.

This guide covers exactly how test emails damage domain reputation, the specific signals that hurt you, and the safe testing methods that keep your sender score healthy.

## TL;DR: Test Emails and Domain Reputation

**The problem:** Test emails sent to real addresses sit unopened in inboxes. Email providers track this lack of engagement and lower your domain reputation score.[^1]

**Why it matters:** Your domain reputation determines whether emails reach the inbox or spam folder. Bad reputation = wasted emails.

**Safe testing methods:**
- **Test addresses only**: Create dedicated test accounts that won't affect your metrics
- **Email testing tools**: Mail-Tester, GlockApps, or Litmus give you safe inboxes for testing
- **Keep volumes low**: A few test emails won't hurt. Hundreds will.
- **Sandbox mode**: Most email platforms have test modes that bypass reputation tracking
- **Check reputation first**: If your score is already low, skip testing until it recovers

**Warning:** Sending test emails to your actual subscriber list is the fastest way to damage your sender reputation. Even 50-100 test emails to inactive addresses can trigger spam filters.[^2]

For monitoring your current reputation, check our [how to check domain reputation](/posts/how-to-check-domain-reputation) guide. For testing without risk, see [checking spam scores](/posts/checking-spam-scores).

## How Test Emails Hurt Domain Reputation

Think about it from Gmail's perspective: your domain sends 100 test emails to real addresses. Yet, nobody opens them and nobody clicks anything. Gmail sees a pattern: your emails get ignored.

This creates three specific problems. First, you're generating terrible engagement metrics: email providers measure opens, clicks, replies, forwards, and time spent reading, [^1] and test emails score zero on all of these. Second, if you're testing frequently, you're creating volume without value. A domain that sends 500 test emails and 500 real emails looks like it has a 50% engagement problem. Third, test emails often contain placeholder text, lorem ipsum, or obvious test data that spam filters recognize as junk.

The damage happens faster than you'd think. While not strictly real-time, major providers like Google update reputation data frequently, typically within a day.[^3] Send a batch of bad test emails on Monday, and by Tuesday your legitimate campaigns might start hitting spam folders. The worst part is that reputation takes weeks to rebuild but only days to destroy.[^4]

## Why Test Emails Cause Problems

Email providers use sophisticated algorithms to calculate your domain reputation. They track every single email you send and measure recipient behavior. When someone opens your email quickly, that's a positive signal. When they delete it without reading, that's negative. Test emails generate nothing but negative signals.

The reputation calculation works like a credit score.[^5] Email providers combine multiple factors: engagement rates (opens, clicks, replies), complaint rates (spam reports), bounce rates, and sending patterns. Test emails drag down your engagement rates while adding nothing positive. If you normally have a 30% open rate but send 100 test emails with 0% opens, your overall rate drops significantly.

Volume makes everything worse. One test email to your personal Gmail won't matter. But developers often test with lists of 50 or 100 addresses, especially during QA testing. Some companies even use their entire employee directory for testing, thinking internal addresses are safe, but they're not. While the exact weighting is proprietary, providers like Google have indicated that even internal sends can impact reputation, especially if users mark those emails as spam.[^6]

## How to Send Test Emails Safely

The safest approach is simple: never send test emails through your production email system to real, unmanaged addresses. Instead, use these five methods that protect your reputation.

**Create dedicated test accounts.** Set up test email addresses specifically for testing. Use addresses like `test1@yourdomain.com`, `qa@yourdomain.com`, or `dev@yourdomain.com`. Since you control these addresses, you can open and click the emails to generate positive engagement. Many teams create 5-10 test accounts across different providers (Gmail, Outlook, Yahoo) to see how emails render in each client.

**Use professional testing tools.** Services like Mail-Tester, GlockApps, and Litmus provide safe testing inboxes. These tools give you temporary email addresses that won't affect your reputation. Better yet, they analyze your emails for spam triggers, authentication issues, and rendering problems. Mail-Tester is free for basic testing.[^7] GlockApps costs about $59/month for its entry-level plan and provides detailed deliverability reports.[^8]

**Keep test volumes minimal.** If you must send test emails to real addresses, limit yourself to 5-10 emails per day. This won't move the needle on your reputation metrics. The problems start when teams send 50+ test emails daily or blast test campaigns to hundreds of addresses.

**Enable sandbox mode.** Most email platforms offer sandbox or test modes. SendGrid calls it "Sandbox Mode,"[^9] and Postmark offers a similar feature under the same name, though it also has a simpler "Test Mode" via a specific API token.[^10] Mailgun provides both a "Sandbox Domain" for limited sending and a "Test Mode" parameter for API calls.[^11] These modes validate your API calls and templates without actually sending emails. Your code runs normally but emails never leave the server.

**Check reputation before testing.** If your domain reputation is already struggling, avoid all testing with real addresses until it recovers. Google Postmaster Tools no longer uses a 0-100 score, but instead provides categorical ratings of **Bad, Low, Medium,** or **High**.[^12] If your reputation is anything less than High, use sandbox mode exclusively during recovery periods. You can check your current reputation using Google Postmaster Tools for Gmail or Microsoft Smart Network Data Services (SNDS) for Outlook.[^13][^14]

## Test Email Best Practices

Beyond the basic safety measures, these practices will keep your testing clean and your reputation intact.

**Separate test and production environments completely.** Use different API keys, different sending domains if possible, and different IP addresses for testing versus production. Many companies use a subdomain like `test.example.com` for all testing. This isolation helps insulate your main domain, though it's important to note that a severely damaged subdomain can still sometimes have a negative impact on the root domain's reputation.[^15]

**Document your test addresses.** Keep a spreadsheet of all test email addresses your team uses. Include the provider (Gmail, Outlook, etc.), purpose (rendering tests, API tests), and who manages each account. This prevents accidental sends to old addresses that nobody checks anymore.

**Rotate test accounts regularly.** Even dedicated test accounts can develop reputation issues if you only send test emails to them. Every month, send a few legitimate emails to your test accounts. Open them, click links, and reply occasionally. This maintains a healthy engagement pattern.

**Test rendering without sending.** Tools like Litmus and Email on Acid can preview how your email looks across over 100 different email clients without sending a single email.[^16] Upload your HTML and see instant previews. This eliminates most testing needs.

**Use seed lists for deliverability testing.** Instead of sending test emails to random addresses, use professional seed lists from services like GlockApps or Validity's Everest platform (which absorbed the popular 250ok service).[^17] These lists include addresses across all major providers and generate detailed reports about inbox placement without affecting your reputation.

**Time your tests strategically.** If you must send test emails, do it when your engagement rates are highest. While this can vary, multiple studies show that mid-week (Tuesday to Thursday) and mid-day (10am to 2pm) tend to yield the highest engagement.[^18] The positive engagement from legitimate emails helps offset any negative impact from tests.

## Where Bento Fits: Safe Testing Support

If you're worried about test emails damaging your reputation, Bento has built-in protections.

**Sandbox mode built in.** Bento's sandbox mode validates everything without sending real emails. Your templates render, merge tags process, and API calls succeed, but nothing hits an inbox. Perfect for development and QA testing.

**Reputation monitoring included.** Bento tracks your domain reputation across all major providers. You get alerts before problems become critical and if your reputation drops, Bento automatically adjusts sending patterns to help recovery. No extra fees, no add-ons, just built into the platform.

**Smart testing workflows.** Bento separates test sends from production sends in your analytics. Test emails to whitelisted addresses won't skew your engagement metrics or affect your reputation score. You can test freely without worrying about the consequences.

**When Bento makes sense:** You want email infrastructure that handles the technical details. You're tired of managing authentication, reputation monitoring, and testing workflows separately. You need a platform that prevents testing mistakes from affecting deliverability.

**When specialized tools work better:** You need pixel-perfect rendering tests across 100+ email clients (use Litmus). You want detailed spam filter testing across multiple providers (use GlockApps). You're building custom testing infrastructure for unique requirements.

**The practical reality:** Most companies need both. Bento for day-to-day sending with built-in protections, plus specialized tools for specific testing needs. Bento's sandbox mode handles 80% of testing requirements. For the other 20%, tools like Litmus or GlockApps fill the gaps.

## Test Without Destroying Your Reputation

Your domain reputation is too valuable to risk on careless testing. Every test email to a real address is a potential reputation hit. The good news is that safe testing is straightforward once you know the rules.

Start by auditing your current testing practices. Count how many test emails you're sending to real addresses each week. Check if you're using production systems for testing. Look at your engagement metrics for signs of test email pollution. If you see problems, stop all testing to real addresses immediately.

Next, implement the safe testing methods covered above. Set up dedicated test accounts across major email providers. Configure sandbox mode in your email platform. Consider investing in professional testing tools if you send high volumes or need detailed deliverability data.

Most importantly, treat your domain reputation like the critical business asset it is. One bad testing practice can undo months of careful list building and engagement optimization. Train your entire team on safe testing methods. Document your testing procedures. Make reputation protection part of your development culture.

**Take action today:** Check your domain reputation using [Google Postmaster Tools](/posts/how-to-check-domain-reputation). Run your next campaign through [spam scoring tools](/posts/checking-spam-scores) before sending. Review our guide to [email deliverability tools](/posts/email-deliverability-tools) for ongoing monitoring.

---

[^1]: Litmus, "Email engagement: The good, the bad, and the ugly." (Accessed February 2026).
[^2]: Allegrow, "How Many Emails Can You Send a Day Without Spamming?" (Accessed February 2026).
[^3]: Google, "Postmaster Tools dashboards," Google Workspace Admin Help. (Accessed February 2026).
[^4]: Validity, "How to Repair a Bad Sender Reputation." (Accessed February 2026).
[^5]: Rejoiner, "What is Sender Reputation and Why Does it Matter?" (Accessed February 2026).
[^6]: Google, "Email sender guidelines," Google Workspace Admin Help. (Accessed February 2026).
[^7]: Mail-Tester, "Test your newsletter for spam." (Accessed February 2026).
[^8]: GlockApps, "Pricing." (Accessed February 2026).
[^9]: SendGrid, "Sandbox Mode." (Accessed February 2026).
[^10]: Postmark, "Sandbox Mode." (Accessed February 2026).
[^11]: Mailgun, "Test Mode." (Accessed February 2026).
[^12]: Google, "Monitor outgoing email with Postmaster Tools," Google Workspace Admin Help. (Accessed February 2026).
[^13]: Microsoft, "Smart Network Data Services (SNDS)." (Accessed February 2026).
[^14]: Google, "Learn about the deprecation of the old Postmaster Tools interface," Google Workspace Admin Help. (Accessed February 2026).
[^15]: Postmark, "Should I use a subdomain for sending email?" (Accessed February 2026).
[^16]: Sinch, "Email on Acid: Email Testing & Previews." (Accessed February 2026).
[^17]: Validity, "Validity Acquires 250ok." (Accessed February 2026).
[^18]: Forbes, "What Is The Best Time To Send An Email?" (Accessed February 2026).


Learn how test emails can hurt domain reputation. Understand why test emails cause problems and how to send test emails without damaging reputation.

Test Emails Could Be Hurting Your Domain Reputation

Welcome emails are one of the most powerful tools in a marketer's arsenal, generating up to 320% more revenue per email than other promotional emails[^1]. They also achieve significantly higher engagement, earning 4 times more opens and 5 times more clicks than regular marketing campaigns[^2]. Yet most companies send a boring confirmation that wastes this golden opportunity.

When someone signs up for your list, they actually want to hear from you - right now. This moment of peak interest is when you build the foundation for every future interaction. Get it right, and you've earned an engaged subscriber who opens your emails for months. Get it wrong, and you're fighting an uphill battle from day one.

## TL;DR: Quick Wins for Your Welcome Email

- Send within minutes while they're still thinking about you; 74% of people expect a welcome email immediately after subscribing[^3].
- Thank them, confirm what they signed up for, and tell them what's next.
- Give them one clear action that delivers immediate value.
- Welcome emails earn 4x more opens and 5x more clicks than regular campaigns[^2].

**Watch out:** Don't dump your entire product catalog in email one. Pick a single goal and make it obvious what you want them to do next.

## Why Welcome Emails Matter More Than You Think

Some studies showed that welcome emails see average open rates of over 80%, compared to typical open rates of 15-25% for regular campaigns[^4]. They generate more revenue per email than any other type of message[^1]. But the real power goes deeper.

Your welcome email trains Gmail and Outlook that your messages deserve the inbox - it sets expectations that determine whether future emails get opened or ignored. Most importantly, it captures new subscribers when they're actually paying attention, not three weeks later when they've forgotten who you are.

The data backs this up. Companies with strong welcome emails see 33% higher long-term engagement[^5]. While it's a common misconception that these subscribers spend more, the engagement itself is a critical asset. Furthermore, 74% of people expect a welcome email immediately after subscribing[^3]. Miss that window, and you've already disappointed them.

## The Core Elements Every Welcome Email Needs

### Send it instantly (not tomorrow morning)

Speed matters more than perfection. Someone just gave you their email address. They're expecting confirmation, with 74% of consumers anticipating a welcome email immediately upon subscribing[^3]. If your welcome email shows up tomorrow, they've already moved on. Worse, they might mark it as spam because they don't remember signing up.

Set up automated triggers that fire the second someone subscribes. Test your delivery speed regularly. If emails take more than a minute to arrive, fix your infrastructure. Slow welcome emails create confused customers and angry support tickets.

### Confirm what just happened

Start with a warm thank you. Do not use corporate speak, show genuine appreciation and then immediately remind them what they signed up for; something like "You're now getting weekly marketing tips" or "Your free trial of Bento is ready." Include their email address and any account details they might need.

This confirmation serves two purposes: first, it reassures people the signup worked; second, it prevents confusion if someone else signed them up. Clear confirmation means fewer "I didn't sign up for this" complaints.

### Set crystal clear expectations

Tell subscribers exactly what they're getting and when. "Every Tuesday, you'll get one email with our best marketing tip of the week." or "We'll check in three times during your trial to help you succeed." Be specific about frequency, content type, and value.

People unsubscribe when reality doesn't match expectations. If you promise weekly tips but send daily promotions, you've broken trust. Better to be honest upfront than deal with spam complaints later.

### Give them one compelling next step

Pick the single most important action for new subscribers. Complete their profile, download your app, join your community, watch a demo video, read your most popular article - whatever moves them toward success fastest. Don't put everything at once.

Make this action impossible to miss by using the big, colorful button. Explain the benefit in plain language. "Set up your first automation in 2 minutes" beats "Get started." Remove competing links and options - one clear path forward performs better than five possibilities.

### Deliver immediate value

Prove you're worth their inbox space right away by sharing your best resource, most popular template, or exclusive discount. Give them something useful they can apply today. This instant win validates their decision to subscribe.

Think about what made current customers successful and package that into a quick win for new subscribers. A checklist, video tutorial, or insider tip that saves them time or money. The faster they see results, the longer they'll stick around.

### Add human touches (without overdoing it)

Use their first name if you have it and reference where they signed up. "Welcome from the Bento blog" feels more personal than generic greetings. Mention their plan level or interests if you collected that data.

But don't force personalization. "Hey [First Name]!" looks terrible when the field is empty. Simple, genuine language beats fancy merge tags. Write like you're emailing a colleague, not broadcasting to thousands.

### Optimize for mobile first

A significant portion of emails—by some estimates, 41-60%—are opened on mobile devices[^6]. That beautiful three-column layout might look like scrambled eggs on an iPhone. Design for small screens first, then check desktop.

Keep subject lines concise, aiming for 30-50 characters to ensure they don't get cut off on mobile screens[^7]. Make buttons at least 44 pixels tall to provide an easy tap target for thumbs[^8]. Use a minimum of 14-point font for body text to ensure readability[^9]. Single-column layouts work best. Test on real devices, not just preview tools. If people have to pinch and zoom, you've already lost them.

### Include a polite way out

Yes, you just got this subscriber. Yes, you want to keep them. But forcing people to stay makes them hate you. This is why you have to include an unsubscribe link. 

Early unsubscribes actually help you. These people would never buy anyway. They'd tank your engagement rates and hurt deliverability. A healthy unsubscribe rate is generally considered to be under 1%[^10]. Thank them for their honesty and move on.

What is the best option is to, beside unsbscribe button, also offer a link to preference center where they can adjust frequency instead of leaving entirely. Maybe someone wants to be a customer, but doesn't like all the emails. Make sure this can be adapted.

## Real Examples Worth Studying

The best welcome emails share common patterns. They confirm the signup clearly and quickly, remind you why you signed up in the first place and push you toward one specific action that helps you succeed. They prove their value with social proof, useful content, or exclusive access. Additionally, they handle the boring stuff (compliance, contact info, social links) without making it the focus.

Study welcome emails from companies you admire - sign up for their lists and screenshot what arrives. Notice how fast it shows up, look at the subject line, preview text, and first paragraph, check what action they want you to take, and see how they balance personality with information.

## Common Welcome Email Mistakes to Avoid

### Waiting too long to send

Every hour you wait cuts your open rate. After 24 hours, most people have forgotten they signed up for anything. Send that welcome email within minutes, not days.

### Information overload

New subscribers don't need your life story and they don't want 15 links to explore. Pick the most important information and save the rest for email two or three. Cognitive overload kills engagement faster than anything else.

### Generic, boring copy

"Welcome to our newsletter" puts people to sleep. "Thanks for signing up" is what everyone says. Stand out with specific, benefit-focused language. "Your first marketing win is 2 minutes away" beats generic welcomes every time.

### Broken or slow links

Test every link before going live. Check load times on mobile. Nothing kills momentum like a 404 error or a page that takes 30 seconds to load. Your welcome email might be perfect, but if the landing page sucks, you've lost them anyway.

### Forgetting mobile users

That desktop-perfect email might be unreadable on phones: images might not load, buttons might be too small to tap, text might require horizontal scrolling. Always design mobile-first, then adapt for desktop.

### No clear next step

Confused subscribers do nothing. You need to give your subscribers one obvious action. Make the button huge, explain the benefit clearly and remove distractions. The welcome email isn't the time for multiple options.

## Timing Your Welcome Series for Maximum Impact

A single welcome email works, but a series works better. Here’s the cadence that consistently performs:

**Email 1** arrives immediately. It confirm the signup, set expectations, and provide one clear action. This is your highest-performing email, so make it count.

**Email 2** follows within 24 hours. This one share your best resource, most popular content, or biggest success story. Help them see what’s possible when they engage with your brand.

**Email 3** comes 2-3 days later. In this email you should address common questions, overcome objections, or invite them to connect on other channels. This is where you deepen the relationship beyond transactions.

Keep the series tight, make it three to five emails max. Any longer and you risk overwhelming new subscribers before they've seen value. Save the advanced stuff for engaged users who've proven they want more.

## Subject Lines That Actually Get Opened

Your welcome email subject line needs to stand out in a crowded inbox. Here’s what works:

"Your [specific thing] is ready" creates urgency and confirms action. "Welcome to [brand]" is boring but clear. "Quick question about your [goal/interest]" sparks curiosity. "[First name], here’s your first [benefit]" combines personalization with value.

Keep it concise for mobile users, aiming for a length of 30-50 characters to ensure it's fully visible[^7]. Avoid spam triggers like FREE, %, or excessive punctuation. Test different approaches with your audience. What works for B2B software might fail for fashion ecommerce.

The preview text matters too - don't waste it on "View this email in your browser." Use those 35-90 characters to expand on your subject line or add another benefit[^11]. Think of it as your subject line’s sidekick.

## Measuring What Actually Matters

Track the right metrics to improve your welcome emails over time:

**Open rate** shows if your subject line and sender name work. While a 50% open rate is a good baseline, top-performing welcome emails can exceed 80%[^4]. However, be aware that Apple's Mail Privacy Protection (MPP) can inflate these numbers, making them less reliable for measuring true engagement.

**Click-to-Open Rate (CTOR)** reveals whether your content and CTA resonate. For welcome emails, a CTOR of 20-30% is an excellent target, indicating strong engagement with your content[^12].

**Conversion rate** measures real business impact. Define what conversion means (trial start, first purchase, profile completion) and optimize toward that goal. Everything else is a vanity metric if conversions don’t improve.

**Unsubscribe rate** indicates expectation mismatches. A rate under 1% is generally considered healthy, though aiming for under 0.5% is even better[^10].

**Complaint rate** (spam reports) must stay below 0.1%. This is a strict threshold set by major inbox providers like Google, and exceeding it can severely damage your sender reputation and deliverability[^13].

**Time to open** shows engagement urgency. A large portion of opens occur within the first few hours of an email being sent, with about half of all opens happening within the first six hours[^14]. If people wait days to open, your subject lines might be weak or your sending reputation might need work.

## Advanced Personalization Without Being Creepy

Personalization goes beyond "Hi [First Name]." Smart welcome emails adapt based on:

**Signup source**: Blog subscribers get different content than free trial users. Ad traffic needs different messaging than organic visitors. Track where people come from and customize accordingly.

**User intent**: Someone downloading a guide wants education. Trial starters want quick wins. Buyers want confirmation and next steps. Match your message to their moment.

**Industry or role**: B2B companies can customize based on company size, industry, or job title. Ecommerce can segment by browsing history or stated preferences. Use what you know to be more relevant.

**Geographic location**: Time zones affect send times. Local events or seasons provide context. Currency and language preferences matter for global businesses.

**Behavioral signals**: Did they browse pricing? Download a resource? Attend a webinar? These actions reveal intent you can address in the welcome email.

But don’t get creepy. Using information people didn’t explicitly provide feels invasive. Mentioning their company name from their email domain is clever. Referencing their LinkedIn profile is stalking. Know the line.

Bento's native integration with [RightMessage](https://bentonow.com/integrations) makes it easy for you to add relevant, valuable personalization to your emails that boost conversions.

## How Bento Helps You Nail Your Welcome Email

Bento makes welcome emails simple without sacrificing sophistication. Automations trigger instantly when someone subscribes, so your welcome arrives while they're still engaged. Built-in deliverability infrastructure means your emails actually reach the inbox, not spam folders.

The visual workflow builder shows exactly how your welcome series flows. Drag and drop to add emails, delays, and conditions. See how many people are at each stage. Test changes without breaking what works.

Personalization tokens pull from any data source. Merge tags for basics like name and email. Custom templates start you fast, but they're fully customizable. Mobile-responsive by default. Accessibility features built in. Dark mode support automatic. Your welcome email looks professional from day one.

Plus, you get the infrastructure that matters: reputation monitoring to catch issues early, authentication setup (SPF, DKIM, DMARC) handled for you, batch sending controls for list warming, and detailed analytics to optimize over time.

[Start your free 30-day free trial](https://bentonow.com/signup) or book a demo today.

## Your Welcome Email Checklist

Before hitting send on your welcome email:

- [ ] Automation triggers within minutes of signup
- [ ] Subject line is compelling and between 30-50 characters
- [ ] Preview text adds value, not "view in browser"
- [ ] Thank you and confirmation in first paragraph
- [ ] Clear expectations about frequency and content
- [ ] One primary CTA above the fold
- [ ] Immediate value delivered (resource, tip, discount)
- [ ] Mobile-optimized design and button sizes (44px+)
- [ ] All links tested and working
- [ ] Unsubscribe link included and functional
- [ ] Sender name and reply-to address recognizable
- [ ] Follow-up emails scheduled (if running series)

## Ready to Transform Your Welcome Experience?

Your welcome email sets the tone for every future interaction. It's the difference between engaged customers and dead subscribers. Between strong deliverability and the spam folder. Between growing revenue and leaving money on the table.

Stop treating welcome emails like an afterthought. Create an experience that makes new subscribers excited to hear from you. Test, optimize, and improve based on data, not guesses.

---

[^1]: Invesp. "Important Welcome Email Statistics and Trends." [Online]. Available: https://www.invespcro.com/blog/welcome-emails/

[^2]: Campaign Monitor. "How Effective Are Welcome Emails? [Infographic]." [Online]. Available: https://www.campaignmonitor.com/resources/infographics/how-effective-are-welcome-emails/

[^3]: WordStream. "74% of Consumers Expect a Welcome Email." [Online]. Available: https://www.wordstream.com/blog/ws/2018/05/31/welcome-email

[^4]: GetResponse. "Email Marketing Benchmarks & Statistics (Updated for 2024)." [Online]. Available: https://www.getresponse.com/resources/reports/email-marketing-benchmarks

[^5]: Campaign Monitor. "7 Welcome Email Dos (and Don'ts!) for Stellar Results." [Online]. Available: https://www.campaignmonitor.com/blog/email-marketing/7-welcome-email-dos-and-donts-for-stellar-results/

[^6]: Emailmonday. "The ultimate mobile email statistics overview." [Online]. Available: https://www.emailmonday.com/mobile-email-usage-statistics/

[^7]: Twilio. "What's the ideal email subject line length in 2025?" [Online]. Available: https://www.twilio.com/en-us/blog/ideal-email-subject-length

[^8]: Apple Developer. "Human Interface Guidelines - Buttons." [Online]. Available: https://developer.apple.com/design/human-interface-guidelines/buttons

[^9]: UX Stack Exchange. "email font and accessibility." [Online]. Available: https://ux.stackexchange.com/questions/149790/email-font-and-accessibility

[^10]: Campaign Monitor. "What is a good unsubscribe rate?" [Online]. Available: https://www.campaignmonitor.com/resources/knowledge-base/what-is-a-good-unsubscribe-rate/

[^11]: Litmus. "The Ultimate Guide to Email Preview Text." [Online]. Available: https://www.litmus.com/blog/the-ultimate-guide-to-preview-text-support

[^12]: Pushwoosh. "13 email marketing metrics every marketer should track in 2026." [Online]. Available: https://www.pushwoosh.com/blog/email-marketing-metrics/

[^13]: Google Workspace Admin Help. "Email sender guidelines FAQ." [Online]. Available: https://support.google.com/a/answer/14229414?hl=en

[^14]: MarketingCharts. "Half of Your Email Campaign's Clicks Occur Within 3 Hours of Being Sent." [Online]. Available: https://www.marketingcharts.com/digital/email-online-and-mobile-116558

Learn welcome email best practices to improve user onboarding. Understand what makes effective welcome emails and how to design emails that engage new users.

Welcome Email Best Practices: Design Effective Onboarding

Discover sales funnel software that boosts earnings per click, average order value, lifetime value, and more.

Sales Funnel Software: Boost EPC, AOV, LTV and more

Every app sends these emails: password resets, order confirmations, shipping notifications, account verification. They're transactional emails, the automated messages your application fires off when users do something.

What developers miss is transactional emails aren't just any automated email. They're a specific type with unique technical requirements and users expect them instantly. A password reset that takes five minutes feels broken. An order confirmation that never arrives creates support tickets.

This guide covers everything about transactional email. What it is, why it's different from marketing email, and why you probably need a specialized service to send it properly.

## TL;DR: What Is Transactional Email?

**Transactional email** is any automated email your app sends when users take an action. Password resets, order confirmations, shipping updates, account verifications, system notifications.[^1]

**Key characteristics:**
- **Triggered by actions**: Users do something, email gets sent
- **Time-sensitive**: Users need them right away
- **Functional, not promotional**: They deliver information, not ads
- **High deliverability requirements**: Must reach inboxes reliably
- **Sent via APIs**: Your code triggers them, not marketing campaigns

**What to watch out for:** Don't mix transactional and marketing emails. They have different technical requirements. Marketing emails can wait, but transactional emails can't. If you send them together, marketing problems (spam complaints, low engagement) can tank your transactional delivery.

For more on the differences, see our [transactional vs marketing email](https://bentonow.com/posts/transactional-vs-marketing-Email-differences) guide. For service recommendations, check [best transactional email services](https://bentonow.com/posts/how-to-choose-transactional-email-provider).

## What Is Transactional Email?

Transactional email is any automated email your application sends after a user does something. If user clicks "forgot password," your app sends a reset link. If customer completes checkout, they get an order confirmation. When someone signs up, they receive a welcome email.[^1]

These emails are functional, not promotional and users need them to use your app properly. No one can't reset a password without that reset email nor verify a purchase without the receipt.

**Common transactional email types:**

**Authentication emails:**
- Password reset links
- Email verification codes
- Magic link logins
- Two-factor authentication
- Security alerts (new login from unknown device)

**Order and purchase emails:**
- Order confirmations
- Digital receipts
- Shipping updates
- Delivery notifications
- Refund confirmations

**Account emails:**
- Welcome messages after signup[^2]
- Email verification requests
- Profile change confirmations
- Subscription confirmations
- Payment method updates

**System notifications:**
- Activity alerts (someone replied to your comment)
- Status updates (your export is ready)
- Reminder messages
- Error notifications
- Usage warnings (approaching limits)

Transactional emails go to one person at a time, triggered by their specific actions. Marketing emails blast out to entire lists. One is personal and expected. The other is promotional and optional.[^1]

## How Transactional Email Is Used

Every type of app uses transactional emails differently, but they all serve critical functions:

**User authentication** relies entirely on transactional email. Password resets, email verification, magic links. Without these emails working properly, users get locked out of accounts. A password reset that doesn't arrive means a user can't log in. Period.

**Ecommerce operations** need transactional emails for trust. Order confirmations prove the purchase went through, shipping notifications keep customers informed and receipt emails provide records for accounting. When these emails fail, customers panic as they think their order didn't process. This will ceratinly make support tickets pile up.

**Account management** uses transactional emails to confirm changes. New user signs up, they get a welcome email. Someone updates their password, they get a security notification. These emails build trust by showing the system works.

**System notifications** keep users engaged with your app. Comment on a post, get notified when someone replies. Upload a large file, get an email when processing finishes. These emails bring users back to your application.

Many developers set up transactional emails once and forget about them, until something breaks and only then you realize how critical they are. A delayed password reset email generates immediate complaints. An order confirmation that lands in spam creates angry customers. These aren't nice-to-have features - they're essential infrastructure.

## Transactional Email vs Marketing Email

These are completely different types of email with different technical requirements:

**Transactional emails:**
- Triggered by user actions (someone clicks a button, email gets sent)
- Need to arrive in seconds
- Contain functional information users need
- Go to one person at a time
- Must reach the inbox every time
- Sent through your application's code via APIs

**Marketing emails:**
- Sent to lists of subscribers
- Can wait minutes or hours
- Promote products or content
- Go to hundreds or thousands at once
- Some landing in promotions tab is fine
- Sent through campaign interfaces or automation

Gmail, Yahoo, and other email providers evaluate these emails differently. They look at transactional emails and check authentication. Is this really from who it claims to be? They look at marketing emails and check engagement. Are people opening these? Are they complaining?[^3]

If you send both types from the same place, marketing problems hurt transactional delivery. Your newsletter gets marked as spam a few times, suddenly password resets start failing too. Users complain about promotional emails, now order confirmations land in spam.

Keep them separate - use different services or at least different sending streams. While Postmark was known for being a transactional-only service, they now support both transactional and broadcast emails through separate "Message Streams."[^4] SendGrid and others offer similar separation with features like IP Pools.[^5] This separation protects your critical transactional emails from marketing reputation issues.

## Why Transactional Emails Need Specialized Services

You could send transactional emails through any email service. But specialized transactional services exist for good reasons.

**Speed is everything.** Users click "reset password" and start checking their email immediately. Every second matters. A password reset that takes 30 seconds feels slow. One that takes five minutes feels broken. Specialized transactional services optimize for speed. Most deliver in under 10 seconds.[^6] [^7]

**Reliability can't be optional.** Your marketing campaign can wait an hour. Your password reset can't. If transactional emails fail, users can't use your app - they can't log in, can't verify purchases, can't confirm account changes. Specialized services provide 99.9% uptime or better because they know every failed email is a failed user experience.[^8]

**Volume spikes happen instantly.** Launch a product, get 500 signups in five minutes. That's 500 welcome emails firing at once. Run a flash sale, trigger thousands of order confirmations instantly. Generic services might throttle these sends or flag them as suspicious. Specialized transactional services handle spikes without blinking.

**Reputation needs protection.** Marketing emails generate lots of complaint. People mark newsletters as spam and that's normal. But if those complaints affect your transactional sending reputation, suddenly password resets land in spam too. Specialized services keep transactional reputation completely separate.

**APIs must be rock solid.** Your application code calls these APIs thousands of times per day. They need to be fast, reliable, and well-documented. Marketing platforms focus on campaign interfaces. Transactional services focus on developer experience. Better APIs, better SDKs, better error handling.

**Deliverability requires different optimization.** Gmail evaluates transactional emails differently than marketing emails. They check authentication more strictly but care less about engagement metrics.[^3] Specialized transactional services optimize specifically for these patterns. They know how to get functional emails into inboxes.

Yes, you can use Mailchimp or similar platforms for transactional email through their add-on services like Mandrill.[^9] But for critical emails that directly impact user experience, specialized services deliver better results. The cost difference is minimal. The reliability difference is huge.

## How Transactional Emails Work

The technical flow is straightforward:

**1. User triggers an action.** Someone clicks "forgot password.", someone completes checkout, someone signs up for an account, someone's package is on the way - all of these actions you application needs to detect. 

**2. Your code calls the email API.** Your application makes an HTTP request to your transactional email service. The request includes the recipient's email, either a template ID or the email content, and any dynamic data (user's name, order details, reset link).

**3. The service processes the email.** The transactional service validates your request, renders any templates with your data, and prepares the email for sending. This includes adding a DKIM signature to the email headers and checking your domain's SPF and DMARC records.[^10]

**4. Email gets delivered.** The service connects to the recipient's email server via SMTP and delivers the message.[^11] If everything's configured right, it lands in the inbox. If not, it goes to spam folder or rejection.

**5. Events get tracked.** Good services track what happens next. Did it bounce? Did they open it? Click any links? This data comes back to your app via webhooks.

**The API side** is what developers interact with most. You make POST requests with JSON payloads. Include who it's going to, what template to use, what data to insert. The service responds with success or error codes. Simple stuff.

**Templates make life easier.** Instead of sending raw HTML every time, you create templates in the service's dashboard. Your code just references the template ID and passes dynamic data. Want to update email design? Change the template. No code deployment needed.

**Webhooks close the loop.** The service tells your app what happened to each email. Delivered successfully? Great. Bounced? Remove that email from your database. Clicked the password reset link? Log it for security. This feedback helps you maintain clean email lists and track user behavior.

## Transactional Email Best Practices

These practices will save you from common problems:

**Send emails immediately.** Users expect transactional emails now, not in five minutes. When someone resets a password, they're sitting at the login screen waiting. Every second of delay increases support tickets. Configure your service for immediate sending, not batched delivery.

**Write clear, actionable content.** Tell users exactly what happened and what to do next. "Click here to reset your password" beats "We've received your request." Include all necessary information. Order confirmations need order numbers, items purchased, total cost, and delivery estimates. Don't make users guess or search.

**Set up authentication properly.** SPF, DKIM, and DMARC aren't optional anymore. As of February 2024, Gmail and Yahoo require them for bulk senders (those sending over 5,000 emails a day).[^12] [^13] Even for transactional email, proper authentication improves deliverability. Most good services handle this automatically, but verify it's configured.

**Keep transactional and marketing separate.** Never send both through the same stream. Marketing emails will generate complaints. Those complaints will hurt your transactional reputation. Use different services, different subdomains, or at minimum different message streams.[^4] [^5]

**Remove bad emails immediately.** When an email bounces, remove it from your system. Don't keep trying to send to dead addresses. High bounce rates hurt your sender reputation, which hurts deliverability for everyone else. Set up webhook handlers to process bounces automatically.

**Test everything first.** You must send test emails before going live. Check that templates render correctly, verify dynamic data appears properly and confirm emails arrive quickly. Use your service's sandbox or test mode. Don't debug in production when it's too late.

**Monitor constantly.** Track delivery rates, bounce rates, and complaint rates, and watch out for sudden changes. A spike in bounces might mean a problem with your signup form and slow delivery might indicate service issues. Set up alerts for anomalies. Fix problems before users complain.

## Where Bento Fits: Transactional Email with Deliverability Built-In

If you're evaluating transactional email services, here's what Bento offers.

**Full API access for transactional sending.** Bento provides REST APIs, webhooks, and SDKs for all major languages. Your application can send transactional emails programmatically, just like with Postmark or SendGrid. The API is fast, reliable, and well-documented.

**Deliverability infrastructure included.** Most transactional services make you handle deliverability yourself. You will need to set up SPF records, configure DKIM, monitor blocklists, deal with reputation issues etc. Meanwhile, Bento includes all this infrastructure in the base price. Authentication setup, reputation monitoring, and delivery optimization come standard, without any extra price. You focus on your app, not email infrastructure.

**Separate streams protect reputation.** Bento separates transactional and marketing emails automatically. Marketing complaints won't affect transactional delivery. This isolation is critical if you're sending both types of emails. Your newsletter can have engagement problems without breaking password resets.

**Smart batching for volume spikes.** Launch day hits, you get 1,000 signups in an hour. That's 1,000 welcome emails firing instantly. Dumping them all at once looks suspicious to ISPs. Bento spreads these sends over time, maintaining natural delivery patterns. Your emails arrive reliably even during traffic spikes.

**When to use Bento:** You want transactional email that works without becoming an email expert. You value deliverability and want infrastructure included. You're sending both transactional and marketing emails and need proper separation. You want one platform that handles everything.

**When to use alternatives:** Postmark if you need the absolute fastest delivery (they're unbeatable on speed).[^6] Amazon SES if you want the cheapest possible option and can handle complexity.[^14] Mailgun if you're building custom email infrastructure and need maximum flexibility.[^15]

Bento might not be the fastest nor cheapest. But if you want transactional email that includes everything you need for good deliverability, it's worth considering. Most developers underestimate how much work goes into email deliverability. Bento handles that complexity for you.

[Start your free 30-day trial today](https://bentonow.com/signup) or book a demo with our team.

## Ready to Build Transactional Email?

Pick a service with serious uptime guarantees - this means 99.9% or better.[^8] Transactional email failures directly break user experiences. When your email service goes down, users can't reset passwords or receive purchase confirmations. That's immediate, visible failure.

Speed matters more than features. A simple API that delivers in 5 seconds beats a complex platform that takes 30 seconds. Users are literally waiting for these emails. Pick services that prioritize transactional speed.[^6] [^7]

Keep transactional and marketing completely separate. Different services, different subdomains, different everything as this isolation protects your critical emails when marketing campaigns have problems.

Set up monitoring from day one. You need to track delivery rates, bounce rates, and speed. You want to know about problems before users complain. Most services provide webhooks so use them and log everything. Set up alerts for anomalies.

Pay attention to deliverability features. Fast delivery means nothing if emails land in spam. Look for services that handle authentication automatically. SPF, DKIM, and DMARC should be standard. Reputation monitoring should be included.

**Start simple.** Pick one service that fits your needs. Integrate it properly. Test thoroughly. Monitor constantly. You can always add complexity later. But get the basics working first.

**Related resources:** For detailed comparisons, see our [transactional vs marketing email](https://bentonow.com/posts/transactional-vs-marketing-Email-differences) guide. For service recommendations, check [best transactional email services](https://bentonow.com/posts/best-transactional-email-services). For deliverability deep dives, read [email deliverability tools](/posts/email-deliverability-tools).

## References

[^1]: [Mailchimp: About Transactional Email](https://mailchimp.com/help/about-transactional-email/)
[^2]: [EmailIndustries: Is a Welcome Email a Transactional Email?](https://www.emailindustries.com/email-marketing/is-a-welcome-email-a-transactional-email/)
[^3]: [Klaviyo: Email Deliverability Best Practices for Gmail & Outlook](https://www.klaviyo.com/blog/outlook-gmail-deliverability)
[^4]: [Postmark: A better way to send all your application email](https://postmarkapp.com/message-streams)
[^5]: [Twilio SendGrid Docs: IP Pools](https://www.twilio.com/docs/sendgrid/ui/account-and-settings/ip-pools)
[^6]: [Zapier: The 7 best transactional email services](https://zapier.com/blog/best-transactional-email-sending-services/)
[^7]: [Twilio SendGrid: Email API](https://sendgrid.com/en-us/solutions/email-api)
[^8]: [Twilio SendGrid: Proven Email Infrastructure](https://sendgrid.com/en-us/solutions/email-api/proven-email-infrastructure)
[^9]: [Mailchimp: Mailchimp Transactional Email API | Mandrill](https://mailchimp.com/features/transactional-email-infrastructure/)
[^10]: [Cloudflare: What are DMARC, DKIM, and SPF?](https://www.cloudflare.com/learning/email-security/dmarc-dkim-spf/)
[^11]: [Mailgun: What Is SMTP?](https://www.mailgun.com/blog/deliverability/what-is-smtp/)
[^12]: [Google Workspace Admin Help: Email sender guidelines](https://support.google.com/a/answer/81126?hl=en)
[^13]: [Yahoo Sender Best Practices](https://senders.yahooinc.com/best-practices/)
[^14]: [Amazon SES Pricing](https://aws.amazon.com/ses/pricing/)
[^15]: [Mailgun: Transactional Email API Service For Developers](https://www.mailgun.com/)

Learn what transactional email is and how it's used. Understand the difference between transactional and marketing emails, and why transactional emails need specialized services.

What Is Transactional Email? Complete Guide for Developers

Email bounces happen when your message can't reach its destination. Maybe you typed the address wrong. Maybe the inbox is full. Or maybe a spam filter blocked you. Understanding bounces saves your sender reputation from tanking.

## TL;DR: Bounce Management That Protects Deliverability
- __Hard bounces__ mean the address is dead. Remove it from your list today.
- __Soft bounces__ are temporary problems. Try sending again a few times, then give up.
- __Keep bounce rates under 2%__ with email validation, double opt-in, and regular list cleaning.

## Understanding Hard Bounces vs Soft Bounces

### Hard bounces mean game over
A hard bounce means that email address is done. The user doesn't exist, the domain shut down, or the server permanently blocked you. When you get a hard bounce, that address needs to come off your list immediately.

Gmail, Yahoo, and other providers track how often you send to dead addresses. Keep hitting those same bad addresses and your sender score drops fast. Once that happens, even your good emails start landing in spam.

Common hard bounce causes include invalid email addresses (typos like "gmial.com"), deleted accounts where users closed their email, and domain blocks where entire domains reject your mail. ISPs also issue hard bounces for reputation problems if they've permanently blacklisted your sending domain.

### Soft bounces are temporary setbacks
Soft bounces mean something's wrong right now, but it might work later. This bounce can indicate various things: the mailbox could be full, the server might be down, your message might be too big.

With soft bounces, you get a few more chances. Most email services try 3 to 5 times over 48 hours. After that, if the address still bounces, treat it like a hard bounce and remove it.

Typical soft bounce scenarios include full mailboxes when users hit their storage limit, server timeouts during maintenance windows, and message size limits when attachments are too large. Greylisting also causes soft bounces, where new senders get temporarily rejected as an anti-spam measure.

## Reading Bounce Codes Like a Pro
Every bounce comes with a code that tells you what went wrong. These SMTP response codes follow a pattern where the first digit tells you severity, the second indicates the category, and the third provides specific details.

The most common codes you'll see:

- __550 5.1.1__ means the user doesn't exist (hard bounce)
- __550 5.7.1__ means your message got rejected by policy (hard bounce)
- __552 5.2.2__ means the mailbox is over quota (can be hard or soft)
- __421 4.2.1__ means the server is temporarily unavailable (soft bounce)
- __450 4.2.2__ means the mailbox is temporarily full (soft bounce)
- __451 4.3.0__ means temporary system error (soft bounce)

Each email provider adds their own flavor to these codes. Google might say "The email account that you tried to reach does not exist" while Microsoft says "Recipient address rejected: User unknown." Build yourself a translation guide for the providers you send to most.

## Your Bounce Handling Game Plan
Good bounce management starts with capturing bounce notifications in real-time. Your email service provider or SMTP relay sends these through webhooks or bounce messages sent to a return-path address. Process them immediately, not in batches hours later.

### Step 1: Capture bounce data immediately
Set up webhooks from your ESP to get instant notifications. If you're running your own mail server, configure a dedicated bounce mailbox and parse those messages. Store the raw bounce data including timestamps, error codes, and the full bounce message.

### Step 2: Classify bounces accurately
Parse those error codes to determine if it's hard or soft. Don't just look at the code number. Check the actual message text too. Some providers use non-standard codes, so pattern matching on the text helps catch edge cases.

### Step 3: Take action based on bounce type
Hard bounces get suppressed immediately. No debates, no second chances. Add them to your suppression list so they never get mailed again. Soft bounces go into a retry queue. Space out your retries over 24-48 hours. If an address soft bounces consistently for a week, convert it to a hard bounce.

### Step 4: Track patterns and trends
Log everything. Which campaigns generate the most bounces? Are certain email domains bouncing more than others? Did bounce rates spike after you changed something? This data helps you spot problems before they wreck your reputation.

### Step 5: Set up smart alerts
Configure alerts when your bounce rate exceeds 2% for any campaign. Also watch for sudden spikes in bounces from specific domains, which often means you've been blocked. Alert on unusual bounce messages that might indicate new filtering rules.

## Preventing Bounces Before They Happen
The best bounce is the one that never happens. Start by validating email addresses when people sign up. Real-time validation APIs catch typos and fake addresses before they enter your database. Double opt-in adds friction but guarantees the address works and the person wants your emails.

Regular list hygiene keeps bounce rates low. Remove subscribers who haven't opened an email in 6 months as they've probably abandoned that address. Before big campaigns, run your list through an email verification service. It costs money but saves your reputation.

Watch for common typo domains in your signup forms. People type "gmial.com" or "yahooo.com" more than you'd think. Add client-side validation that suggests corrections for these common mistakes. Also check for role addresses like "info@" or "admin@" which often have stricter filtering.

When you start sending from a new IP address or domain, warm it up slowly. Send to your most engaged users first. Start with 50 emails on day one, then double the volume each day. This gradual ramp-up builds trust with receiving servers.

## Bounce Rate Benchmarks That Matter
Your overall bounce rate should stay under 2%. That's the industry standard that keeps ISPs happy. Break it down further for better insights.

Hard bounce rates above 0.5% suggest list quality problems. Maybe your signup form accepts fake addresses, maybe you bought a list (don't do that) or maybe you haven't cleaned your list in too long.

Soft bounce rates vary more by provider and time of year. During holidays, expect more full mailboxes. Corporate addresses bounce more on weekends when servers run maintenance. Track your baseline and investigate when rates double.

Unknown bounce rates above 1% mean your bounce processing needs work. You're not classifying bounces correctly, which makes it hard to fix the real problems.

Campaign-specific bounce rates tell their own story. Welcome emails should bounce less than 1% since addresses are fresh, while re-engagement campaigns might hit 5% or higher, which is normal for dormant lists. Know what's normal for each campaign type.

## Common Bounce Scenarios and Solutions

### List imports gone wrong
You imported a list from another system and bounce rates exploded. This comes from the fact that those addresses might be years old. Run the entire list through email verification before sending and remove anything that fails verification. Only then send a re-engagement campaign to the rest and remove non-responders.

### Sudden spike from one domain
If Gmail suddenly starts bouncing everything, you might have a reputation problem. Check Google Postmaster Tools for clues as you might be hitting spam traps or sending to too many inactive accounts. Slow down your sending and focus on engaged users until your reputation recovers.

### Consistent soft bounces
When the same addresses soft bounce repeatedly, something's broken. The mailbox might be abandoned but not closed o the server might have aggressive rate limiting. Add these to your suppression list after 3-5 attempts.

### Bounces after no changes
Your bounce rate jumped but you didn't change anything. Check if a major provider updated their filters. Microsoft and Google announce major changes, but smaller providers don't always. Your content might suddenly trigger new spam rules.

### Advanced Bounce Management Tactics
Smart senders segment their bounce handling by provider. Gmail bounces get different treatment than corporate Exchange servers. B2B addresses might deserve more retry attempts than free webmail accounts.

Create feedback loops with major providers. Yahoo and Microsoft offer programs where they'll tell you which messages got marked as spam. This isn't exactly bounce data, but it helps you understand delivery problems before they become bounce problems.

Monitor your authentication records continuously. Broken SPF, DKIM, or DMARC records cause bounces that look like reputation problems. Set up monitoring that alerts you if your DNS records change or your DKIM signatures start failing.

Build a bounce forensics process for investigating problems. When bounce rates spike, you need a checklist: Check authentication, review recent content changes, analyze which segments bounced most, compare against historical patterns, and test delivery to seed accounts.

## Where Bento Makes Bounce Management Simple
Bento handles the heavy lifting of bounce processing. Webhooks capture bounce events instantly. Our classification engine recognizes bounce patterns from all major providers. Hard bounces get suppressed automatically while soft bounces enter smart retry queues.

The platform shows real-time bounce metrics broken down by campaign, domain, and bounce type. When rates spike, you get alerts with actionable insights about what changed. List hygiene tools identify risky addresses before you send.

Integration with your existing tools means bounce suppressions sync everywhere. Your CRM, help desk, and other systems stay updated. No more accidentally emailing someone from a different system after they bounced.

## Your Bounce Management Action Plan
Start with these five steps today:

1. Check your current bounce rate. Log into your ESP and pull the numbers for your last 10 campaigns. If any exceeded 2%, you have work to do.

2. Audit your bounce processing. Send test emails to fake addresses and see how your system handles the bounces. Are they classified correctly? Are hard bounces suppressed immediately?

3. Clean your list now. Export everyone who hasn't opened in 6 months. Either run a re-engagement campaign or remove them entirely.

4. Fix your signup forms. Add email validation that catches typos in real-time. Implement double opt-in if you haven't already.

5. Set up monitoring. Configure alerts for bounce rates over 2%. Track trends weekly. Document which campaigns bounce most and why.

Learn more about keeping your emails out of spam with our guides on email deliverability tools and why are my emails going to spam.

Email bounces give you direct feedback about list quality and sender reputation. Pay attention to what they're telling you. Clean your lists regularly, process bounces properly, and your delivery rates will stay strong.


Learn about email bounces and how to handle them. Understand hard bounces vs soft bounces, bounce handling best practices, and how to reduce bounce rates.

Email Bounces: Complete Guide to Handling Bounce Messages

Learn from dunning email examples and best practices. Understand what makes effective payment recovery emails and how to design emails that recover failed payments.

Dunning Email Examples: Payment Recovery Best Practices

You've probably gotten those fake emails from "Amazon" or "PayPal" asking for your password. That's email spoofing - when someone uses your domain to send fake emails, DMARC gives email providers a way to stop them and protects your domain from scammers who send emails pretending to be you. It works by combining two other security protocols, SPF and DKIM, into one powerful shield for your domain.

But DMARC does more than just check if emails are real: it tells Gmail, Outlook, and other email providers exactly what to do with fake emails using your domain. You can tell them to send suspicious emails to spam or block them entirely. Getting this right means your real emails get delivered while the fake ones get stopped.

This guide walks through setting up DMARC for your domain, from basic DNS records to advanced policies. We'll cover the technical parts in plain language so you can protect your domain without getting lost in the details.

## TL;DR: DMARC Basics
__DMARC (Domain-based Message Authentication, Reporting & Conformance)__ combines SPF and DKIM to stop email spoofing and phishing attacks using your domain.

__How it works:__

- You need SPF or DKIM already set up (preferably both)
- DMARC policies tell email providers what to do with suspicious emails
- You get reports showing who's sending email from your domain

__The three DMARC policies:__

- p=none: Just monitor and report (start here when setting up)
- p=quarantine: Send suspicious emails to spam folders
- p=reject: Block suspicious emails completely

__What to watch out for:__ You need SPF or DKIM working first. Start with p=none to see what's happening, then slowly increase protection once you know all your legitimate emails are authenticating properly.

For setting up the prerequisites, see our SPF records guide and DKIM guide. For DMARC monitoring tools, check best DMARC tools.

## What Is DMARC?
DMARC stands for __Domain-based Message Authentication, Reporting & Conformance__. It's an email security protocol that stops people from sending fake emails that look like they come from your domain.

Think of DMARC as the bouncer at the email club: when an email shows up claiming to be from your domain, DMARC checks its ID. It uses SPF and DKIM as those ID checks and if the email fails the check, DMARC tells the email provider what to do based on your rules.

The key difference between DMARC and other email authentication is control. SPF says which servers can send email for you. DKIM adds a digital signature to prove emails haven't been tampered with, but it's DMARC that takes both of those checks and adds instructions for what happens when emails fail. Without DMARC, email providers guess what to do with suspicious emails and with it you tell them exactly how to handle it.

DMARC also sends you reports about every email claiming to be from your domain. You'll see which emails passed authentication, which failed, and where they came from. This visibility is crucial for spotting problems with legitimate emails or identifying spoofing attempts.

## How DMARC Works
DMARC authentication happens in four steps every time someone receives an email from your domain.

First, the receiving email server checks if the email passes SPF or DKIM. SPF verifies the sending server is authorized. DKIM verifies the email hasn't been changed. The email needs to pass at least one of these checks, though passing both is better.

Second, the email server looks up your DMARC policy. This is a DNS record you publish that contains your rules. The server finds this record and reads your instructions.

Third, the server follows your policy instructions. If you set p=none, it delivers the email but notes the authentication result. If you set p=quarantine, failed emails go to spam. If you set p=reject, failed emails get blocked entirely.

Fourth, the email server sends you a report about what happened. These reports come in two types - aggregate and forensic. Aggregate reports give you daily summaries of all authentication results. Forensic reports give you details about specific failed emails, though many providers don't send these for privacy reasons.

The alignment check is where DMARC gets strict. The domain in the "From" address that recipients see must match the domain that passes SPF or DKIM. If you send from newsletter@example.com, either your SPF record needs to authorize the sending server for example.com, or your DKIM signature needs to be valid for example.com. This alignment requirement stops spoofing attempts that try to bypass authentication by using different domains.

## DMARC Policies
DMARC gives you three policy options that control how email providers handle messages that fail authentication.

### p=none (Monitor Only)
The p=none policy is your starting point. Email providers deliver all emails normally but send you reports about authentication results. This is perfect when you're first setting up DMARC because you can see what's happening without breaking anything.

Use p=none to discover all the legitimate services sending email for your domain. Marketing platforms, CRM systems, password reset services, and other tools might be sending emails you forgot about. The reports will show you everything, letting you fix authentication issues before they cause problems. Most domains stay at p=none for several weeks while gathering data.

### p=quarantine (Quarantine)
The p=quarantine policy tells email providers to treat failed emails as suspicious. Most providers send these emails to spam folders, though some might add warning labels or handle them differently.

Move to p=quarantine after you've fixed authentication for all legitimate senders. This gives you protection against spoofing while still allowing recipients to check their spam folders if something important gets caught. You can also set a percentage, like pct=50, to quarantine only half of failed emails while you test the impact.

Many organizations stop at p=quarantine because it balances security with flexibility. Recipients can still retrieve emails from spam if needed, which helps when you have third-party services that occasionally fail authentication.

### p=reject (Reject)
The p=reject policy provides maximum protection. Email providers completely block emails that fail DMARC checks. These emails never reach the recipient, not even in spam folders.

Only move to p=reject when you're confident all legitimate emails will pass authentication. This usually means having SPF and DKIM both configured properly for every service that sends email for your domain. Banks, government agencies, and security-conscious organizations often use p=reject because stopping spoofing is more important than the occasional lost email.

You can use subpolicy settings to apply different rules to subdomains. Setting sp=reject with p=quarantine lets you strictly protect subdomains while keeping the main domain more flexible.

## DMARC DNS Records
DMARC policies live in your DNS as TXT records. The record name always follows the same pattern: _dmarc.yourdomain.com.

Here's a basic DMARC record:

_dmarc.example.com TXT "v=DMARC1; p=none; rua=mailto:dmarc@example.com"

This record has three parts. The v=DMARC1 identifies it as a DMARC record. The p=none sets your policy. The rua=mailto:dmarc@example.com tells providers where to send aggregate reports.

You can add more settings to fine-tune your policy. The pct tag lets you gradually roll out enforcement. Setting pct=25 applies your policy to only 25% of emails, useful when moving from quarantine to reject. The ruf tag requests forensic reports, though many providers don't send these. The sp tag sets a policy for subdomains that's different from your main domain policy.

A more advanced record might look like this:

_dmarc.example.com TXT "v=DMARC1; p=quarantine; pct=50; rua=mailto:dmarc@example.com; ruf=mailto:forensics@example.com; sp=reject"

This quarantines 50% of failed emails from the main domain, rejects all failed emails from subdomains, and requests both report types.

The record must be exactly at _dmarc.yourdomain.com. Not dmarc.yourdomain.com or yourdomain.com._dmarc. Getting the format wrong means DMARC won't work at all.

## How to Set Up DMARC
Setting up DMARC takes five steps. Each step builds on the previous one, so don't skip ahead.

__Step 1: Verify SPF and DKIM are working__. DMARC needs at least one of these authentication methods working properly. Check your SPF record includes all services that send email for you. Verify DKIM signatures are being added to your emails. Use email testing tools to confirm both are passing authentication checks. If neither SPF nor DKIM works, DMARC can't function.

__Step 2: Create your monitoring record.__ Start with this simple DMARC record that just collects data:

_dmarc.yourdomain.com TXT "v=DMARC1; p=none; rua=mailto:dmarc-reports@yourdomain.com"

Create a dedicated email address for reports. You'll get XML files that are hard to read manually, so most people use DMARC analysis tools or services that parse these reports into readable dashboards.

__Step 3: Add the record to your DNS.__ Log into your DNS provider (where your domain is registered or hosted) and add a new TXT record with the name _dmarc and paste your DMARC policy as the value. Some providers want the full _dmarc.yourdomain.com as the name. Save the record.

__Step 4: Analyze your DMARC reports for 2-4 weeks.__ Reports usually start arriving within 24 hours and then you should look for legitimate services that are failing authentication. Common culprits include marketing automation platforms, customer support tools, and forgotten services from years ago. Then add these to your SPF record or set up DKIM for them and watch your pass rates improve as you fix each service.

__Step 5: Gradually increase enforcement.__ Once your authentication pass rate is above 95%, move to p=quarantine with pct=25. This quarantines 25% of failed emails. Monitor for another week. If no legitimate emails are affected, increase to pct=50, then pct=100. After a month at full quarantine with no issues, consider moving to p=reject.

The whole process typically takes 2-3 months. Rushing through these steps risks blocking legitimate emails, so take your time.

## DMARC Reporting
DMARC reports come in two flavors, each serving different purposes.

__Aggregate reports (RUA)__ arrive daily or weekly as compressed XML files. They show statistics about email authentication from each receiving domain. You'll see how many emails passed or failed, which IP addresses sent them, and what authentication methods were used. These reports help you spot trends and identify services that need fixing.

The XML format is technical, but the data is valuable. Each report shows the sending IP address, the number of messages, SPF results, DKIM results, and the policy action taken. Free tools like DMARC Analyzer or Postmark's DMARC Digests turn these XML files into readable charts and tables.

__Forensic reports (RUF)__ are detailed reports about individual failed emails. They include message headers and sometimes partial message content. These help you investigate specific authentication failures. However, most major email providers stopped sending forensic reports due to privacy concerns - gmail, Yahoo, and Outlook don't send them anymore.

Understanding your reports helps you make informed decisions. A legitimate service showing consistent authentication failures needs to be fixed, while random IPs sending small volumes of failed emails are probably spoofers you can safely ignore. Sudden spikes in failed authentication might indicate a new spoofing campaign or a configuration change that broke authentication.

Keep report emails separate from your regular inbox. The volume can be overwhelming, especially for popular domains. Many organizations use specialized DMARC reporting services that aggregate reports from all sources and provide dashboards instead of managing raw XML files.

## DMARC Troubleshooting
Common DMARC problems have straightforward solutions once you know what to look for.

__Authentication failures from legitimate senders__ usually mean your SPF record is missing authorized servers or DKIM isn't configured. Check if the failing service is in your SPF record and verify they're signing emails with DKIM. Some services need you to enable DKIM in their settings. Marketing platforms often have DKIM disabled by default.

__DMARC record not found errors__ happen when the record format is wrong. Double-check you created the record at _dmarc.yourdomain.com exactly. The record must be a TXT record, not CNAME or another type. Make sure quotation marks in the policy are straight quotes, not curly quotes from word processors.

__Reports not arriving__ could mean several things. Check your rua email address is correct and can receive emails. Some email providers limit report sizes or block them entirely. DNS propagation can take 48 hours, so new records might not work immediately. Try using a dedicated DMARC reporting service instead of a regular email address.

__Alignment failures__ occur when the visible "From" domain doesn't match the SPF or DKIM domain. This often happens with mailing lists or forwarding services that modify emails. To fix itm, you might need to whitelist certain senders or adjust your alignment mode from strict to relaxed using the aspf=r or adkim=r tags.

__Legitimate emails getting blocked__ means you moved to enforcement too quickly. Immediately change your policy back to p=none or reduce the pct value and review your reports to find what service is failing authentication. You should fix the authentication issue before trying enforcement again.

Testing changes takes time because of DNS caching. After updating your DMARC record, wait at least a few hours before testing. Some email providers cache DNS for 24 hours, so full propagation takes time.

## Where Bento Fits: DMARC Setup Included
Setting up DMARC yourself means juggling DNS records, authentication protocols, and report analysis. Here's how Bento handles these complexities for you.

__Guided DMARC setup.__ Bento walks you through creating DMARC records that work with your sending setup. Instead of guessing at the right configuration, you get specific instructions based on your domain and sending patterns. The platform verifies your records are formatted correctly and published properly.

__Built-in authentication monitoring.__ Bento tracks your SPF, DKIM, and DMARC status continuously. If authentication starts failing, you get alerts before it affects deliverability. The dashboard shows your authentication health at a glance, no XML parsing required.

__Deliverability infrastructure included.__ Most email services charge extra for deliverability features or require separate tools, but Bento includes authentication setup, reputation monitoring, and delivery optimization in the base platform. You don't need multiple tools to manage email security.

__When Bento makes sense:__ You want DMARC protection without becoming an email authentication expert. You're sending marketing, transactional, or automated emails and need them to reach inboxes. You'd rather focus on your business than troubleshooting DNS records.

__When specialized tools make sense:__ You need forensic-level DMARC analysis across multiple domains. You're managing email authentication for an enterprise with complex requirements. You want detailed reports about every authentication attempt.

__The honest pitch:__ Bento won't replace dedicated DMARC analysis platforms for large enterprises as those tools provide deeper analytics and more granular control. But if you want reliable email delivery with authentication handled correctly, Bento gives you that without the complexity or additional costs.

## Ready to Set Up DMARC?
__1.__ Start by checking your SPF and DKIM setup. Both need to work before DMARC can protect your domain. Test your current authentication using online tools to see what's already working.

__2.__ Create a monitoring DMARC record with p=none. This lets you see what's happening without affecting email delivery. Use a dedicated email address for reports or sign up for a DMARC monitoring service. 

__3.__ Add your DMARC record to DNS through your domain provider. Most providers have guides for adding TXT records. Copy your record exactly, including all semicolons and quotation marks.

__4.__ Watch your reports for at least two weeks. Fix any legitimate services that are failing authentication. Add missing services to SPF, enable DKIM where possible, and verify alignment is working.

__5.__  Once authentication is solid, gradually increase enforcement. Start with p=quarantine at 25%, then increase the percentage weekly. Only move to p=reject when you're completely confident in your setup.

__Related resources:__ Master the basics with our SPF records guide and DKIM guide. Compare monitoring options in best DMARC tools. For complete deliverability setup, see email deliverability tools.

DMARC stops spoofing and improves deliverability, but only when set up carefully. Take time to monitor before enforcing policies. Your domain's reputation depends on getting this right.


Learn what DMARC is and how to set it up for email authentication. Understand DMARC policies, DNS configuration, and how DMARC protects your domain from spoofing.

DMARC: Complete Guide to Email Authentication and Protection

The domain you send emails from determines whether you land in the inbox or spam folder. Most companies get this wrong. They create clever-sounding domains for campaigns or stick everything on one subdomain. Both approaches can hurt deliverability.

This guide walks you through organizing your sending domains properly, following M³AAWG guidelines that Gmail, Outlook, and other major providers use to evaluate your emails.

## TL;DR: Use Subdomains, Not Cousin Domains

If your company is example.com, send from news.example.com, offers.example.com, or support.example.com. Never create "cousin domains" like example-deals.com or get-example-offers.com. They look fake to spam filters and destroy your deliverability.

## Understanding Domain Trust

Email providers judge domains the same way people judge storefronts. A Louis Vuitton store in a luxury mall gets instant trust. A "Luis Vutton Deals" shop in a strip mall gets suspicious looks.

When recipients see offers.nike.com in their inbox, they recognize Nike immediately. Nike-super-deals.com triggers alarm bells. People make this judgment in under a second. Spam filters work exactly the same way.

The choice between using a subdomain of your main domain versus creating a separate "cousin" domain determines your email fate. One builds trust. The other destroys it.

## Cousin Domains Kill Deliverability

Cousin domains are separate domains that try to look related to your brand. Summer-deals-at-example.com. Shop-example-now.com. Example-exclusive-offers.net. Companies register these thinking they're being creative with campaign names.

Recipients and spam filters can't verify these domains belong to you. They match exactly what phishing attacks look like. Most companies forget to redirect these domains to their main site. Someone clicks through and hits a dead page. Everything about it screams scam.

You don't need special domains for seasonal campaigns or promotions. Summer.example.com works better than summer-deals-at-example.com. Shop.example.com beats shop-example-now.com every time. Subdomains give you campaign flexibility without sacrificing trust.

## Subdomains: The Professional Approach

Subdomains keep all your email under one trusted umbrella while letting you segment different types of communication. Every successful email program uses this structure.

Marketing emails go through descriptive subdomains: offers.example.com for promotions, news.example.com for newsletters, updates.example.com for product updates. Transactional emails that customers expect use info.example.com for general notifications, orders.example.com for purchase confirmations, account.example.com for password resets.

Regional operations get their own subdomains too. UK.example.com for British customers, eu.example.com for European Union, asia.example.com for Asian markets. Different departments use support.example.com for customer service, sales.example.com for outreach, hr.example.com for internal communications.

Recipients instantly recognize anything ending in example.com as legitimate. Your subdomains inherit trust from your main domain's reputation. You manage everything under one domain registration. Each subdomain builds its own reputation for different content types. The whole system looks professional to everyone involved.

## Planning Your Subdomain Structure

Most companies send more types of email than they realize. Take inventory of everything you send. Marketing campaigns including newsletters, promotions, and product launches. Transactional emails covering order confirmations, shipping notifications, and receipts. Account emails for password resets, welcome messages, and profile updates. Support emails containing ticket responses, help articles, and status updates. Don't forget internal communications if you email employees.

Map each email type to a clear subdomain. Keep names short and obvious. News.example.com beats x7news.example.com. Offers.example.com wins over DEALS.example.com. Orders.example.com crushes trans_01.example.com. Help.example.com works better than noreply.example.com, especially since Outlook started penalizing no-reply addresses in 2024.

## Email Header Alignment Matters

Your email headers work like business cards. When all your contact information matches across cards, website, and emails, people trust you more. Email authentication works the same way.

Using a subdomain like news.example.com means aligning everything. Your Return-Path shows bounce@news.example.com. The From address displays hello@news.example.com. DKIM Signature contains d=news.example.com. Reply-To directs to feedback@news.example.com. Everything points to the same subdomain, creating perfect alignment that authentication systems love.

You can also keep your main domain in the From address while maintaining organizational alignment. Return-Path uses bounce@bounce.example.com. From displays hello@example.com. DKIM Signature shows d=example.com. Reply-To goes to support@example.com. Everything stays under the example.com umbrella, preserving trust while giving you flexibility.

## DNS Configuration Options

Three main approaches exist for setting up subdomain DNS records. Each offers different trade-offs between control and convenience.

Direct setup works when you manage your own DNS. You add SPF records specifying which servers send mail. MX records handle bounces. A records enable web tracking. DKIM keys provide authentication. You control everything and can update instantly. The downside is needing technical knowledge to manage it properly.

CNAME delegation lets your email service provider manage certain records. Bento uses this approach, handling DNS complexity for you. You point subdomains to your ESP's servers using CNAMEs. They manage the technical details. Your ESP can optimize settings without bothering you, though you lose some visibility into what's happening.

NS delegation completely hands off a subdomain to your ESP, though few companies choose this. You delegate the entire subdomain to their nameservers. Zero maintenance required, but you give up all control. Most avoid this unless they have unusual requirements.

CNAME delegation typically offers the best balance. You maintain overall control while your ESP handles the complex stuff.

## Volume Guidelines for Subdomains

Each subdomain needs sufficient volume to build reputation without concentrating too much risk in one place.

Low-volume senders under 100,000 emails monthly can use a single subdomain or domain. Simple to manage with enough volume to establish basic reputation.

Medium-volume senders between 100,000 and 1,000,000 monthly should separate marketing from transactional mail. Consider also geographic splits if you serve distinct regions.

High-volume senders over 1,000,000 monthly need dedicated subdomains per email type. Geographic subdomains become essential. Department-specific domains help distribute load. Multiple DKIM selectors prevent bottlenecks.

The optimal range sits between 100,000 and 500,000 emails monthly per subdomain. Below 100,000, reputation never solidifies and delivery stays unpredictable. 

## Migration Without Disruption

Moving from your main domain or cousin domains to proper subdomains requires careful planning to maintain delivery during transition.

Start with foundation work. Create your subdomain infrastructure. Configure SPF, DKIM, and DMARC for each subdomain. Test with your internal team first. Send to your most engaged 5% of subscribers or activate a few low-volume automations.

Then transition gradually over two weeks. Move transactional emails first since they get better engagement. Ramp volume from 5% to 25% to 50% to 100%. Watch your metrics constantly. Keep old domains active as fallback options.

Finally, complete the switch. Migrate all remaining volume. Set up forwarding from old addresses. Update every template and system. Monitor closely for the first month to catch any issues early.

## Mistakes That Hurt Deliverability

Using mail.example.com for everything defeats the purpose of subdomains. You lose segmentation benefits and concentrate reputation risk. Split email types across multiple subdomains instead.

Cryptic names like esp47.example.com or x3n.example.com confuse recipients. People see these in their inbox and immediately get suspicious. Pick clear, descriptive names that make instant sense.

Setting up subdomains then ignoring them causes problems to compound silently. Schedule monthly reviews of each subdomain's performance. Check authentication passes, engagement rates, and spam complaints.

## Security for Your Subdomains

Subdomains need the same protection as your main domain. Configure DMARC policies for each one. Monitor for unauthorized usage weekly. Upgrade to 2048-bit DKIM keys. Protect against subdomain takeover attacks. Audit configurations quarterly. Document every active subdomain in a central location.

## Implementation Timeline

Start today by auditing your current setup. List every email type you send. Match each to an appropriate subdomain. Takes about 30 minutes.

This week, check subdomain availability with your DNS provider. Decide between direct setup, CNAME delegation, or NS delegation. Coordinate timing with your ESP. Budget 2-3 hours total.

Over two weeks, implement DNS changes methodically. Verify authentication with testing tools. Start your gradual migration. Monitor everything closely.

## Essential Tools

Planning requires basic tools. A spreadsheet works fine for mapping subdomain structure. DNS checkers verify your configurations. Authentication validators test SPF, DKIM, and DMARC.

Monitoring needs ongoing attention. Postmaster tools from Gmail and Outlook track subdomain reputation. DMARC reports show authentication success rates. Your ESP provides engagement metrics per subdomain.

## Scaling Your Domain Strategy

Your subdomain approach evolves with growth.

Startups with under 50,000 subscribers keep things minimal. One or two subdomains maximum. Focus entirely on authentication basics.

Growing companies from 50,000 to 500,000 subscribers expand strategically. Three to five subdomains organized by purpose. Geographic separation if serving multiple regions.

Enterprise senders over 500,000 subscribers need complete architecture. Department and regional subdomains. Multiple DKIM selectors for load distribution. Dedicated IPs for critical subdomains.

## Build on Solid Ground

Your sending domain forms the foundation of your email program. Cousin domains crumble under scrutiny. Subdomains stand strong.

ISPs expect subdomain structures. Recipients recognize and trust them. Major brands all use them. They work consistently, build reputation effectively, and scale with your growth.

Start with three core subdomains. News.yourdomain.com handles marketing. Account.yourdomain.com manages transactional mail. Support.yourdomain.com covers customer service. Expand from there as needed. The foundation matters more than the size.

Choosing the right domain for your email campaigns isn't just a technical decision—it's the foundation of your email deliverability. Get it wrong, and even your best content lands in spam. Get it right, and you build lasting trust with both recipients and email providers.

The Complete Guide to Email Sending Domains: Why Your Choice Matters More Than You Think

How to organize your email sending domains (basic guide)

I've seen emails with every trendy design element you can imagine: gradients, animations, complex layouts. Yet, most of them still fail at the basics. Modern email design focuses on something simpler: making sure your message gets read. That means it has to load fast, look good on any device, and work in Outlook without breaking.

## TL;DR: Email Design That Actually Works
- Build for mobile first with single columns and big buttons. 
- Keep text readable in both light and dark mode. 
- Test in Gmail, Outlook, and Apple Mail before sending. 
- If it breaks in Outlook, fix it, as your subscribers use Outlook.

## The Foundation of Good Email Design
### Mobile comes first, desktop comes second
About 60% of email opens happen on mobile devices. Some industries even see 70% or higher. You need single-column layouts that flow naturally on small screens. Body text should be at least 14px, but 16px is better, while buttons need to be 44px tall minimum, or people will miss them with their thumbs.

Desktop design is just the mobile design with more breathing room. If you start with desktop and try to shrink it down, you'll end up with tiny text and buttons nobody can tap.

### White space makes everything better
Cramming content into an email makes it harder to read, not easier. You need padding around sections, space between paragraphs, and margins around images. When an email feels cluttered, people close it; when it feels clean, they keep reading.

We've tested this with actual campaigns - emails with generous white space get 15-20% better click rates than packed layouts. The extra scrolling doesn't hurt engagement if the content flows well.

### Typography does the heavy lifting
Your font choices actually matter more than your color scheme. Body text needs to be readable at arm's length on a phone. That means 14-16px minimum, with line height around 1.5. Headlines should be noticeably bigger, but not huge. You want contrast between elements, not a circus poster.

Stick to system fonts or web-safe options. Custom fonts look nice until they fail to load, then your carefully crafted email turns into Times New Roman. Meanwhile, Georgia, Helvetica, and Arial work everywhere. If you want something different, use it for headlines only and include a fallback.

### Dark mode changes everything
Half of email users have dark mode enabled, but you have to keep in mind that Gmail, Outlook, and Apple Mail all handle it differently. Some invert your colors automatically, while others respect your media queries. A few do both, depending on settings.

The safe approach is to design with both modes in mind from the start. Use transparent PNGs for logos, pick background colors that work when inverted and test how your email looks when Gmail forces dark mode, because it will.

### Accessibility isn't optional anymore
Every image needs alt text that describes what it shows. Links need to make sense without color cues. Your HTML should use proper heading tags, not just big bold text. Screen readers need structure to navigate.

This isn't just about compliance - about 15% of people have some form of disability that affects how they use email. When you make emails accessible, you make them work better for everyone. Clear hierarchy helps speed readers, while good contrast helps people reading in bright sunlight.

### Your brand needs to show up consistently
People decide whether to open, read, or delete an email in seconds. They need to recognize it's from you immediately. Use the same header layout, colors, and tone across all your emails. Match what they see in your app or website.

But don't overdo it: a simple logo in the header and your brand colors on buttons is enough. The goal is recognition, not turning every email into a brand manifesto.

## Current Design Trends (and Whether They're Worth It)
### Dynamic content and personalization
Showing different content based on location, purchase history, or behavior can boost engagement, but you need fallbacks for when data is missing. A broken personalization token looks worse than no personalization at all.

The technical overhead is real. You need clean data, proper segmentation, and testing for every variation. Start simple with first name personalization and product recommendations before trying complex dynamic blocks.

### Interactive elements in email
AMP for Email and CSS animations work great in Gmail and Apple Mail. You can build carousels, accordions, and even shopping carts right in the email. Engagement rates jump when people can interact without clicking through.

But Outlook users see none of it, neither do many corporate email systems. You need static fallbacks that convey the same information. If the interactive version is critical to your message, you're doing it wrong.

### Illustrations and custom graphics
Custom illustrations make emails feel warmer and more human - they work especially well for onboarding, feature announcements, and holiday campaigns, but they come with tradeoffs.

File size matters. A beautiful hero image that takes 10 seconds to load on mobile data isn't helping anyone. Optimize everything. Use SVGs for simple graphics. Keep detailed images under 200KB. Test loading times on slow connections.

### Minimalist and brutalist designs
Simple layouts with bold typography and limited color palettes are having a moment. They load fast, work everywhere, and feel modern. The constraint forces you to focus on message clarity.

This works best for transactional emails and product updates. Marketing campaigns might need more visual interest to stand out in crowded inboxes. Know your audience and test what resonates.

### Motion and animation
GIFs still work everywhere, which makes them the safe choice for adding motion. Keep them under 1MB, loop smoothly, and make sure the first frame works as a static image. Some email clients only show that first frame.

CSS animations are smoother but have limited support and Lottie animations look amazing but need fallbacks. Use motion to enhance the message, not replace it.

## The Testing Process That Actually Matters
### Preview in real email clients
Don't trust your ESP's preview tool alone. Test in actual clients:

- Gmail on web, iOS, and Android
- Outlook on Windows, Mac, and mobile
- Apple Mail on Mac and iOS
- Yahoo Mail on web and mobile
- Whatever your audience actually uses (check your analytics)

Each client renders HTML differently. What looks perfect in Gmail might be completely broken in Outlook. The only way to know is to test.

### Check both display modes
Open your test emails with dark mode on and off. Check forced dark mode in Gmail and Outlook mobile apps. Look for invisible text, poor contrast, and broken images. Fix what you can, accept what you can't.

### Validate the technical bits
Run your HTML through a validator. Check that all links work and point to the right places. Verify alt text is present and descriptive. Test form submissions and dynamic content. Make sure your unsubscribe link works, because that's legally required.

### Performance testing
Check file sizes for all images. Test loading on 3G mobile connections. Measure how long the email takes to render - if it's over 3 seconds, start cutting. Remove custom fonts, optimize images further, or simplify the layout.

### Accessibility audit
Run your email through an accessibility checker and test with a screen reader if possible. Verify color contrast ratios meet WCAG standards. Finally, check that the email makes sense without images loaded.

## How to Actually Build Modern Emails
### Start with your goal
Every email needs a clear purpose. Welcome series? Drive a single action. Newsletter? Deliver value. Transactional? Provide information clearly. The design should support that goal, not compete with it.

### Sketch the hierarchy first
Before touching code, map out what matters most. What do readers see first? What action should they take? How does the eye move through the content? A quick paper sketch saves hours of revision later.

### Build mobile-first
Start with a single column at 320px wide, get the flow right, make sure everything is readable and tappable, and then expand to tablet and desktop widths. The mobile version is your foundation, everything else builds on top.

### Layer in your brand
Once the structure works, add your colors, fonts, and imagery. Keep it consistent with your other touchpoints but optimized for email constraints. Your website might have parallax scrolling and video backgrounds and your email needs to load in 2 seconds on spotty wifi.

### Test, measure, and iterate
Send your email to a test list. Check rendering across clients and monitor open rates, click rates, and conversions. Then see where people drop off - each campaign teaches you something about what works for your audience.

## Making This Work with Bento
Our template system handles the technical requirements so you can focus on design and content. Responsive layouts work out of the box. Dark mode fallbacks are built in. The drag-and-drop editor outputs clean, tested HTML that works everywhere. You can customize everything or start from proven templates. 

What is great is also that our analytics show exactly how your designs perform across different clients and devices. The deliverability tools make sure your perfectly designed email actually reaches the inbox.

## Your Next Email Design
Good email design isn't about following every trend or adding every feature. Pick what serves your message and test what works for your audience. Don't forget to focus on clarity, speed, and reliability.

Start with these fundamentals - build mobile-first layouts that load fast, making typography and spacing most of the work. Then test across major email clients before sending. Once you have that foundation, you can experiment with trends that add value without breaking the basics.

The best email design is invisible. When people focus on your message instead of your layout, you've got it right.


Learn how to design modern emails. Understand current email design trends, best practices, and how to create emails that look great and engage users.

Designing a Modern Email: Best Practices and Examples

Let me explain using an analogy what it means to send emails using dedicated IPs or shared IPs.

Sending email using shared IPs are like car pooling to work with people you don't know. Yes, you get all the benefits of car pooling. But you may unknowingly be riding with a serial killer. And what happens if you get pulled over by the cops? Everyone in the car might get arrested, just in case, until things can get sorted out at the police station.

Sending email using dedicated IPs is like driving your own car. You don't have to deal with the uncertainty of whether or not criminals accompany you on your daily commute. But it'll cost you more to own your own vehicle, if you need one at all (maybe you don't need to drive a lot.)

Most email services use shared IPs by default. You share IP addresses with other senders, and the service manages reputation for you. Dedicated IPs give you exclusive use of an IP address, but you're responsible for managing reputation yourself.

Dedicated IPs aren't always better. They require IP warmup, reputation management, and higher costs. Shared IPs are often sufficient for most senders and include reputation management automatically.

Understanding when to use dedicated vs shared IPs helps you make the right choice. This guide explains the differences, when to use each, and how IP reputation affects deliverability.

Bento offers both shared IPs (default for most of our customers) and dedicated IPs for high-volume senders in good standing. And we protect the sending reputation of our shared IPs in several ways, so email deliverability remains superb for all our customers. You can read more about this below, in the section titled “Where Bento Fits...”

## TL;DR: Dedicated vs Shared IPs

**Shared IPs:**
- **What they are:** IP addresses shared with other senders
- **Best for:** Most senders, especially those sending less than 100,000 emails/month
- **Advantages:** No warmup required, reputation managed by service, lower cost
- **Disadvantages:** Reputation affected by other senders, less control

**Dedicated IPs:**
- **What they are:** Exclusive IP addresses for your sending
- **Best for:** High-volume senders (100,000+ emails/month), strict compliance requirements
- **Advantages:** Full control over reputation, isolation from other senders
- **Disadvantages:** Require IP warmup, you manage reputation, higher cost

**When to use dedicated IPs:** High-volume sending (100,000+ emails/month), strict compliance requirements, or need for reputation isolation. For most senders, shared IPs are sufficient.

**What to watch out for:** Dedicated IPs aren't always better. They require warmup, reputation management, and higher costs. Shared IPs are often sufficient and include reputation management automatically.

For understanding IP reputation, see our [how to check IP reputation](/posts/how-to-check-ip-reputation) guide. For understanding domain reputation, check [how to check domain reputation](/posts/how-to-check-domain-reputation).

## What Are Shared IPs?

Shared IPs are IP addresses shared with other senders. Multiple senders use the same IP addresses, and the email service manages reputation for all senders.

**The definition:** Shared IPs are IP addresses used by multiple senders at the same time. The email service manages IP reputation, handles warmup, and ensures responsible sending across all senders.

**How they work:** When you send emails through a shared IP service, your emails go out from IP addresses that other senders also use. The service monitors overall IP reputation and manages sending patterns to keep reputation good.

**Advantages:**
- No IP warmup required
- Reputation managed by service
- Lower cost (included in service pricing)
- Less maintenance required

**Disadvantages:**
- Reputation affected by other senders
- Less control over IP reputation
- Potential for reputation issues from other senders

Most email services use shared IPs by default. They work well for most senders without requiring extra setup or management.

## What Are Dedicated IPs?

Dedicated IPs are exclusive IP addresses for your sending. You have full control over IP reputation, but you're responsible for managing reputation yourself.

**The definition:** Dedicated IPs are IP addresses used only by your sending. You have full control over IP reputation, sending patterns, and reputation management.

**How they work:** When you use dedicated IPs, your emails go out from IP addresses that only you use. You're responsible for IP warmup, reputation management, and maintaining good sending practices.

Dedicated IPs make sense when you're sending high volumes or need strict compliance. The tradeoff is more hands-on management for complete control.

**Advantages:**
- Full control over IP reputation
- Isolation from other senders
- No reputation impact from other senders
- Better for high-volume sending

**Disadvantages:**
- Require IP warmup (4-8 weeks)
- You manage reputation yourself
- Higher cost (typically $50-200/month)
- More maintenance required

## When to Use Shared IPs

Shared IPs work best for:

**Most senders:** If you're sending less than 100,000 emails per month, shared IPs are usually enough. Most email services use shared IPs by default.

**Low to medium volume:** Shared IPs work well for low to medium volume sending. The service manages reputation, so you don't need to worry about IP warmup or reputation management.

**Cost-conscious:** Shared IPs are included in service pricing, so there's no extra cost. Dedicated IPs typically cost $50-200 per month extra.

**Simplified management:** Shared IPs require less management. The service handles warmup, reputation monitoring, and sending patterns automatically.

For most businesses, shared IPs are the right choice. They're included by default and handle reputation management behind the scenes.

## When to Use Dedicated IPs

Dedicated IPs work best for:

**High-volume sending:** If you're sending 100,000+ emails per month, dedicated IPs may provide better deliverability. High volume can benefit from reputation isolation.

**Strict compliance:** If you have strict compliance requirements like HIPAA or financial services, dedicated IPs provide better control and isolation.

**Reputation isolation:** If you need to isolate your sending reputation from other senders, dedicated IPs give you full control.

**Custom sending patterns:** If you need custom sending patterns or specific IP configurations, dedicated IPs give you full control.

Consider dedicated IPs if you're sending 100,000+ emails monthly or need compliance isolation. Otherwise, shared IPs typically provide better value.

## IP Reputation Impact

IP reputation affects deliverability:

**Shared IPs:** Reputation is shared across all senders. Good senders benefit from good overall reputation, but bad senders can hurt reputation for everyone.

**Dedicated IPs:** Reputation is isolated to your sending. You have full control but are responsible for maintaining good reputation yourself.

Your IP reputation directly determines whether emails reach inboxes or spam folders. With shared IPs, the service handles this for you. With dedicated IPs, you're responsible for building and maintaining reputation.

## IP Warmup Requirements

IP warmup affects IP choice:

**Shared IPs:** No warmup required. The service manages warmup and reputation for all senders.

**Dedicated IPs:** Require 4-8 weeks of warmup. You must gradually increase sending volume to build reputation.

IP warmup adds 4-8 weeks to your timeline with dedicated IPs. Shared IPs skip this entirely since the service has already established reputation.

## Cost Comparison

Cost affects IP choice:

**Shared IPs:** Included in service pricing. No additional cost for shared IPs.

**Dedicated IPs:** Typically $50-200/month extra. Additional cost for dedicated IPs plus reputation management.

Cost differences are significant. Shared IPs come included with your service, while dedicated IPs typically add $50-200 per month plus the time investment for warmup and management.

## Where Bento Fits: Shared IPs with Reputation Management

If you're choosing between dedicated and shared IPs, here's where Bento fits-especially if you want shared IPs with reputation management included.

**Shared IPs by default.** Bento uses shared IPs by default, which is sufficient for most senders. Shared IPs include reputation management automatically.

**Reputation monitoring included.** Bento monitors IP reputation, tracks complaint rates and engagement, and alerts you to issues. This helps you maintain good reputation even on shared IPs.

**Batching controls included.** Bento batches sends over time, spreading volume naturally instead of dumping everything into inboxes at once. This helps maintain good reputation on shared IPs.

**When Bento makes sense:** You're sending emails and want shared IPs with reputation monitoring and batching controls included. You care about inbox placement enough to want emails that send responsibly.

**When dedicated IPs make sense:** You're sending 100,000+ emails/month, you have strict compliance requirements, or you need reputation isolation. Dedicated IPs provide full control but require more management.

**The honest pitch:** Bento uses shared IPs by default because they work well for most senders. If you're sending 100,000+ emails monthly or need compliance isolation, we can set up dedicated IPs. But for most businesses, shared IPs with reputation monitoring provide better value than managing dedicated IPs yourself.

## Next Steps: Choose Your IP Strategy

Choosing between dedicated and shared IPs depends on your sending volume and requirements. Here's how to choose:

**Step 1: Evaluate sending volume.** How many emails do you send per month? Shared IPs are sufficient for most senders (less than 100,000/month). Dedicated IPs are best for high-volume sending (100,000+ emails/month).

**Step 2: Assess compliance requirements.** Do you have strict compliance requirements? Dedicated IPs provide better control and isolation for compliance needs.

**Step 3: Consider cost.** Shared IPs are included in service pricing. Dedicated IPs typically cost $50-200/month extra. Factor cost into your decision.

**Step 4: Evaluate management needs.** Shared IPs require less management. Dedicated IPs require IP warmup and reputation management. Consider your management capabilities.

**Step 5: Test with shared IPs first.** Start with shared IPs and evaluate deliverability. Most senders don't need dedicated IPs. Upgrade to dedicated IPs only if you have specific requirements.

**Related resources:** For understanding IP reputation, see our [how to check IP reputation](/posts/how-to-check-ip-reputation) guide. For understanding domain reputation, check [how to check domain reputation](/posts/how-to-check-domain-reputation). And for understanding email infrastructure, see [email deliverability tools](/posts/email-deliverability-tools).

Choosing between dedicated and shared IPs depends on your sending volume and requirements. Evaluate sending volume, assess compliance requirements, consider cost, evaluate management needs, and test with shared IPs first. Ready to choose your IP strategy? Start with shared IPs, evaluate deliverability, then upgrade to dedicated IPs only if you have specific requirements.

Learn the difference between dedicated and shared IPs for email. Understand when to use dedicated IPs vs shared IPs and how IP reputation affects deliverability.

Dedicated vs Shared IPs for Email: When to Use Each

Three ports handle email sending: 25, 465, and 587. Each works differently. Pick the wrong one, and your emails get blocked or fail to send. Pick the right one, and everything works smoothly.

Many developers hit this problem when setting up email for the first time. You configure everything correctly, but emails won't send. The culprit? You're using port 25, which your ISP blocks. Switch to port 587, and suddenly it works.

This guide explains which SMTP port to use, why it matters, and how to configure it properly. If you'd rather not worry about any of this and you'd prefer to send transactional and marketing emails without needing a PhD in email infrastructure, [just use Bento](https://bentonow.com/email-deliverability).

## TL;DR: Quick SMTP Port Reference

**Port 587 (Use This One):**
- **What it is:** SMTP with STARTTLS encryption
- **When to use:** Sending emails from apps, websites, or email clients
- **Encryption:** Starts plain, upgrades to encrypted (STARTTLS)
- **ISP blocking:** Works everywhere

**Port 465 (Also Good):**
- **What it is:** SMTP with immediate SSL/TLS
- **When to use:** When you need encryption from the start
- **Encryption:** Always encrypted (SSL/TLS)
- **ISP blocking:** Works everywhere

**Port 25 (Usually Won't Work):**
- **What it is:** Original SMTP port
- **When to use:** Only for server-to-server mail relay
- **Encryption:** None by default
- **ISP blocking:** Blocked by most ISPs

**Quick tip:** Use port 587 for almost everything. If that doesn't work, try 465. Avoid port 25 unless you're running a mail server.

For SMTP basics, see our [everything about SMTP](/posts/everything-about-smtp) guide. For service comparisons, check [best SMTP email services](/posts/best-smtp-email-services).

## What Are SMTP Ports?

Think of SMTP ports like different doors into a mail server. Each door has its own rules about who can enter and what security checks they need to pass.

Your email client or application knocks on one of these doors when it wants to send mail. The port you choose determines whether you need a special key (encryption), whether the door is even open (ISP blocking), and what kind of mail you're allowed to send.

The three main ports serve different purposes. Port 25 was the original door, built when the internet was smaller and spam wasn't a problem. Port 465 and 587 came later, adding security features to protect against spam and eavesdropping.

## Port 587: SMTP with STARTTLS (Your Best Bet)

Port 587 is the standard for sending emails from applications and email clients. Almost every email service supports it, and it works reliably across different networks.

Here's how port 587 works: Your email client connects to the server using a regular connection. Then it asks "Hey, can we encrypt this?" The server says yes, and they switch to an encrypted connection. This two-step process is called STARTTLS.

The beauty of STARTTLS is flexibility. If a server doesn't support encryption (rare these days), the connection can still work unencrypted. But modern servers always upgrade to encryption, keeping your emails secure.

Port 587 became the standard because it solved a real problem. ISPs were blocking port 25 to stop spam, but people still needed to send legitimate emails. Port 587 gave them a dedicated port for email submission that ISPs don't block.

Gmail, Outlook, Yahoo, and virtually every major email provider uses port 587 as their primary submission port. When you configure email in Thunderbird, Apple Mail, or any email client, it defaults to port 587 for sending mail.

## Port 465: SMTP over SSL/TLS (Encrypted from the Start)

Port 465 takes a different approach to security. Instead of starting unencrypted and upgrading, it requires encryption from the very first byte. The entire conversation between client and server happens inside an encrypted tunnel.

This port has an interesting history. It was officially assigned for SMTPS (SMTP over SSL) in 1997, then revoked in 1998 in favor of STARTTLS on port 587. But email providers kept using it anyway. In 2018, the IANA officially re-assigned port 465 for "submissions" (email submission with implicit TLS).

Today, port 465 is just as valid as port 587. Microsoft uses it for Outlook.com. Google supports it for Gmail. Most modern email services offer both ports.

Some developers prefer port 465 because the encryption is simpler. There's no STARTTLS negotiation to worry about. The connection is either encrypted or it fails. This makes debugging easier and ensures encryption is always used.

The main limitation is compatibility with very old email servers that don't support implicit TLS. But if you're connecting to any mainstream email service, port 465 works perfectly.

## Port 25: Standard SMTP (The Original Port)

Port 25 is the granddaddy of SMTP ports, defined in the original 1982 specification. It was designed for one purpose: moving mail between mail servers.

When someone@gmail.com emails someone@yahoo.com, Gmail's servers connect to Yahoo's servers on port 25 to deliver the message. This server-to-server communication is what port 25 was built for, and it still handles billions of messages every day.

But here's the catch: port 25 was never meant for regular users or applications to submit email. It was designed for mail servers talking to each other. When spammers figured out they could connect directly to port 25 and send spam, ISPs started blocking it.

Today, most home and office internet connections can't reach port 25 on external servers. Comcast, AT&T, Verizon, and most ISPs block it completely. Even if your ISP doesn't block it, many email services refuse connections from residential IP addresses on port 25.

You only need port 25 if you're running your own mail server that receives email from other servers. For sending email from applications or email clients, port 25 is effectively dead.

## How to Choose the Right SMTP Port

Picking an SMTP port is simple once you know what you're building.

For 99% of use cases, start with port 587. It works with every major email service, passes through firewalls, and handles encryption properly. If your email service specifically tells you to use port 465, use that instead. Both are equally secure and reliable.

Only consider port 25 if you're building infrastructure that receives email from other mail servers. Even then, you'll still use port 587 or 465 when your server needs to send outbound mail through a relay service.

Some legacy applications only support specific ports. Old versions of Microsoft Exchange might require port 25. Some embedded systems only know port 465. In these cases, use what works. But for new development, stick with port 587.

## Common SMTP Port Configurations

Here's how major providers configure their SMTP ports. Notice the pattern: everyone supports port 587, most support port 465, and nobody recommends port 25 for client connections.

**Gmail (Google Workspace):**
- Server: smtp.gmail.com
- Port: 587 (recommended) or 465
- Encryption: STARTTLS (port 587) or SSL/TLS (port 465)
- Authentication: OAuth2 or app-specific password

**Microsoft 365 / Outlook.com:**
- Server: smtp.office365.com or smtp-mail.outlook.com
- Port: 587
- Encryption: STARTTLS
- Authentication: Modern authentication (OAuth2) preferred

**SendGrid:**
- Server: smtp.sendgrid.net
- Port: 587, 465, or 25 (not recommended)
- Encryption: TLS required on all ports
- Authentication: API key as password

**Amazon SES:**
- Server: email-smtp.[region].amazonaws.com
- Port: 587, 465, 25, or 2587
- Encryption: STARTTLS (587) or TLS Wrapper (465)
- Authentication: IAM credentials

Notice how providers offer multiple ports but always recommend 587. They support other ports for compatibility, not because they're better options.

## Debugging SMTP Port Problems

When email won't send, the port is often the problem. Here's how to diagnose port issues quickly.

First, test if you can reach the SMTP server. Use telnet or nc (netcat) to check connectivity. If you can't connect, either the port is blocked or the server is down.

```bash
# Test port 587 connectivity
telnet smtp.gmail.com 587

# Or using netcat
nc -zv smtp.gmail.com 587
```

If the connection times out, your network is blocking that port. This happens often with port 25 on home and office networks. Try port 587 or 465 instead.

Connection refused means the server isn't listening on that port. Double-check the server address and port number. Make sure you're using the right combination.

If you connect but get authentication errors, the port is working fine. The problem is with your credentials or authentication method. Modern services often require app-specific passwords or OAuth2 tokens instead of regular passwords.

Encryption mismatches cause subtle problems. Port 587 expects STARTTLS. Port 465 expects immediate SSL/TLS. Using the wrong encryption method creates confusing error messages. Match your client's encryption setting to what the port expects.

Firewall rules can block specific ports. Corporate networks often block port 25 and sometimes port 465. Port 587 usually gets through because it's the standard submission port. If you control the firewall, open the ports you need. If not, use whatever port works.

## Security Considerations for SMTP Ports

All three SMTP ports can be secure, but they handle security differently.

Port 587 with STARTTLS starts unencrypted, then upgrades to encryption. This creates a brief window where an attacker could theoretically prevent the upgrade (called a STARTTLS downgrade attack). In practice, modern email servers require STARTTLS, making this attack ineffective.

Port 465 doesn't have this theoretical vulnerability because encryption starts immediately. But it's not inherently more secure than properly configured STARTTLS. Both provide the same level of encryption once the secure connection is established.

Port 25 usually runs without encryption for server-to-server mail delivery. Servers can use STARTTLS on port 25, but many don't. This is slowly changing as email providers push for universal encryption.

Authentication is separate from port choice. All three ports support the same authentication methods: plain passwords, OAuth2, API keys, client certificates. The port doesn't determine authentication strength.

For maximum security, use port 587 or 465 with strong authentication. Enable two-factor authentication on your email account. Use app-specific passwords or API keys instead of your main password. Monitor your SMTP logs for unauthorized access attempts.

## Where Bento Fits: SMTP Port Support

If you need SMTP access for your application, Bento provides it with both port 587 and port 465 support. You get standard SMTP credentials plus the deliverability infrastructure to ensure your emails actually reach inboxes.

The platform includes authentication setup (SPF, DKIM, DMARC), reputation monitoring, and send rate controls. These features come standard, not as expensive add-ons. Your SMTP-sent emails benefit from the same deliverability infrastructure as emails sent through the API.

Bento works well when you need reliable SMTP sending with port 587 or 465, want deliverability features included in the base price, and care about inbox placement for your transactional or marketing emails.

Other services might fit better if you need port 25 for receiving inbound email, require extremely high volumes (millions per day), or want the absolute lowest price regardless of deliverability.

## Start Sending with the Right Port

Getting SMTP ports right is straightforward. Use port 587 for sending email from applications and clients. Test your connection before going to production. Monitor your email delivery to catch problems early.

Most SMTP port problems have simple solutions. Wrong port? Switch to 587. Port blocked? Try 465. Still having issues? Check your encryption settings and credentials.

Pick port 587, configure your authentication, and start sending. It really is that simple.

Learn which SMTP port to use for email sending. Understand port 25, 465, and 587, when to use each, and how to configure SMTP ports correctly.

Choosing the Right SMTP Port: Port 25, 465, 587 Explained

Find affordable email marketing software that works. Compare budget-friendly options from free plans to low-cost paid platforms that deliver results.

Cheap Email Marketing Software: Get Results on a Budget

Find the best transactional email services for developers. Compare APIs, reliability, and speed to build infrastructure that delivers emails fast.

Best Transactional Email Services: Fast, Reliable Delivery

If your childhood dream was to become an email infrastructure engineer, use Amazon SES. If your idea of self care involves configuring CloudWatch alarms, building IP warm-up schedules from scratch, or trying to decode bounce logs, use Amazon SES. If you would rather spend A LOT of time to save a little money, use Amazon SES.

No? Then you ought to use literally anything else. And by anything else, I mean use...

BENTO, THE ARTISANAL EMAIL SERVICE PROVIDER WITH END-TO-END EMAIL INFRASTRUCTURE FOR MARKETING AND TRANSACTIONAL EMAILS BUILT-IN, AND UNMATCHED CUSTOMER SUPPORT DIRECT FROM ITS FOUNDER, JESSE HANLEY.

And yeah, there are a few other options. I've included them here so this article isn't totally one-sided. Read on to find out more.

## TL;DR: Quick Picks

- **Bento** handles deliverability infrastructure so you can focus on your product. Built-in batching controls, authentication setup, warm-up management.
- **SendGrid** combines transactional emails with marketing tools. Solid SDKs for every language you need.
- **Postmark** gets your emails delivered in seconds. They keep transactional traffic separate from marketing emails so nothing slows down.
- **Mailgun** works great for technical teams sending millions of emails. Detailed analytics, flexible routing, strong API.
- **Resend** feels like what AWS SES should have been in 2024. Clean API, TypeScript SDK, actually useful dashboard.

For more options, see [best transactional email services](/posts/best-transactional-email-services) and [email deliverability tools](/posts/email-deliverability-tools).

## Why Teams Leave Amazon SES

![amazon-ses](//images.ctfassets.net/7154jijfbyeo/q9JJNhn6ZZxvnabpZ7H9L/218f6cdd9b224eeb68e1e6c0f257d027/amazon-ses.png)

Price stops mattering when emails start failing. SES makes you set up authentication yourself. Build your own bounce processing. Create your own suppression lists. Want to see if emails are actually delivered? Time to build a dashboard or connect CloudWatch to something useful. Need to warm up IPs? Figure it out yourself. Something breaks? Hope someone answered your question in the AWS forums three years ago.

If you enjoy that kind of control, SES works great. Most teams would rather pay a bit more to get analytics that work, support that answers, and deliverability that someone else worries about.

## How the Top Alternatives Compare

### Bento: Deliverability-first email API

![bento](//images.ctfassets.net/7154jijfbyeo/UkmTILUGISwVjk5ISQmdH/07c24a1df56806a53574e959142956e4/bento.png)

Bento treats email as a real channel, not an afterthought. You get REST and SMTP endpoints, real-time events, plus all the infrastructure pieces that actually matter. SPF, DKIM, and DMARC get configured automatically. The platform handles IP warm-up and batching so you don't blow up your reputation on day one. You only pay for emails you send, not contacts sitting in your database.

Pick Bento if you want email that just works without becoming an email expert yourself.

### SendGrid: Full-service option

![sendgrid-by-twilio](//images.ctfassets.net/7154jijfbyeo/01PmW3Gx01vaGf2HM8PPly/cdc72fbf85c6b07ff9667f88cd66fb53/sendgrid-by-twilio.png)

SendGrid puts transactional APIs, marketing campaigns, and templates in one place. The documentation actually helps. SDKs work in every language your team uses. You can see what's happening with your emails without writing SQL queries against CloudWatch logs. Pricing starts at $20/month. Once you factor in the time you save not debugging SES, that $20 looks pretty reasonable.

### Mailgun: Built for scale

![mailgun-by-sinch](//images.ctfassets.net/7154jijfbyeo/3Cncb1R8f2GX0hpnoMrXx4/44ffa67076392903deaff9800f139a6e/mailgun-by-sinch.png)

Mailgun works best for technical teams sending millions of emails who still want control. You get detailed logs that actually tell you what happened. Routing rules that make sense. Analytics you can use without a data science degree. They have real SDKs for Node, Python, PHP, Ruby, Go, and basically everything else. Pricing matches SendGrid once you're past test volumes. The difference is Mailgun gives you more knobs to turn if you need them.

### Postmark: Speed above everything

![postmark-by-activecampaign](//images.ctfassets.net/7154jijfbyeo/yOaVs2BuyI1HaHB2b3B3X/0b4e12fd1a9ce8aaadd246986eb7b451/postmark-by-activecampaign.png)

Postmark built their whole company around one idea: transactional emails should be fast. Your password resets land in seconds, not minutes. They keep marketing emails completely separate so that newsletter you sent to 50,000 people won't slow down your order confirmations. Setup takes minutes. Their libraries work. Support actually helps. Yes, it costs more than SES. But when customers are waiting for that password reset, speed matters more than saving three cents.

### Resend: Modern developer experience

![resend](//images.ctfassets.net/7154jijfbyeo/454lXLKBxSAN80lcutw82W/73f481177c8794f84510cd5316ffd209/resend.png)

Resend is what happens when developers who actually send email build an email service. The API makes sense. The TypeScript SDK is first-class, not an afterthought. The dashboard shows you what you need without 47 tabs. They handle all the boring stuff like templates, webhooks, and authentication setup. You can send production emails in about 10 minutes. If you want something that feels modern instead of like 2012, Resend delivers.

## When Amazon SES Still Wins

Keep using SES if you're already deep in AWS, love having total control, and saving money beats everything else. Nothing else comes close on price for huge volumes. If you have the skills to handle deliverability yourself, those savings add up. Just remember to factor in the hours you'll spend building tools and waiting for support. That cost never goes away.

## Where Bento Fits

Bento works for teams who want real email infrastructure without building it themselves. You get APIs that developers like, SMTP that just works, webhooks that fire reliably, and a dashboard your marketing team can actually use. The platform handles the annoying parts: authentication setup, warming up IPs and domains, watching reputation scores, controlling send rates, and staying out of spam folders. 

If you're tired of cobbling together SES with six other services but don't need a full marketing suite, Bento makes sense.

## How to Choose Your Alternative

First, be honest about what you want to manage yourself. Warming up IPs takes weeks. Monitoring reputation means checking multiple postmaster tools daily. Dealing with blocklists means emailing abuse desks at 2 AM. Every task you don't want becomes a reason to pay for managed service.

Focus on features you'll actually use. That fancy AI subject line generator sounds cool in the demo. But if you're just sending password resets and order confirmations, who cares? Pick the service that does what you need today, not what you might need in three years.

Run the numbers at different volumes. Some services look cheap at 10,000 emails but get expensive fast. Others cost more upfront but include everything you'd build yourself on SES. Don't forget to add the cost of your time. Those hours debugging CloudWatch logs aren't free.

Test with real emails before you commit. Sign up for trials. Send the same emails you'd send in production. Check how fast they deliver. Try to break something and see how support responds. A service that looks perfect on paper might fall apart when you actually use it.

Want to dig deeper into specific options? Check out these guides: [Email deliverability tools](/posts/email-deliverability-tools), [Best transactional email services](https://bentonow.com/posts/transactional-email-best-practices), and [Best email API](https://bentonow.com/posts/best-email-api-for-developers).

Find Amazon SES alternatives for transactional email. Compare email API services that offer better features, deliverability, or easier setup than AWS SES.

Amazon SES Alternatives: Compare Transactional Email Services

Getting hit with Microsoft's S3150 or S3140 errors? Your emails are being rejected, customers aren't getting important messages, and you're probably starting to panic.

Don't worry—we've been through this process dozens of times. Here's exactly how to get your IP delisted from Microsoft's blocklist, explained in plain English.

## Quick Summary: What's Happening?

When you see S3150 or S3140 errors, Microsoft has blocked your sending IP address due to suspicious activity or poor sending practices.

It'll look something like this in your bounce logs: 550 5.7.1 Unfortunately, messages from [X.XXX.XX.XXX] weren't sent. Please contact your Internet service provider since part of their network is on our block list (S3150). You can also refer your provider to http://mail.live.com/mail/troubleshooting.aspx#errors. [Name=Protocol Filter Agent]. 

Microsoft isn't super transparent about the reason they issue both of these errors, but it's often for the following reasons: 

```
⚠️  THE SITUATION:
┌─────────────────────────────────────────────┐
│ Error S3150: IP blocked because it's some limit (i.e sending abnormal volumes of emails)  │
│ Error S3140: Reputation-based blocking (i.e too many complaints or bounces)     │
│ Result: Emails REJECTED to Outlook/Hotmail │
│ Impact: Lost revenue + frustrated customers │
└─────────────────────────────────────────────┘
```

**The good news:** Microsoft's delisting process works, but you need to approach it correctly.

**The great news (if you're a Bento customer):** We handle IP reputation management for you and can often resolve these issues fast given our experience dealing with this often.

## Understanding S3150 vs S3140 Errors

### S3150: Policy-Based Blocking
**What it means:** Your IP violated Microsoft's sending policies. This doesn't necessarily mean you're doing something wrong, but it's a sign that Microsfot does want you to reach out to tell them what exactly you're doing. 

**Common causes:**
- Sudden volume spikes without proper warming
- Scaling up volume too quickly
- Sending a lot of different domains on that IP address

### S3140: Reputation-Based Blocking  
**What it means:** Your IP's is sending low quality email (aka spam).

**Common causes:**
- Consistent low engagement rates
- High bounce rates over time
- Sending patterns that look suspicious
- Association with other poor-reputation IPs

```
📊 ERROR BREAKDOWN:
┌─────────┬────────────────────────────────────┐
│ S3150   │ 🚫 Policy violation (more serious) │
│         │ Usually requires human review      │
├─────────┼────────────────────────────────────┤
│ S3140   │ 📉 Reputation issue (recoverable)  │
│         │ Often auto-resolved with good data │
└─────────┴────────────────────────────────────┘
```

## The Microsoft Delisting Process: Step-by-Step

### ✅ Step 1: Stop the Bleeding (Do This First)
Before contacting Microsoft, fix the underlying issues:

**Immediate actions:**
- Pause (or throttle) all email traffic from the affected IP
- Clean your email list (remove bounces, unengaged contacts)
- Review recent sending patterns for anomalies
- Check spam complaint rates
- Lock down all your sign up forms.
- Implement double opt in. 

Basically, you just want to make sure people getting your email actually want to get your email. You don't want to be sending to bots or have your forms abused by spammers. The latter is often a reason for an S3140.

**Bonus:**
- Read our [deliverability guide](https://bentonow.com/deliverability) and check as many boxes as possible. 

### ✅ Step 2: Gather Your Data
Microsoft wants specifics. Collect this information:

```
📋 REQUIRED INFORMATION:
┌─────────────────────────────────────────────┐
│ ✓ Blocked IP address                        │
│ ✓ Date/time of first error                  │
│ ✓ Sample of rejected emails (headers)       │
│ ✓ Your sending volume history               │
│ ✓ Steps taken to fix the issue              │
└─────────────────────────────────────────────┘
```

You may need to work with your ESP to get this information.

### ✅ Step 3: Submit Your Delisting Request
Use Microsoft's official sender support form:

**Where to go:** [https://sender.office.com/](https://sender.office.com/) if you are seeing bounces on Outlook (365 - paid) accounts and [https://olcsupport.office.com/](https://olcsupport.office.com/) if you are seeing bounces on Outlook (free - hotmail.com, outlook.com) accounts.

**What to include in your request:**
- Professional, concise explanation
- Acknowledgment of the issue
- Specific steps you've taken to fix it
- Commitment to better practices going forward

### ✅ Step 3.5: Reply to the automated email

You may get an automated email back saying nothing is wrong. Their systems don't seem to automatically check for S3150 errors, so you have to reply to them and get someone manually to review your case. 

### ✅ Step 4: Write an Effective Delisting Request

Here's a template that works:

```
Subject: IP Delisting Request - [Your IP Address] - S3140

Dear Microsoft Support Team,

I am requesting delisting for IP address [X.X.X.X] which is currently 
receiving S3140 errors when sending to Microsoft domains.

Issue Details:
- First noticed: [Date/Time]
- Error type: S3140
- Affected domains: outlook.com, hotmail.com, live.com
- Sending domains: example.com, example.net, example.org

Root Cause Analysis:
[Brief explanation of what caused the issue - be honest]
i.e "During the month of May, someone spammed our form with thousands of emails, which we've cleaned up and are now implementing double opt in ..." 

Corrective Actions Taken:
1. Paused all email campaigns from this IP
2. Cleaned email list (removed X unengaged contacts)
3. Implemented stricter list hygiene practices
4. [Other specific actions]

Preventive Measures:
1. Enhanced monitoring of engagement metrics
2. Improved list cleaning procedures
3. Volume ramping protocols for future campaigns
4. [Other ongoing improvements]

We take email deliverability seriously and are committed to maintaining 
best practices. Please let me know if you need additional information.

Best regards,
[Your name and company]
```

Or, if it's a S3150 and you're asking for mitigation, you can use this template: 

```
Subject: IP Mitigation Request - [Your IP Address] - S3150

Dear Microsoft Support Team,

I am requesting mitigation for IP address [X.X.X.X] which is currently 
receiving S3150 errors when sending to Microsoft domains.

Issue Details:
- First noticed: [Date/Time]
- Error type: S3150
- Affected domains: outlook.com, hotmail.com, live.com
- Sending domains: example.com, example.net, example.org

Root Cause Analysis:
[Brief explanation of what caused the issue - be honest]
i.e "During the month of May, we increased our sending volume on this list from 500 per day to 5,000 per day ... we believe this may have caused the block and are requesting mitigation to allow us to increase our email volume to your servers. Our expected volume for the next 30 days is 5,000 per day and will increase to 10,000 per day in June."

We are following best practices in regards to: 
- SPF, DKIM, DMARC

We take email deliverability seriously and are committed to maintaining 
best practices. Please let me know if you need additional information.

Best regards,
[Your name and company]
```

Additionally, include your phone number and email address in the request. More information is always better for the support agent to see you are a legitimate business and not a spammer.

### ✅ Step 5: Follow Up Appropriately
**Timeline expectations:**
- Initial response: 4-8 hours
- Resolution: 12-24 hours.
- Complex cases: Up to 2 weeks

**Follow-up rules:**
- Be professional and patient
- Provide additional information if requested
- Don't spam their support system

## Common Mistakes That Delay Delisting

### ❌ "It wasn't our fault"
Taking responsibility speeds up the process. Even if the issue wasn't entirely your fault, acknowledge your role and focus on solutions. Even in the case of listbombing, where a spammer is putting emails into your list, you still need to take responsibility as it's a security issue and fix it.

### ❌ Submitting multiple requests
One well-crafted request is better than five rushed ones. Multiple submissions can actually delay your case.

### ❌ Not fixing the underlying issue
Microsoft may check your sending practices before delisting. If the same problems persist, you'll get blocked again quickly.

## Alternative Approaches

There aren't any, you must go through official channels. 

## Prevention: Avoid Future Blocks

### Monitor These Key Metrics
```
🎯 HEALTH METRICS TO WATCH:
┌─────────────────────────────────────────────┐
│ Bounce rate:        < 0.5%                    │
│ Complaint rate:     < 0.1%                  │  
│ Engagement rate:    > 20%                   │
│ List growth:        Steady, not sudden      │
└─────────────────────────────────────────────┘
```

### Best Practices Going Forward
- **Regular list cleaning** (ideally, instantly removing bounces which is something Bento does for you)
- **Double opt-in** for new subscribers
- **Gradual volume increases** when scaling
- **Monitor feedback loops** from major ISPs
- **Maintain proper authentication** (SPF, DKIM, DMARC)

## Tools & Resources

### Monitoring Tools:
- **Microsoft SNDS** (Smart Network Data Services)
- **250ok or Validity** for reputation monitoring  

### Microsoft Resources:
- [Sender Support Portal](https://sender.office.com/)
- [Sender Support Portal for Hotmail, Outlook, etc](https://olcsupport.office.com/)
- [Microsoft's Deliverability Guidelines](https://docs.microsoft.com/en-us/microsoft-365/security/office-365-security/anti-spam-message-headers)

## FAQs

### Q: How long does Microsoft delisting usually take?
**A:** Most requests are resolved within 12-24 hours, though complex cases can take up to 2 weeks.

### Q: Can I still send during the delisting process?
**A:** Your IP will remain blocked until Microsoft removes it. However, you can send from other IPs if available. Be careful that you fix the issue first before rotating IPs as you don't want the issue to spread.

### Q: What if Microsoft denies my delisting request?
**A:** Review their feedback, make additional improvements, and resubmit after addressing their concerns. Sometimes it takes 2-3 attempts.

### Q: Will this happen again?
**A:** Not if you maintain good sending practices. However, reputation requires ongoing maintenance—it's not a "set it and forget it" situation.

## The Bottom Line

Getting blocked by Microsoft is stressful, but it's fixable. The key is taking responsibility, making real improvements, and communicating professionally.

**Remember:** The delisting is just the first step. Long-term success requires ongoing attention to your email practices and reputation management.

**Most importantly:** If you're seeing these errors frequently, it might be time to evaluate your overall email strategy and consider working with specialists who can help prevent future issues.

---

*Need help with Microsoft delisting or want to prevent future blocks? Most email service providers offer deliverability support, and some specialize in Microsoft relationship management.*


Getting hit with Microsoft's S3150 or S3140 errors? Your emails are being rejected, customers aren't getting important messages, and you're probably starting to panic.

Don't worry—we've been through this process dozens of times. Here's exactly how to get your IP delisted from Microsoft's blocklist, explained in plain English.

How to get your IP delisted after a S3150 & S3140 bounce

Learn how to check spam scores for emails. Understand spam score testing tools, what affects spam scores, and how to improve email deliverability.

Checking Spam Scores: Email Deliverability Testing Guide

Try this now. Send an email to your list with the subject line “FIRSTNAME?”. I bet it your most opened email ever. That's because people care most about themselves. 

Any time you can make your audience believe you are talking **1:1 to them**, you'll get a better response. But before you can do that, you need to know more about them. Who they are. What they do. Their goals. Problems they're struggling with. That's where segmentation comes in.

This guide covers segmentation basics, shows how to design segments for different industries, and explains how Bento handles personalization without hurting inbox placement. Bento has a native integration with [RightMessage](/posts/rightmessage-and-bento/), which allows you to gather gather segmentation data so you can personalize both your emails and web pages.

## TL;DR: Segmentation Starter Pack

- Capture preferences, behavior, and lifecycle stage with explicit consent.
- Define segments that match your business goals and update automatically.
- Personalize content with Bento custom fields and events, then measure performance per segment.
- Review segments regularly to remove inactive contacts and keep your reputation strong.

## Segmentation Fundamentals

### Types of segmentation

**Demographic segmentation:** In B2B this can be job title or industry. B2C this can be gender or age. Your product doesn't only appeal to one type of prospect. Being able to personalize your emails and landing pages based on specific use cases increases conversion rates. 

**Behavioral segmentation:** Have they opened an email in the last 30 days? Have they viewed your product or pricing page? Did they opt-in for a lead magnet? What someone has done recently tells you how to communicate with them.

**Lifecycle segmentation:** Lead, prospect, customer, evangelist. MQL, SQL, PQL. Whales, loyal customers, lapsed customers, prospects. Each stage of the buyer's journey needs different communication.

### Why segmentation boosts deliverability

The more relevant an email looks, the more likely it is to be opened and read. The more people who read your email, the more of them will take actions like clicking, replying, and buying.

Email service filtering algorithms rewards consistent engagement patterns. Segmented sends create predictable positive signals that keep your reputation high.

## Designing Segments

### Core segments for SaaS

**Free trial users:** Your job here is to get them to use the product and experience a positive result. If they do, they're more likely to upgrade. You'll also need to remind them their trial is ending, and if you took their card details on signup, to cancel before they're billed.

**New users:** The goal is the same here as a free trial. They need to use your product. If they don't use it, they don't get value. If they don't get value, they are more likely to cancel. Be careful not to overwhelm them. Bento's onboarding show's new users how to one feature a day for 8 days.  

**Tiers and billing schedule:** If they are on a lower tier, try to upsell them to a higher one. Show off your most powerful features in the higher tiers. If they are on monthly billing, try to convert them to annual. Send a “tax write-off” campaign near the end of the year.

**Lapsed users:** If they haven't logged in in a while, they're more likely to churn. It happens like this. They don't log in for 3 weeks. Then they get rebilled. Then they think, hey, I'm not using this app, let me cancel. Keep them engaged, and not just with reminders to log in.

**Lapsed trial:** People whose free trial ended without upgrading, or who canceled before being billed. Goal is to find out why and then get them to sign up if possible. 

**Churned users:** These are people who've canceled their subscription. Try to get them back. FOMO helps. Hopefully you're shipping new features regularly.

### Core segments for ecommerce

**Leads:** If you've set up email or SMS capture. Goal is to get them to buy as soon as possible. Leads older than 30 days, conversion rate drops off a cliff.

**First-time buyers:** Get them to buy again as soon as possible. With this and the previous segment, there's no such thing as too many emails. Hammer them until they buy or die.

**Frequent buyers:** There are people who've placed more than your average number of orders. You want to keep them buying while increasing their average order value. E.g. Offer a gift with their next order of $X or more.

**Whales/VIPs:** These are frequent buyers who spend a lot more than other customers. How much is “a lot more”? That's up to you. E.g. 3X Average order value. You want to keep them buying and get them tell their friends about you. Make them feel special. Give them white glove service. Exclusive perks and bonuses.

**Lapsed customers:** People who've bought in the past but haven't made a purchase in a while, e.g. more than 6 months. Goal is to get them to buy again. Don't assume you need to offer discounts (to any prospect or customer.)

**Unengaged contacts:** People who haven't engaged with your emails in a while. Here you want to re-activate them. If they don't respond, stop emailing them. You don't have to unsubscribe them.

**The four abandonments:** Site abandonment; viewed a page on your website that's not a product page. Browse abandonment; viewed a product page but didn't add to cart. Cart abandonment; added to cart but didn't start checkout. Checkout abandonment; started checkout but didn't place order. Each needs its own automation. If you have several products, each needs its own unique browse abandonment.

### Core segments for digital products, courses, coaching

We're lumping low-ticket and high-ticket digital products together here. We've also combined direct-to-checkout and phone sales funnels.

**Leads:** People who've opted-in for a lead magnet; a free resource, VSL, webinar etc. Goal is to get them to take the next step. Buy a course, book a call, show up to a webinar, etc.

**Completed application:** People who've completed their application but haven't booked a call. They could have dropped off without booking a call. Or they could have been rejected, manually or by conditional logic.

**Booked call:** People who've booked a call with a salesperson. Goal is to get them to show up for the call.

**No-shows, no-offers:** People who didn't show up to their sales call. Or people who showed up and weren't a good fit, or didn't buy due to some objection.

**Abandoned checkout:** If running a direct-to-checkout sales funnel, someone who has viewed the checkout page but has not completed their purchase.

**New customers/clients:** People who bought recently. They need to be onboarded and compelled to consume the information and resources provided (e.g. view course materials or show up to coaching calls.) If you sell any back-end offers, you'll also want to set them up for an upgrade conversation.

## Executing Segmentation in Bento

### Custom fields, tags, events

New signups are automatically tagged with “lead.” If they buy they get tagged “customer.” You can create your own tags. Like a tag for every product you sell.

Forms and onboarding surveys can update custom fields (e.g. job title, industry, use case) and trigger events (e.g. $trialstarted.)

Events and tags can start flows and email sequences. Custom field data can personalize emails and landing pages.

Note: Use custom fields when the data being collected must be one of several options. E.g. someone can't be a CEO and a Marketing Director. Use tags when the data collected can be several of a single category. E.g. someone can have bought more than one course from you.

### Segmented campaigns

Bento comes with pre-built segments like “Customers”, “Gmail users”, and others. You can build your own, like a VIP segment for customers whose lifetime value is greater than $X, or a reactivation segment for people who haven't taken any actions in 90+ days.

Once you've built segments, you can send targeted email campaigns. Our email campaign builder allows you to select pre-built segments or define your sending audience manually.

### Liquid templating

You can personalize your emails with [liquid tags](/docs/liquid_guide/). This can be as simple as greeting subscribers by their first name, or as complex as showing every subscriber a unique offer based on the information you know about them.

And with our native RightMessage integration, you can also use your segmentation data to personalize the content they see on your website.

## Ready to Personalize Without the Headache?

Segmentation doesn't have to be a complex data project. With Bento you can design, automate, and monitor segments that keep customers engaged and deliverability strong. [Request a Bento demo](https://bentonow.com/demo) or email sales@bentonow.com to build segmentation templates for your team.

Check out related resources on [behavioral targeting tools](/posts/behavioral-targeting-tools) and [email deliverability tools](/posts/email-deliverability-tools).

Learn customer segmentation fundamentals, build behavior-driven segments, and execute personalized email journeys with Bento while safeguarding deliverability.

Customer Segmentation Basics: Personalize Every Email and Journey

Find the best newsletter platforms for content creators. Compare tools to build your audience, monetize content, and manage subscribers effectively.

Best Newsletter Platforms: Build and Monetize Audiences

Email APIs let you send emails programmatically from your applications. You make HTTP requests, the API sends emails. Simple as that.

But not all email APIs are created equal. Some have clean design and solid documentation that make integration a breeze. Others turn a simple task into a week-long debugging marathon. The difference between a good API and a bad one can mean hours (or days) of development time.

When you're building an app that needs to send emails, you need more than just HTTP endpoints. You need authentication that works, webhooks that fire reliably, templates that save time, and analytics that show what's happening. Most importantly, you need an API that doesn't fight you at every turn.

This guide breaks down the top email API services and what makes each one unique. We'll look at API design, SDK support, developer experience, and the stuff that actually matters when you're writing code at 2 AM trying to get email notifications working.

## TL;DR: Quick Picks by Developer Experience

Need to pick fast? Here's who each API works best for:

**Bento** fits applications that want an email API plus deliverability tools in one package. You get a solid API plus reputation monitoring and batching controls included. Often cheaper than buying these separately. Marketing is included so you can send your campaign emails, automations, etc. 

**Resend** works for modern applications that care about developer experience. They built their API from scratch with developers in mind. Clean design, great docs, modern approach. The downside? They're newer, so fewer features and less track record.

**SendGrid** handles both transactional and marketing emails through one API. If you need password resets AND newsletters, this saves you from juggling multiple services. Jack of all trades, master of none.

**Mailgun** serves high-volume senders who need serious infrastructure. Enterprise-grade everything, tons of features, powerful API. Also enterprise-grade complexity and pricing.

**Postmark** delivers critical transactional emails faster than anyone else. When milliseconds matter for password resets or payment confirmations, they're the gold standard. You pay for that speed though.

**What to watch out for:** Developer-focused APIs like Resend make integration easy but might lack advanced features. Enterprise APIs like Mailgun have everything but take longer to learn. Fast APIs like Postmark cost more. Pick based on your actual needs, not what sounds impressive.

Want background on email APIs? Check our [what is email API](/posts/what-is-email-api) guide. For broader transactional email comparisons, see [best transactional email services](/posts/best-transactional-email-services).

## What Makes a Good Email API?

After integrating dozens of email APIs over the years, patterns emerge. Good APIs share certain traits that make developers' lives easier.

Clean API design saves hours of work. You want intuitive endpoints that make sense without reading docs for every call. REST conventions should be followed. Request and response formats should be consistent. Error messages should tell you what went wrong and how to fix it, not just "Error 400."

Documentation makes or breaks an API. Complete reference docs are the minimum. You need code examples in multiple languages, common use case walkthroughs, and clear explanations of rate limits and restrictions. If you have to guess how something works or dig through GitHub issues for answers, the docs have failed.

SDK support in your language matters more than you think. Sure, you can make raw HTTP requests. But native SDKs handle authentication, retries, error parsing, and all the boring stuff that takes time to get right. Good SDKs for Node.js, Python, Ruby, PHP, Go, and Java should be table stakes in 2025.

Webhooks turn email from fire-and-forget into a real-time system. You need delivery confirmations, bounce notifications, open tracking, and click events. More importantly, you need webhooks that actually fire when they should. Nothing worse than finding out three months later that your bounce webhook stopped working.

Error handling separates good APIs from frustrating ones. Clear error codes, helpful messages, and consistent formats make debugging possible. Cryptic errors like "Invalid request" with no details waste everyone's time.

The best email APIs feel invisible. They work the first time, handle edge cases gracefully, and give you the information you need when something goes wrong.

## How Email APIs Compare

Each major email API takes a different approach. Here's what you actually get with each one.

### Bento: API with Deliverability Included

![backdrop-teaching](//images.ctfassets.net/7154jijfbyeo/7EOYJ4876qIQfyInkgzZGB/86d91ba6971d0951f3d5c76cee09d68c/backdrop-teaching.png)

Bento (hi there 👋) takes a different approach. We give you a solid API but include the deliverability infrastructure most providers charge extra for.

The API itself is straightforward. REST endpoints for sending, webhooks for events, SDKs for major languages. Nothing revolutionary, but everything works as expected. The documentation covers the basics well, though it's not as polished as Resend's.

What sets Bento apart is what comes with the API. Authentication setup (SPF, DKIM, DMARC) is guided and monitored. Reputation tracking happens automatically. Sending gets throttled if metrics drop. The spam API catches abuse and invalid emails. These are things you'd normally buy separate tools for or build yourself.

The platform shows its roots in marketing automation sometimes. Some API responses include fields you won't need for pure transactional sending. The SDKs work but feel less polished than dedicated API-first providers.

If you want email infrastructure that handles deliverability for you, Bento makes sense. You trade some API polish for not having to think about IP warming, reputation monitoring, or authentication setup.

### Resend: Modern Developer Experience

![resend](//images.ctfassets.net/7154jijfbyeo/454lXLKBxSAN80lcutw82W/73f481177c8794f84510cd5316ffd209/resend.png)

Resend built their API from scratch in 2022 with one goal: make email integration as painless as possible for developers.

Their API feels modern because it is modern. Clean REST design, predictable responses, and helpful error messages. The documentation reads like it was written by developers who actually use the product. Code examples work. Edge cases are explained. Rate limits are clear.

The SDK quality stands out. Instead of thin wrappers around HTTP calls, they built proper SDKs that handle the annoying parts. Automatic retries, connection pooling, proper error types. The Node.js SDK in particular feels native to the ecosystem.

Where Resend falls short is features and track record. They don't have the decade of battle-testing that older providers have. Advanced features like complex routing rules or IP pool management aren't there yet. If you need enterprise bells and whistles, you'll be disappointed.

For straightforward email sending with a great developer experience, Resend delivers. If you need complex enterprise features or have compliance requirements that demand an established provider, look elsewhere.

### SendGrid: Transactional + Marketing Combined

![sendgrid-by-twilio](//images.ctfassets.net/7154jijfbyeo/01PmW3Gx01vaGf2HM8PPly/cdc72fbf85c6b07ff9667f88cd66fb53/sendgrid-by-twilio.png)

SendGrid tries to be everything to everyone. Send transactional emails through the API, run marketing campaigns through the UI, and manage it all in one place.

The API works well enough. Good documentation, decent SDKs, reliable delivery. They've been around long enough to work out the bugs. The Python and Node.js SDKs in particular get regular updates and have good community support.

Marketing features add complexity though. The API has endpoints for campaigns, lists, segments, and other marketing concepts you might not need. Template management mixes transactional and marketing templates. Pricing tiers assume you're doing both.

The free tier barely exists now, 100 emails per day won't even cover testing for most apps. Paid plans start reasonable but scale up fast. You're paying for marketing features even if you only send transactional emails.

SendGrid works if you genuinely need both transactional and marketing emails. If you just need one or the other, you're paying for complexity you don't use.

### Mailgun: Enterprise API Infrastructure

![mailgun-by-sinch](//images.ctfassets.net/7154jijfbyeo/3Cncb1R8f2GX0hpnoMrXx4/44ffa67076392903deaff9800f139a6e/mailgun-by-sinch.png)

Mailgun builds for developers at large companies. Powerful API, extensive features, enterprise pricing.

The API documentation spans hundreds of pages. Every edge case is covered. Rate limiting is granular. Routing rules handle complex scenarios. You can do almost anything if you spend enough time with the docs.

Multi-region support means you can send from data centers worldwide. IP pool management lets you isolate different email streams. Detailed analytics track everything. If a large company's legal team has asked for it, Mailgun probably supports it.

This power comes with complexity. Simple tasks require multiple API calls. The learning curve is steep. Documentation assumes you understand email infrastructure deeply. What takes 5 lines with Resend might take 50 with Mailgun.

Pricing reflects the enterprise focus. The entry tier is reasonable, but costs escalate quickly. High-volume discounts exist but require annual contracts. Support beyond basic tickets costs extra.

Mailgun makes sense for large applications with complex requirements and dedicated email teams. For everyone else, it's overkill.

### Postmark: Ultra-Fast Transactional API

![postmark-by-activecampaign](//images.ctfassets.net/7154jijfbyeo/yOaVs2BuyI1HaHB2b3B3X/0b4e12fd1a9ce8aaadd246986eb7b451/postmark-by-activecampaign.png)

Postmark does one thing better than anyone: deliver transactional emails incredibly fast.

Most emails arrive in under 3 seconds. For password resets, payment confirmations, and other time-sensitive emails, those seconds matter. Users notice when emails arrive instantly versus 30 seconds later.

The API stays simple on purpose. No marketing features to slow things down. No complex routing rules. Just clean endpoints for sending transactional emails fast. The documentation is excellent, with a focus on best practices for transactional email.

This focus means limitations. No marketing emails allowed, they'll suspend your account. Pricing is premium, about 50% more than competitors for similar volume. The feature set is intentionally limited to maintain performance.

Support deserves special mention. They respond fast and actually help. No tier-one support reading from scripts. Real email experts who understand deliverability.

If transactional email speed and reliability justify premium pricing for your app, Postmark is worth it. For mixed use cases or budget-conscious projects, the restrictions and cost are hard to justify.

## Key Differences: Email APIs

The differences between email APIs become clear when you understand what each optimizes for.

Developer experience varies wildly. Resend feels like it was built last week (in a good way) with modern patterns and helpful docs. Mailgun feels like enterprise software from 2010, powerful but clunky. Bento and SendGrid sit in the middle, functional but not delightful. Postmark keeps things simple, which helps or hurts depending on your needs.

Feature sets reflect target audiences. Mailgun has every feature imaginable because enterprises demand them. SendGrid includes marketing features most developers won't use. Postmark intentionally limits features to maintain performance. Resend and Bento focus on core features done well.

Deliverability approaches differ significantly. Postmark's transactional-only focus means pristine reputation. Bento includes monitoring and tools to maintain good reputation. Mailgun provides tools but expects you to manage them. SendGrid's mixed sending can hurt transactional deliverability. Resend is too new to have established reputation patterns.

Pricing models tell you who they're selling to. Amazon SES prices for AWS users who handle everything themselves. Bento prices for value, including features others charge extra for. SendGrid and Mailgun price for businesses with email budgets. Postmark prices for companies where email deliverability directly impacts revenue. Resend prices competitively to gain market share.

Support quality correlates with price. Postmark's premium support matches premium pricing. Mailgun support requires enterprise contracts for real help. SendGrid support is hit or miss. Bento provides decent support for all customers. Resend is still small enough that support is good, but this might not scale.

## Where Bento Fits: Email API with Deliverability Included

Bento occupies an interesting middle ground in the email API landscape.

The API itself won't win design awards. It's RESTful, documented, and has SDKs for major languages. Everything works as advertised. But it's not as polished as Resend or as powerful as Mailgun. It's a tool that does its job without trying to impress you.

Where Bento stands out is deliverability infrastructure. Most providers give you an API and wish you luck. We include authentication setup, reputation monitoring, and automatic throttling when metrics drop. These are included by default. You won't have to buy an add-on or upgrade to a higher tier.

The pricing model makes sense for many use cases. You pay for emails sent, not contacts stored. If you email 10,000 contacts once a month, you pay for 10,000 emails. With contact-based pricing, you'd pay for 10,000 contacts every month whether you email them or not.

Bento works well when you want a complete email system without assembling pieces yourself. You're not buying the best API or the fastest delivery or the most features. You're buying a system that handles the whole email problem reasonably well.

This approach won't work for everyone. If you need Postmark's speed for critical transactional emails, Bento can't match it. If you need Mailgun's enterprise features, we don't have them. If you want Resend's developer experience, we fall short.

But if you want to send emails reliably without becoming an email infrastructure expert, Bento provides that. One vendor, one bill, one support team, and deliverability handled for you.

## Ready to Choose Your Email API?

Picking an email API comes down to understanding your actual needs versus what sounds good on paper.

Start with the basics. How many emails will you send? What types (transactional, marketing, both)? What's your budget? How much time can you spend on integration? These answers eliminate half your options immediately.

Test the APIs that match your needs. Sign up for free trials. Send test emails. Integrate their SDKs. Read their docs. You'll quickly feel which ones fight you and which ones help you. An hour of testing beats days of reading comparison articles.

Consider the full picture. API quality matters, but so does deliverability, support, pricing, and company stability. A perfect API from a startup that might not exist next year is risky. An okay API from an established provider might be the safer choice.

Think about maintenance, not just integration. You'll live with this choice for years. Consider how the API will scale, how pricing will grow, how support will work when something breaks at midnight. The easiest API to integrate might not be the easiest to maintain.

Make a decision and move forward. Every API has tradeoffs. Perfect doesn't exist. Pick the one that handles your must-haves well and whose downsides you can live with. You can always switch later if needed, though nobody enjoys migrating email providers.

For background on email APIs, read our [what is email API](/posts/what-is-email-api) guide. To compare transactional services broadly, see [best transactional email services](/posts/best-transactional-email-services). For SMTP details, check [everything about SMTP](/posts/everything-about-smtp).

If you're considering Bento's API, [we're here to help](https://bentonow.com).

Find the best email API services for developers. Compare REST APIs, SDKs, webhooks, and developer experience across email service providers.

Best Email API: Compare Developer-Friendly Email Services

Best Email API for Developers: Compare Developer-Friendly Email Services

Find the best email API services for developers. Compare reliable delivery, API quality, and features to build infrastructure that scales effectively.

Best Email API Services: Reliable Infrastructure

Best Email API Services: Reliable Infrastructure for Sending Emails

This may come as a surprise but DMARC is not the name of a 90's era hip hop artist. I know. I too was shocked when I found out. DMARC (Domain-based Message Authentication, Reporting & Conformance) protects your domain from email spoofing and phishing attacks.

But setting up DMARC is only half the battle. You need tools to monitor DMARC reports, analyze authentication failures, and implement policies. Without monitoring, you're flying blind. You won't know if DMARC is working or if authentication issues are blocking legitimate emails.

I've tested dozens of DMARC tools to find the ones that actually work. This guide covers the best DMARC tools available, what makes each one useful, and how to pick the right one for your situation.

## TL;DR: Best DMARC Tools

Need to pick fast? Here's who each tool works best for:

**DMARC Analyzer** – Best for businesses that need comprehensive monitoring. You get detailed analytics, clear reports, and it handles multiple domains well. Starts at $10/month.

**Postmark DMARC Digests** – Perfect if you want simple weekly email summaries. Free, easy setup, no dashboard to log into. Great for basic monitoring.

**MXToolbox** – Free tool for quick DMARC checks. Good for verifying records, but not for ongoing monitoring.

**Valimail** – Enterprise-level DMARC management with compliance features. Expect to pay enterprise prices.

**Dmarcian** – Best if you're new to DMARC. They guide you through implementation with solid documentation. Around $10/month.

**PowerDMARC** – Good for MSPs managing multiple client domains. Has automated reporting and threat intelligence features.

**What to watch out for:** Free tools work for checking records but won't monitor your reports. Most businesses need at least basic monitoring to catch authentication problems.

For more on email authentication, see our [email deliverability tools](/posts/email-deliverability-tools) guide. To check your sending reputation, read [how to check domain reputation](/posts/how-to-check-domain-reputation).

## What Are DMARC Tools?

DMARC tools help you monitor, analyze, and implement DMARC email authentication. They turn complex XML reports into data you can actually use.

Think of DMARC tools as three types. First, monitoring tools collect reports from Gmail, Yahoo, and other ISPs. They show you dashboards with pass rates, failures, and who's sending email from your domain. Second, analyzers take those cryptic XML reports and turn them into readable data. You can see which emails fail authentication and why. Third, implementation tools help you set up DMARC records correctly. They test your policies before you enforce them.

Without these tools, you'd have to parse XML reports manually. Trust me, that's painful. ISPs send thousands of reports, each one full of technical data. DMARC tools make this manageable.

## Why DMARC Tools Matter

Here's what happens without DMARC monitoring. You set up DMARC, feel good about it, then forget it exists. Meanwhile, authentication failures pile up. Maybe your marketing team added a new email tool that isn't authenticated. Or a vendor starts sending emails on your behalf. These emails fail DMARC, and if you're on an enforcement policy, they go straight to spam.

DMARC tools catch these problems before they hurt deliverability. They track your authentication pass rates daily. When something breaks, you get an alert. You can see exactly which IPs are failing authentication and fix the problem fast.

The tools also help during implementation. Moving from monitoring to enforcement is scary. You don't want to accidentally block legitimate emails. DMARC tools show you exactly what would get blocked at each policy level. You can test quarantine mode, see the impact, then move to reject when you're confident.

Manual DMARC monitoring is technically possible but brutal. Each ISP sends reports in different formats. A single day might generate hundreds of XML files. Parsing these by hand takes hours, and you'll miss important patterns.

## Best DMARC Monitoring Tools

After testing dozens of DMARC tools, these are the ones worth your time:

### DMARC Analyzer

![dmarc-analyzer](//images.ctfassets.net/7154jijfbyeo/1H4iMC2mSmcX2C1NddLayw/0d1409e6406f3b60ed8b10f75d8e64a5/dmarc-analyzer.jpg)

DMARC Analyzer gives you the most comprehensive monitoring without overwhelming complexity. The dashboard actually makes sense. You can see your authentication pass rates at a glance, spot problems quickly, and drill down when you need details.

What sets it apart is how it handles multiple domains. If you manage 10 domains, you see all of them in one view. No switching between accounts or dashboards. The platform collects reports automatically, parses them overnight, and shows you clean data in the morning.

The alerting system is smart too. It doesn't cry wolf over minor issues. You get alerts for real problems, like when a new IP starts sending from your domain or your pass rates drop suddenly. The trend analysis helps you spot patterns before they become problems.

Pricing starts free for one domain with basic features. Paid plans run $10 to $30 per domain monthly, depending on email volume and features. Most businesses land around $20/month per domain for the features they actually need.

One downside: the free plan is limited. You can monitor basic metrics, but you need a paid plan for detailed source analysis and advanced alerts.

### Postmark DMARC Digests

![postmark-dmarc-digests](https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fpostmarkapp.com%2Fimages%2Fdmarc-digests-sources%402x.png&f=1&nofb=1&ipt=db4d82d7512c5799b2933340b78097b5d0ad551d8f9c726ae8dedefc5b1ef9f6)

Postmark takes a different approach. No dashboard, no login, just weekly emails. Every Monday, you get a digest showing your DMARC performance. It tells you pass rates, which sources are sending email, and if anything looks wrong.

This simplicity is the whole point. Many businesses set up DMARC monitoring then never check the dashboard. Postmark solves this by bringing the data to your inbox. The emails are well-designed and actually readable. You can scan them in 30 seconds and know if everything's fine.

Setup takes five minutes. Add Postmark's address to your DMARC record, verify ownership, done. The service is completely free. Postmark offers it to build goodwill and showcase their email expertise.

The limitation is obvious: weekly summaries don't help with urgent issues. If something breaks on Tuesday, you won't know until Monday. And you can't dig into historical data or run custom reports. But for basic monitoring, especially if you're just starting with DMARC, it's perfect.

### MXToolbox

![mxtoolbox](//images.ctfassets.net/7154jijfbyeo/13nGg3TfENOVpLOcI0KRiu/d551b970852c2a403d56b80174597e2c/mxtoolbox.jpg)

MXToolbox is the Swiss Army knife of DNS tools. Their DMARC checker is free and instant. Type in your domain, get results in seconds. It shows your DMARC record, explains what each tag means, and flags any problems.

The tool shines for troubleshooting. It checks your entire email authentication chain. SPF record? Check. DKIM keys? It'll test common selectors. DMARC syntax? Validated. You see everything in one report.

MXToolbox also offers paid DMARC monitoring, but honestly, other tools do it better. Their strength is quick checks and troubleshooting, not ongoing monitoring. Use the free tool when you're setting up DMARC or debugging issues.

The paid monitoring starts at $129/month, which is steep compared to alternatives. You're mostly paying for MXToolbox's other monitoring features (blacklist monitoring, uptime checks). If you just need DMARC monitoring, look elsewhere.

### Valimail

![valimail](//images.ctfassets.net/7154jijfbyeo/71vIIhDQFGY1Tm6u3XGixt/dac19e883da348b597f5a63c802465ac/valimail.jpg)

Valimail plays in the enterprise space. If you're a Fortune 500 company with hundreds of domains and complex email infrastructure, Valimail makes sense. They don't just monitor DMARC. They actively manage it.

Their standout feature is automated enforcement. Valimail gradually moves domains from monitoring to enforcement based on data. No manual work, no accidentally blocking emails. The platform identifies all legitimate senders, ensures they're authenticated, then tightens policies automatically.

The compliance features matter for regulated industries. Valimail generates audit reports, tracks policy changes, and proves you're protecting your domain. If you need to show DMARC compliance for SOC 2 or other standards, Valimail has you covered.

They also handle the messy parts of DMARC. Third-party senders, subdomain policies, complex SPF flattening. Valimail sorts it out so you don't have to become a DMARC expert.

Pricing isn't public because it's negotiated per enterprise. Expect to pay thousands monthly for large deployments. They do offer a free tier for single domains, but it's basic compared to their enterprise product.

### Dmarcian

![dmarcian](//images.ctfassets.net/7154jijfbyeo/6riILABkfUr2kf3ojylAQU/98a5df906d45f778866458c4239dca77/dmarcian.jpg)

Dmarcian was built by DMARC experts who realized most people need help understanding this stuff. The platform doesn't just show you data. It explains what the data means and what to do about it.

Their source viewer is particularly good. When you see authentication failures, Dmarcian shows you exactly where they're coming from. Is it your marketing platform? A forgotten vendor? Forwarded emails? The tool identifies the source and suggests fixes.

The deployment tools guide you through DMARC implementation step by step. Start with monitoring, identify all legitimate senders, fix authentication issues, then move to enforcement. Dmarcian holds your hand through each phase.

They also run DMARC training sessions and maintain excellent documentation. If your team needs to understand DMARC deeply, not just monitor it, Dmarcian provides the education.

Free accounts get basic monitoring for small senders. Paid plans start at $20/month and scale with email volume. Most businesses pay $50-100/month for full features. The pricing is transparent, which is refreshing in this space.

### PowerDMARC

![powerdmarc](//images.ctfassets.net/7154jijfbyeo/19oGKdOpCDm9OPowMBJiaS/1f909ebb96df490f912949429178f701/powerdmarc.jpg)

PowerDMARC targets managed service providers and agencies managing multiple clients. The platform supports white-labeling, so MSPs can offer DMARC monitoring under their own brand.

The multi-tenant architecture means you manage all clients from one account. Set up alerts per client, generate branded reports, and handle support without switching between systems. The AI-powered threat intelligence identifies suspicious sending patterns across your entire client base.

For individual businesses, PowerDMARC offers solid monitoring with a modern interface. The visual reports are cleaner than most competitors. You can actually show these to executives without translation.

Pricing starts at $8/month for basic monitoring. MSP plans vary based on client count but typically run $200-500/month for 50 domains. They offer a 15-day free trial to test the platform.

## How to Choose DMARC Tools

Picking the right DMARC tool depends on your situation. Here's what actually matters:

### Monitoring Capabilities

First, the tool must collect reports automatically. Some tools make you forward reports manually or upload XML files. Skip those. You want automatic collection that just works.

Second, check the dashboard. Can you understand it in 30 seconds? Good dashboards show pass rates, top senders, and problems clearly. Bad dashboards bury important data in cluttered interfaces. Ask for a demo or trial before committing.

Third, alerting needs to be smart. You want alerts for real problems: new unauthorized senders, sudden pass rate drops, or policy violations. You don't want daily noise about minor fluctuations. Ask how you can customize alert thresholds.

### Analysis Features

The tool needs to identify sender sources accurately. When you see failures, you should immediately know if it's your CRM, your support desk, or something suspicious. Vague data like "Google IP" or "Amazon Server" isn't helpful.

Look for forensic report support. While aggregate reports show trends, forensic reports show individual message failures. Not all tools process forensic reports, but they're invaluable for troubleshooting specific issues.

Historical data matters too. You need at least 90 days of history to spot patterns. Some free tools only keep 30 days, which isn't enough for serious monitoring.

### Implementation Help

If you're new to DMARC, implementation guidance is crucial. Good tools walk you through setup, test your configuration, and suggest next steps. They should help you identify all legitimate email sources before enforcing policies.

Policy testing is non-negotiable. Before moving to p=quarantine or p=reject, you need to see exactly what would be affected. The tool should simulate policy changes and show the impact clearly.

Some tools include SPF flattening or DKIM key management. These aren't essential but can simplify email authentication management.

### Pricing and Support

DMARC tool pricing varies wildly. Free tools work for basic checking but lack monitoring. Paid tools range from $10 to $500+ monthly. Consider these factors:

Email volume matters more than domain count for some tools. If you send millions of emails, per-message pricing gets expensive. Look for unlimited message plans.

Support quality varies. Email support is standard, but response times range from hours to days. If DMARC is critical to your business, pay for phone support or priority response.

Watch for hidden costs. Some tools charge extra for API access, custom reports, or additional users. Get complete pricing upfront.

## DMARC Implementation Best Practices

DMARC implementation isn't complicated if you follow the right process. Most failures happen when people rush to enforcement without proper monitoring.

### Start with SPF and DKIM

Before touching DMARC, get SPF and DKIM working. DMARC only passes when at least one of these authenticates and aligns. Set up SPF to include all your sending IPs and services. Configure DKIM for your main sending platforms. Test both thoroughly.

### Monitor First, Enforce Later

Always start with p=none. This monitoring mode collects data without affecting delivery. Run this for at least two weeks, preferably a month. You need to see a full cycle of your email sends: newsletters, transactional emails, automated campaigns.

During monitoring, you'll discover senders you forgot about. That old survey tool, the invoice system, the support desk. DMARC reports reveal every system sending from your domain. Document them all.

### Fix Authentication Issues

Once you know all your senders, ensure they authenticate properly. Add them to SPF (watch the 10-lookup limit). Set up DKIM signing where possible. For services that can't authenticate, consider using subdomains or finding alternatives.

Common authentication failures have standard fixes. Forwarding breaks SPF but usually preserves DKIM. Mailing lists often break both, requiring special handling. Your DMARC tool should help identify these patterns.

### Gradual Enforcement

Move to p=quarantine with pct=10. This quarantines 10% of failing emails, limiting damage if something's wrong. Monitor for a week. If all's well, increase to pct=50, then pct=100.

Only move to p=reject when you're confident. This policy tells receivers to block all failing emails. There's no undo button. Make sure you've identified every legitimate sender and fixed all authentication issues.

### Ongoing Monitoring

DMARC isn't set-and-forget. New services get added, configurations change, problems arise. Keep monitoring even after reaching p=reject. Set up alerts for pass rate drops or new unauthorized senders.

Regular reviews catch problems early. Check monthly for new sending sources, authentication failures, and pass rate trends. It takes five minutes but prevents major delivery issues.

## Where Bento Fits: DMARC Support Included

If you're sending marketing or transactional emails, you might not need a separate DMARC tool. Here's where Bento fits in.

Bento handles the email authentication basics automatically. When you set up sending, Bento guides you through SPF, DKIM, and DMARC configuration. No guessing about DNS records or authentication requirements. The platform verifies everything's correct before you send.

More importantly, Bento monitors authentication continuously. If your emails start failing DMARC, you get alerts. If pass rates drop, you know immediately. This monitoring is built into the platform, not a separate tool you might forget to check.

The deliverability infrastructure comes standard. You're not paying extra for authentication monitoring, reputation tracking, or delivery optimization. It's all included in your Bento subscription.

Bento makes sense if you want email sending and DMARC monitoring in one platform. You don't have to juggle multiple tools or correlate data between systems. Everything's in one place.

But specialized DMARC tools still have their place. If you need forensic report analysis, multi-domain management for dozens of domains, or white-label DMARC monitoring for clients, dedicated tools do it better. Bento handles DMARC for your email sending. Specialized tools handle DMARC as their entire focus.

Think of it this way: Bento is like getting DMARC monitoring included with your email platform. Specialized tools are like hiring a DMARC consultant. Both work, depending on your needs.

## Ready to Implement DMARC Monitoring?

Here's your action plan:

First, pick a tool based on your needs. If you're just starting, try Postmark DMARC Digests or MXToolbox's free checker. Get familiar with DMARC reports before investing in paid tools. If you manage multiple domains or need detailed analysis, start with DMARC Analyzer or Dmarcian's free tier.

Next, set up authentication properly. Verify SPF includes all your senders. Implement DKIM for major platforms. Test both with free tools before adding DMARC. This foundation prevents most authentication problems.

Then implement DMARC gradually. Create a p=none record pointing reports to your tool. Monitor for at least two weeks. Identify and document all legitimate senders. Fix any authentication issues you discover.

When ready, enforce carefully. Move to p=quarantine with low percentages first. Monitor impact for a week at each level. Only reach p=reject when you're completely confident. Remember, there's no rush. Better to move slowly than block important emails.

Finally, maintain ongoing monitoring. DMARC isn't a one-time setup. Check reports monthly, investigate failures, and watch for new senders. Your email infrastructure changes over time. Keep your DMARC configuration current.

The tools in this guide make DMARC manageable. Pick one that fits your budget and complexity. Start monitoring today, even if you're not ready to enforce. The sooner you start collecting data, the sooner you can protect your domain properly.

**Related resources:** For a complete deliverability toolkit, read our [email deliverability tools](/posts/email-deliverability-tools) guide. To monitor your sending reputation, see [how to check domain reputation](/posts/how-to-check-domain-reputation). For troubleshooting delivery problems, check [why are my emails going to spam](/posts/why-are-my-emails-going-to-spam).

Find the best DMARC tools for monitoring and implementing email authentication. Compare DMARC monitoring services, analyzers, and implementation tools.

Best DMARC Tools: Monitor and Implement Email Authentication

Find behavioral targeting tools that personalize experiences based on user actions. Compare platforms to boost engagement and drive conversions effectively.

Behavioral Targeting Tools: Personalize Each Buyer's Journey

Are you thinking of signing up for or switching to Mailgun? Mailgun promotes itself as being “by developers, for developers.” But many developers switch *from* Mailgun *to* Bento. Like Danny Postma, founder of Headshot Pro.

![danny postma bento testimonial](//images.ctfassets.net/7154jijfbyeo/6efXwt3qHmsBq18eXp3On7/06a57beaa1463bd37610f589d04554ae/danny_postma_bento_testimonial.jpg)

![danny postma bento testimonial 2](//images.ctfassets.net/7154jijfbyeo/3kryLqiCTcYIbNVDGqnEiI/446354b3a7d9a7cc54d492ee49b3c975/danny_postma_bento_testimonial_2.jpg)

There are plenty of alternatives to Mailgun. Some cost less, some deliver emails more reliably, and some offer features Mailgun doesn't have. This guide covers your options, explains what makes each one unique, and helps you pick the right one (Bento) for your needs.

## TL;DR: Quick Picks by Use Case

If you need to pick quickly, here's what each alternative does best:

**Bento**: Great for applications that need email API access with built-in deliverability tools. You get SMTP, API access, reputation monitoring, and batching controls. Usually costs less than Mailgun. Has one of the best deliverability levels in the industry.

**SendGrid**: Works if you need both transactional emails and marketing campaigns in one place. The API is easy to use, deliverability is solid, and pricing is similar to Mailgun.

**Postmark**: Best for critical transactional emails that must get delivered. Super fast delivery, separate message streams to protect reputation, but you'll pay more.

**Amazon SES**: Perfect if you're already on AWS and want cheap email sending. Integrates seamlessly with other AWS services, pay only for what you send. Takes more work to set up but saves money at scale.

**Resend**: Great for developers who want a modern, clean API. The documentation is excellent, the design is intuitive. It's newer but already popular with developers.

**What to watch out for:** Each alternative has different strengths. Postmark focuses purely on transactional email. Bento and SendGrid handle both transactional and marketing. SES wins on cost. Pick based on what you need most.

For more comparisons, check our [best transactional email services](/posts/best-transactional-email-services) guide. To understand deliverability better, see [email deliverability tools](/posts/email-deliverability-tools).

## Why Look for Mailgun Alternatives?

Here's why people switch from Mailgun to other services like Bento:

**Pricing gets expensive:** Mailgun starts at $15/month for 10,000 emails. As you grow, costs climb quickly. Amazon SES or Bento often cost less, especially at higher volumes.

**Too many features:** Mailgun has tons of features, which is great until you just need to send simple emails. Services like Resend or Bento keep things simpler.

**Emails not reaching inboxes:** Some teams struggle with Mailgun's deliverability. Services like Postmark or Bento focus more on getting emails delivered.

**Hard to set up:** Mailgun takes time to configure properly. Bento or SendGrid often have simpler setup processes with clearer documentation.

Mailgun is not a bad product - it works well when set up and used correctly. The thing is, do you want to become an email API / SMTP and email deliverability expert just to send a few emails? Or would you rather focus on improving your product and growing your business.

## How Mailgun Alternatives Compare

### Pricing

**Note on Bento:** Unlike the others, Bento charges by **contact (subscriber)**, not by the number of emails sent. You can send unlimited emails to your contacts. The price listed below assumes you have 3,000 contacts or fewer (the minimum tier).

| Provider | Free Tier (Monthly) | Starting Paid Plan | Cost for ~50,000 Emails | Best For |
| :--- | :--- | :--- | :--- | :--- |
| **Bento** | 30-day free trial | $30/mo (up to 3k contacts) | **$30.00*** | CRM & Automation |
| **Amazon SES** | 3,000 emails (for 12 mos) | Pay-as-you-go | **$5.00** | Lowest absolute price |
| **Resend** | 3,000 emails | $20/mo (includes 50k) | **$20.00** | Developer Experience (DX) |
| **SendGrid** | 100 emails/day (~3k/mo) | ~$19.95/mo (includes 50k) | **$19.95** | Marketing + Transactional Mix |
| **Mailgun** | 5,000 emails (1 mo trial) | $15/mo | **$35.00** | High Volume & Analytics |
| **Postmark** | 100 emails (Developer) | $15/mo (10k emails) | **$55.00** | Speed & Deliverability |

### Bento: Email API with Deliverability Included

![bento](//images.ctfassets.net/7154jijfbyeo/owWYl4psczdBbWR2gLtKq/5677a499e07c920a30b615b93163208c/bento.png)

**Who it's for:** Teams that want email API access with amazing deliverability.

**What makes it different:** Bento gives you both API and SMTP access, but here's the key difference: deliverability infrastructure comes built in. Most email services make you figure out deliverability on your own. Bento includes authentication setup, reputation monitoring, and batching controls right in the price.

The API documentation is clear and covers all major programming languages. You can separate transactional emails from marketing emails, so a bad marketing campaign won't hurt your password reset emails.

**Pricing comparison:** Bento usually costs less than Mailgun, especially as you scale up. You actually pay for contacts stored, no matter how many emails do you send. This often works out cheaper than Mailgun's pricing model.

**When to choose Bento:** Pick Bento if you want great deliverability without extra work. It costs less than Mailgun for larger amounts of emails and includes for the same price the tools that Mailgun charges extra for.

**When to stick with Mailgun:** Stay with Mailgun if you need their enterprise features or  SDK support across many languages.

### SendGrid: Transactional + Marketing Combined

![sendgrid](//images.ctfassets.net/7154jijfbyeo/5GgbdChE3xJWWMCGVrBWnF/770f1b772fb7a9490e09f7f6af5d505e/sendgrid.png)

**Who it's for:** Teams that need to send both transactional emails and marketing campaigns.

**What makes it different:** SendGrid does both types of email in one platform. Need to send password resets? Check. Want to run email campaigns? Also check. The API works with Python, Java, Node.js, PHP, Ruby, C#, and Go. Documentation is solid.

SendGrid runs reliable infrastructure and gives you tools to monitor your reputation and fix delivery problems.

**Pricing comparison:** SendGrid costs about the same as Mailgun. You'll pay $19.95/month for 50,000 emails with SendGrid, while Mailgun charges $15/month for 10,000 emails. Since pricing is similar, pick based on features instead.

**When to choose SendGrid:** Go with SendGrid if you need both types of email or prefer their interface. Their marketing tools might work better for your needs.

**When to stick with Mailgun:** Keep Mailgun if you need their enterprise infrastructure or advanced tracking features. High-volume senders often prefer Mailgun's enterprise tools.

### Postmark: Ultra-Fast Transactional

![postmark-by-activecampaign](//images.ctfassets.net/7154jijfbyeo/yOaVs2BuyI1HaHB2b3B3X/0b4e12fd1a9ce8aaadd246986eb7b451/postmark-by-activecampaign.png)

**Who it's for:** Apps that send critical emails like password resets or order confirmations.

**What makes it different:** Postmark only does transactional email, and they do it really well. Emails arrive in seconds. The service rarely goes down. They keep transactional emails separate from marketing emails, so nothing affects your critical sends.

The API is clean and easy to integrate. They support Rails, Ruby, .NET, Java, PHP, and Node.js.

**Pricing comparison:** Postmark costs more than Mailgun. Both charge $15/month for 10,000 emails, but remember: Postmark only handles transactional email. You'll need another service for marketing emails.

**When to choose Postmark:** Pick Postmark if your transactional emails are critical and you can pay for premium service. The speed and reliability matter when emails directly affect user experience.

**When to stick with Mailgun:** Stay with Mailgun if you need marketing emails too, or if their enterprise features work better for you.

### Amazon SES: Budget-Friendly AWS Integration

![amazon-ses](//images.ctfassets.net/7154jijfbyeo/q9JJNhn6ZZxvnabpZ7H9L/218f6cdd9b224eeb68e1e6c0f257d027/amazon-ses.png)

**Who it's for:** Developers already using AWS who want cheap email sending.

**What makes it different:** If you're on AWS, SES is incredibly cheap. You pay $0.10 per 1,000 emails. No monthly fees, no commitments. Just pay for what you send.

SES works perfectly with other AWS services. Use CloudWatch to monitor emails, Lambda for automation, and build your entire email infrastructure with AWS tools.

**Pricing comparison:** SES beats everyone on price. Mailgun charges $15/month for 10,000 emails, which works out to $1.50 per 1,000. SES charges $0.10 per 1,000. That's 15 times cheaper.

**When to choose Amazon SES:** Choose SES if you're on AWS, don't mind managing infrastructure, and want the cheapest option. At scale, nothing beats SES pricing.

**When to stick with Mailgun:** Keep Mailgun if you want managed infrastructure without dealing with AWS complexity. Or if you need Mailgun's specific features and support.

### Resend: Modern Developer Experience

![resend](//images.ctfassets.net/7154jijfbyeo/454lXLKBxSAN80lcutw82W/73f481177c8794f84510cd5316ffd209/resend.png)

**Who it's for:** Developers who want a modern, well-designed email API.

**What makes it different:** Resend feels modern. The API is intuitive, the documentation actually helps, and integration takes minutes, not hours. They focused on making email easy for developers.

You get template support, webhook callbacks, and good deliverability. Even though they're newer than the competition, developers love them.

**Pricing comparison:** Resend prices similarly to Mailgun. They offer a free plan, and paid plans start around $20/month for comparable volumes.

**When to choose Resend:** Pick Resend if you value developer experience and clean APIs. They're great if you care more about ease of use than enterprise features.

**When to stick with Mailgun:** Stay with Mailgun for enterprise infrastructure, advanced tracking, or extensive SDK support. High-volume senders often need Mailgun's enterprise tools.

## Key Differences: Mailgun vs Alternatives

Here's what sets each service apart:

**Pricing:** Amazon SES wins on price, especially at scale. Bento usually costs less than Mailgun. SendGrid and Postmark cost about the same as Mailgun.

**Features:** Mailgun has the most enterprise features. SendGrid includes marketing tools. Postmark focuses purely on transactional email. Bento builds in deliverability tools.

**Deliverability:** Postmark is great with delivering transactional emails. Bento includes deliverability infrastructure in the price and has some of the best stats in the business. SendGrid has good practices. Mailgun is decent but nothing special.

**Developer experience:** Resend makes developers happy with clean APIs. Bento has clear documentation. SendGrid works well. Mailgun is powerful but takes time to learn.

Each service has different strengths. Pick based on what you need most: price, features, deliverability, or ease of use.

## Where Bento Fits: Mailgun Alternative with Deliverability Included

If you're looking at Mailgun alternatives, here's what Bento offers.

**Email API access.** Bento has a REST API for sending emails from your code. You get webhooks for tracking delivery events and SDKs for popular programming languages. Works just like Mailgun's API.

**SMTP access.** You can also use SMTP if you prefer. Connect on port 587 with STARTTLS, authenticate with your API key, and send through any standard mail library.

**Deliverability infrastructure included.** Most email services make you handle deliverability yourself. Not Bento. Authentication setup, reputation monitoring, and batching controls come built into the price with no extra tools needed.

**Often more affordable.** You pay for emails you send, not contacts you store. This pricing model usually costs less than Mailgun, especially when you're sending lots of emails.

**When Bento makes sense:** Choose Bento if you want good deliverability without extra work. You care about emails reaching inboxes, and you want to pay less than Mailgun charges.

**When Mailgun makes sense:** Stick with Mailgun if you need their specific enterprise features or extensive tracking capabilities. Some high-volume senders prefer Mailgun's infrastructure.

**The honest pitch:** Bento doesn't replace Mailgun for everyone. If Mailgun works for you, great, but if you want built-in deliverability tools and lower pricing, Bento delivers both.

## Ready to Choose Your Mailgun Alternative?

First, figure out what matters most to you. Is it price? Features? Deliverability? Ease of use? Knowing your priorities makes choosing easier.

Next, calculate the actual costs. Run the numbers based on how many emails you send. SES wins on price at scale. Bento usually costs less than Mailgun. SendGrid and Postmark cost about the same.

Then look at features. Mailgun has enterprise tools. SendGrid adds marketing features. Postmark focuses on transactional email. Bento includes deliverability infrastructure.

Consider deliverability too. Postmark delivers transactional emails best. Bento builds deliverability tools into the platform. SendGrid has solid practices. Mailgun works fine but isn't exceptional.

Finally, test before you commit. Most services offer free trials or starter plans. Try the API, test deliverability, and see if the features work for you.

**Related resources:** Compare more options in our [best transactional email services](/posts/best-transactional-email-services) guide. Learn about deliverability with [email deliverability tools](/posts/email-deliverability-tools). For SMTP comparisons, see [best SMTP email services](/posts/best-smtp-email-services).

There are solid alternatives to Mailgun. Pick based on what you actually need. If you want to see how Bento compares to Mailgun for your specific use case, [we're here to help](https://bentonow.com).


Find Mailgun alternatives for email sending. Compare email API services that offer better pricing, features, or deliverability than Mailgun.

Mailgun Alternatives: Compare Email API and SMTP Services

Every year, around the start of November, we get inundated with emails from people telling us that their emails are landing in the promotions tab instead of the inbox, implying that it's either our fault this is happening or that they can do something to get their emails back into the inbox.

They see the promotions tab as some sort of punishment.

Purgatory for their email sins.

But this couldn't be further from the truth.

Around this time of year, inbox providers such as Gmail, Yahoo, and others tweak their algorithms to help improve the inbox experience for their users. 

You have to think about it from their perspective; almost every brand is coming online to send emails to their subscribers up until Christmas. Those subscribers are getting bombarded non-stop with emails from companies they haven't heard from in months, maybe years!

For the hardcore shopper, this could be up to +500 brands sending daily emails! 

By tweaking the algorithm to push more emails into the promotions tab, they're ensuring that their users see emails that are most important to them and later, when those users are relaxed in a recliner holding a jug of eggnog in one hand and their phone in the other, they can go into the promotions tab and catch up on all the Black Friday and Cyber Monday deals coming up, helping to contribute to the global e-commerce economy.

Afterall, the majority of emails sent in bulk (i.e., broadcast/campaign emails) are promotional by nature, even if they are not explicitly selling something. On our platform, it is very rare for someone to send an email to tens of thousands of people that is not selling or marketing something.

"Ok, ok, but I still want to get my emails into the inbox! That was happening last month! This period is important to me!"

OK; so what can you do? What do you control here?

From our internal research, we've seen that a lot of the classification of emails has to do with the type of content being sent from specific FROM addresses. We believe that during the holiday period, they change their algorithm to more aggressively classify FROM addresses as promotional, which leads to more emails being put in that tab.

For example, if you send a lot of marketing email from hello@domain.com, then we would expect that the majority of those emails would end up in the promotions tab, even if you were sending transactional emails like password resets from the same address.

That's why it's important to split your different types of emails into different FROM addresses to ensure your customers and users don't miss out on important emails.

newsletter@domain.com for your newsletter emails, billing@domain.com for your billing emails, etc.

When we look into the accounts of customers who have raised tickets with us about being moved to the promotions tab for everything, we often see they're using the same email username (hello@, support@, newsletter@, etc.) across all emails they are sending. Split it up! 

But, importantly, don't try to create new senders in hopes that that will land you in the inbox. You cannot game the algorithm. If you switch up the sender, maybe for a short moment you'll land in the inbox, but when the algorithm detects that you're mass emailing, it'll likely classify that email username as promotional and push all future emails from that sender into the promotions tab.

Worse, if they detect you're trying to game the system (i.e unique FROM address for every email — YES we have seen people attempt this!!!), they'll likely block your domain entirely. 

Additionally, in combination with the above, you can also try updating your content to follow these guidelines: avoid using phrases that imply a purchase or sale, ensure your domain is authenticated with DKIM and SPF records, address recipients by their name, limit the email to one link inside, turn off link tracking, exclude images (especially ones from external sources not aligned with your sending domain), refrain from using RSS campaigns, keep the email concise, and avoid using complex HTML (i.e., use the Bento Shoji editor).

... but even if you do all that, it's not guaranteed that you'll land in the inbox, so it's best not to spend time optimizing for something out of your control and instead focus on sending emails that your users want, expect, and love.

Lastly, and maybe most importantly, Gmail has significantly tightened its threshold for what is considered spam recently. In a lot of the private sending communities I'm in, there is chatter from brands who are finding themselves landing in spam more frequently than before and, as a result, witnessing declines in open rates. 

We think they tweak this algorithm to be more aggressive, being OK with potential false positives, mostly to reduce bandwidth consumption caused by such a large influx of emails during the holidays (emails that hit the spam folder do not get scanned or have their links or images proxied/cached). This also explains possibly why open rates decline around this period; yes it could be less people reading emails because they have so many but also we think there's less bot activity requesting links/pixels.

This algorithm change seems to be mostly temporary and reverts back to normal after the holiday season. So, if you are getting spam-foldered, don't worry until January or February (but up until then, maybe clean up your list and follow our deliverability guide? https://bentonow.com/deliverability).

In summary, this season, don't spend time trying to outsmart Google. 

Instead, embrace the promo tab and send great emails to your users.

Discover why emails land in the promotions tab during the holiday season and learn best practices for improving deliverability. Embrace the promo tab and focus on sending valuable emails to your subscribers.

Landing in the Promotions Tab? It's Not Just You, It's the Season!

During the holiday season expect emails to land more in the Promotion tab

It's easy in the chaos of marketing to forget the basics.

One of those basics is just writing a solid email signature. 

We are often lost on what to include in there, so we don't add anything other than our name and an opt-out link.

```
Kind Regards, 
Your Name
Click here to unsubscribe
```

Not very compelling, is it? 

In addition to not being compelling, if your email is ever reviewed by a blocklist provider it's likely you'll get penalized for spam because it looks no different to a cold email which they dislike. It's also missing an address and clear links to our website's privacy policy which you must include in sends.

So, what should our footer look like? 

Here is one that covers all the bases. It's trustworthy, detailed, and is clear to users ... but it's  also devoid of personality so jazz it up a little. 

```
Kind regards,
Your Name

--- 

This is a marketing email from {{ brand }}. You received it because you {{ insert_reason_here }}. Our head office is located at {{ address }}. If you do not want any more marketing emails, {{ visitor.unsubscribe_url | hyperlink: 'click here to unsubscribe' }}, or send an unsubscribe request to the address above. We process all unsubscribes instantly or within a few days getting the mail.

Your privacy is important to us. Please review {{ 'https://example.com' | hyperlink: 'Our Privacy Policy' }}.

To obtain information on how to contact {{ brand }}, visit the web at {{ 'https://example.com/contact' | hyperlink: 'https://example.com/contact' }}. If you have a privacy-related complaint, use our contact page above.

This email has been sent to {{ visitor.email }} and is being sent from {{ author.email }}.

{{ browser_url | hyperlink: 'Read Online' }}
```

The above one can be jazzed up and made fun, but if you want to go completely creative you can take a look at this one included by one of my favourite marketers Daniel Throssell: 

```
🎮 POST-EMAIL GAME MENU
😵 QUIT GAME (UNSUBSCRIBE) ▶️ Sick of these emails? Hate my personality? Can't stand my sense of humour? Honestly, me neither! Hit unsubscribe to stop receiving these emails. (Tip: If you're really angry at me, hit it hard. It probably won't make a difference, but it might help you calm down.)

🧢 NEW GAME ▶️ Did someone forward you this email? Thank them profusely, then start your own adventure at: https://example.com

🏪 COPYMART ▶️ Unlock new and exciting items! Check out the full range of Persuasive Page copywriting training at: https://example.com

🎒 INVENTORY ▶️ Check your currently stocked items & courses in the free Persuasive Page app: https://example.com

🧥 COSTUME ▶️ Gear up for adventure! Customise your character’s outfit with official Persuasive Page merch: https://example.com (AiC subscribers get exclusive pricing on all items! Check your app for details)

❓ HELP! ▶️ App not working? Can't access something you bought? For technical, access or billing issues, contact https://example.com with as much detail as you can, and we will help you out.

🙋‍♂️ #ASKDANIEL ▶️ Got a copywriting question for Daniel? Stuck in a sticky sitch with a client? Hit reply and #AskDaniel! I answer the best Qs in an email each Sunday.

📄 POST-GAME CREDITS & LEGAL ▶️ This email was sent by Daniel Throssell as director of Persuasive Page Pty Ltd. Copyright © 2024 Persuasive Page Pty Ltd. All rights reserved. No part of this email may be “swiped”/added to a swipe file, reproduced or transmitted in any form or by any means without written permission from Persuasive Page Pty Ltd.

💌 SEND MAIL ▶️ Fan mail, death threats and gifts of expensive whisky can be dispatched via messenger kangaroo to:
```

Now that's more like it! Way more fun! 

Your footer doesn't have to be boring, but at the very least it should be compliant and clear. 

Take 30 minutes today and spice up all the authors in your account for better inboxing and less spam reports.

Stuck on a nice, compliant plain text email signature? We got you covered! 

writing a signature on paper dark room ghibli p fc8a48ce-37c9-40a2-b96a-d2ad5f33ac43

Quick Email Signature Examples

**IMPORTANT UPDATE: We have released a [checklist/guide on deliverability](https://bentonow.com/deliverability) which includes our current perspective that our users should implement a Double Opt-In strategy in 2024. It is the best way to ensure that your users are receiving email that is both wanted and expected. This guide is a work in progress and will have more updates to come, please check back later!**

This year, we are prioritizing deliverability as the most important principle at Bento and are aiming to work with all customers to be ahead of the pack.

One area that all users can work on is ensuring that when you send out email it is going to subscribers who both **want and expect** to see your email in their inbox. 

**Sending email that is both wanted and expected is critical when running any email marketing program, more so now than ever before.**

### The Gold Standard

Whilst there are various methods used to build and maintain an email list, one of the best is to implement a Confirmed Opt-In strategy (or more commonly known as Double Opt-In strategy).

It's the one way to ensure that you are building a marketing list of high quality contacts who want to hear from you. 

It is _the_ gold standard when it comes to list building and strongly encouraged by blocklist provides such as [Spamhaus (recommended reading)](https://www.spamhaus.org/faqs/marketing-email/). It is also encouraged by all inbox providers too.

### How does COI/DOI work? 

Once a contact submits an email on your website, whether automatic or manual, you send them an initial email that requests they confirm/consent to further emails. 

Once they click that link or engage, they can then be sent marketing emails. 

If they do not engage, then you can unsubscribe them.

Simple! 

### Why does this work so well?

The internet is filled with bad actors, and those bad actors may submit emails without the permissions of their owners. If you begin to send emails to those users, constantly, you will most likely see an increase in spam complaints and/or a blocklist listing.

This is expensive and time consuming to resolve. 

It will also have an impact on your revenue whilst the issue or blocklist listing persists. In addition to this, a lack of action in 2024 will also see stronger block enforcement from the likes of Google and Yahoo.

### Can't you help fight this spam? 

Over the years, we've tried harder than you could possibly imagine to stop spam sign-ups whether that be the implementation of the Bento Spam API, aggressive rate limiting, and protection of our forms, automatic detection of listbombing attempts, or other strategies. 

There's been a lot of sleepless nights fighting and learning how to block these bad actors, but we will always persist!  

Unfortunately, whilst all those tactics help none of it has been as effective as implementing a Confirmed Opt-In process. There's a reason it's so strongly recommended.

It's truly the only way to ensure that your users are getting the emails they both want and expect.

### Benefits of Confirmed Opt-In and Double Opt-In

Other than being able to sleep well at night, there are many! 

1) By verifying each subscriber, your list becomes cleaner, eliminating inaccuracies such as typo errors in email addresses, which could otherwise inflate your list with non-deliverable contacts.

2) Subscribers who actively confirm their interest are more engaged, leading to higher email open rates over time and, consequently, better deliverability scores. Oh and more revenue! 

3) Implementing this process safeguards your list from fraudulent subscribers, spammers, and automated bots aimed at compromising your email deliverability. A clean list devoid of invalid email addresses ensures genuine subscribers receive your emails and can access your products with ease, maintaining the integrity of your deliverability.

### How to get started with COI and DOI

In Bento, you are able to toggle your account to set all new subscribers to unsubscribed first. You can then set up an automation to send an email based on an event or form submission which requests the users consent. Using a link trigger in the same automation, you can then subscriber (or tag) the user.

Other users prefer to create Confirmed Opt-In flows specific to certain opt-ins or lead magnets. Bento gives you this flexibility, but we encourage you to spend a day or so sitting down to map out every way a user is opted in and ensure that, for your marketing email, those users expect, want, and have consented to those emails.

### Need help? 

As mentioned in the newly created deliverability checklist our team is here and dedicated for every single customer to help them set up an effective double opt-in strategy for their business. Please schedule a call or reach out to support@bentonow.com to talk about ideas to implement today.

In this article, we'll talk about the benefits of Confirmed Opt-In aka Double Opt-In.

backdrop-teaching

Confirmed Opt-In aka Double Opt-In Benefits

Hey, you! Yes you! 

Were you poking around some email headers and noticed one called 'Precedence: Bulk'?

Of course you did, that's why you're here!

Well, let me explain exactly what this header is so you can go about your day.

A few years back, the ISPs (Gmail, Yahoo, etc) began asking email marketers to identify themselves and classify the type of email they were sending upfront (in the email headers).

This was done to help the ISPs process the email quicker and make sure they were landing in the right places.

One of the headers they introduced was called `Precedence`. 

It was a simple header that allowed you to classify the type of email you were sending. 

The most common values were `bulk` and `first-class`. 

The `bulk` value was used for bulk emails, like newsletters or marketing emails. The `first-class` value was used for emails that were more important or time-sensitive, like urgent support, important announcements, or transactional emails (password resets, account confirmations, etc).

You could also include the value `normal`, `urgent`, or `non-urgent` to indicate the urgency of the email. For example, if you were sending an email to a customer service team, you might use the `urgent` value to indicate that the email is time-sensitive and needs to be delivered quickly.

In practice, having sent over a billion emails, we've only seen a difference using `Precedence: Bulk`. ISPs process email so quickly these days that the other options aren't really used anymore and machine learning is mostly doing the heavy lifting for classification.

So, what happens if I include the header?

If you send out a bulk email, with `Precedence: Bulk`, the ISPs will process the email slightly differently and start suppressing all automatic replies. 

This means your inbox won't be flooded with "out of office" messages, and your support email won't accidentally go into an infinite loop. 

As a general rule of thumb, any templated email should include the `Precedence: Bulk` header. Whereas, anything that is sent 1-to-1 like a support ticket or sales message via your CRM should include `Precedence: First-Class` or nothing at all (again, we haven't noticed a difference with inboxing when using this option).

And that's it! That's basically all that header does! 

Whilst there are some theories that it helps with staying out of the spam inbox, in practice we haven't found that to be true. We have some theories that it may help with warming up new IPs but don't have hard data on that being the case.

We hope this helps you understand the `Precedence` header and how it can help you optimize your email marketing efforts. If your email provider is not including this header in their emails, you should raise a ticket with them to see if they can add it for you.

Thanks for reading, and happy emailing!

A few years back, the ISPs (Gmail, Yahoo, etc) began asking email marketers to identify themselves and classify the type of email they were sending upfront (in the email headers). This was done to help the ISPs process the email quicker and make sure they were landing in the right places. Continue reading ... 

stop sign in the middle of an empty road ghibli pas 162bf72e-d563-4a81-97bd-93d756edb13c

What is the Precedence: Bulk header?

Every now and then, we get a support ticket that basically asks, "... my emails keep ending up in the promotions tab! Can you help get them in the inbox?"

"しょうがない! (translated: it can't be helped)", we reply! 

... but that's not entirely true. 

In this post, we'll walk you through how to think of inbox placement and leave you with some steps to take action on.

### Predictability

When it comes to inbox placement, the number one thing to focus on is becoming a predictable brand to inbox providers (Gmail, Yahoo, Hotmail, etc).

You want to: 

Send via predictable addresses (and domains).

Send predictable volume through those addresses.

Send predictable content in that volume.

Afterall, inbox providers need to place your email within seconds of it hitting their servers, and they need your help to train them on where to place it. 

Predictability is key.

### Predictable Senders

The MOST significant signal we've noticed influencing inbox placement is the FROM address. 

alerts@example.com

sales@example.com

notifications@example.com

no-reply@example.com

receipt@sales.example.com

Just by glancing at the above emails, I bet you can quickly predict where each of those emails would end up. 

As you send volume through each of these different addresses, you're essentially training the classifiers to place your emails in specific tabs. 

For example, if they see you send 1,000 transactional reciept emails every single day to users from notifications@example.com they'll reliably place you in the updates tab every single time.

Whereas if they see you sending your newsletter every Thursday from newsletter@example.com then they know they can put those in the promotions tab.

But, what happens if you send all your emails from one address (i.e yourname@example.com)?

... then that's when the classifier gets confused. 

Usually, it gets confused and starts to put all your emails in the promotions tab because, by volume, you a probably mostly sending  marketing emails from that address thanks to your newsletter.

This is also why if you use your personal email for all your marketing newsletters, you'll often have people you work with tell you they didn't get your email because it got lost in the wrong tab. 

This used to happen to me a lot until I started sending different types of emails via different FROM addresses.

Recommendation: ensure you're sending each email from a dedicated inbox for each activity. Keep your personal usernames (name@example.com) for your most important emails, and use them sparingly for your newsletter or marketing mail. 

### Predictable Volume

Once you've set up your email inboxes for each specific type of email, you'll want to maintain consistency with your sending volumes. 

This means sticking with the same address for your newsletter each week, and not switching it up with a different address. 

If you need to send from a different user for a specific announcement (like a "Message from the Founder"), we suggest sticking with the same FROM address as always but just tweaking the name ("Jesse Hanley < newsletter@example.com >). Bento allows you to have as many FROM addresses (called Authors in our platform) as you want. 

### Predictable Content

Last, but certainly not least, you'll want to make sure you're sending the same type of content as always from these addresses. 

This will train the classifiers in such a way that they'll reliably put it in the right every single time.

While you can adjust the content to influence where your email will be placed, we believe it often gets overruled by how the FROM address has been classified.

For example, if you've trained the inbox classifier that emails from jesse@bentonow.com are personal and belong in the inbox, avoid sending content that includes words like "sales", "promotion", or "deal". 

This sudden shift in content may change how future emails are classified and could actually land you in spam. 

### Takeaways

Jump into your Bento account today, create separate FROM addresses (we call these "Authors" in Bento) for every type of email you are sending, and update them all. 

We recommend using different usernames as well as different subdomains for each.

Any questions, please ask in our Discord!

Ever wondered how to land in the primary inbox? We've got you covered in this post!

sorting machine

Can You Predict Inbox Placement?

Predicting Inbox Placement

"Hi! Our users are reporting that our emails are going to spam recently and it seems like the IP has been blacklisted, do you mind having a look?"

That's a message we received on our Discord channel last week from a customer. I thought it would be interesting to share how we tackled this issue and found the root cause. Who knows, it might help you improve your own email deliverability!

The customer shared a screenshot showing that our IP address had been blacklisted by Barracuda: 

![CleanShot 2024-03-08 at 15.40.03@2x](//images.ctfassets.net/7154jijfbyeo/6w6Kat1ZQgYdXTGAEbEcX2/869432fa75a2e65c4d66ebd80c47f6c4/CleanShot_2024-03-08_at_15.40.03_2x.png)

Ouch! 

Now, Barracuda is a big player in the blacklist world, but landing on it isn't necessarily a catastrophe as not everyone uses it. It would particularly impact our customers who had lots of Microsoft Exchange users.

Given I knew this user had a lot of Gmail users, and that's where the complaints were coming from, my first stop in this investigation was Google Postmaster.

Google Postmaster has a handy feature where you can check the reputation of IP addresses; at Bento all of our IP addresses are listed here to monitor. 

The reputation of the questioned IP was marked as "high", which usually means it should be able to deliver emails to Gmail inboxes without a hitch. Google doesn't use Barracuda's blacklist, but usually if I get a listing on Barracuda or another backlist, I'd expect to see a lower reputation score in Postmaster as they are somewhat correlated — but not the case here.

![CleanShot 2024-03-08 at 15.42.31@2x](//images.ctfassets.net/7154jijfbyeo/3iC5xx5dhIg8GHciPa9Db5/18ecb2c8c3f964b5dec988c13a9ccd08/CleanShot_2024-03-08_at_15.42.31_2x.png)

Next, I sent a few test emails from the customer's email address to myself. I noticed that SPF and DKIM weren't set up correctly, as evidenced by a glaring yellow "BE CAREFUL WITH THIS MESSAGE" banner at the top of the email. Our sending domain was also visible there (via ....) 

![CleanShot 2024-03-08 at 15.46.08@2x](//images.ctfassets.net/7154jijfbyeo/Xt3YGYRZwX17Zqpw43MNM/6ce8e0647af3a8a74dd4a6932647baa2/CleanShot_2024-03-08_at_15.46.08_2x.png)

I asked the customer to add the necessary records, thinking that would solve their problem. Afterall, Google and Yahoo were rolling out their new restrictions on email sending and I thought maybe the lack of SPF and DKIM records was the culprit.

They then sent out a resend of their last newsletter. 

A few days later, they reported back that the open rate was still as low as before. 

To my surprise, my test emails were also landing in spam. 

Could it actually be the IP? 

I checked the email performance of a handful of other customers who shared the same IP pool and had sent emails in the past 48 hours. They all had decent open rates, despite the Barracuda listing. 

So, the IP didn't seem to be the culprit. 

Then, I went to this users authors page (a list of addresses they were sending from in their account) and found they were sending from different subdomains and domains.

The customer was sending their newsletter from a subdomain (mail.domain.com). For all their other emails, they were sending from their primary domain (domain.com).

In the world of email marketing, each domain/subdomain combo has its own reputation. It's usually a good idea to send marketing emails from a subdomain to safeguard your primary domain. If you mess up the primary domain, you're in for a world of hurt.

I sent a few test emails from their primary domain and, voila, each one landed in the inbox using the same IP address. Great!

So, the issue seems to be isolated to this subdomain. 

To quadruple-check, I switched this customer to another IP address and sent a few test emails from their subdomain to myself. Same result: all emails still landed in spam. This confirmed that the subdomain was the problem.

I asked the customer to add this subdomain to Google Postmaster. Unfortunately, Google doesn't aggregate subdomains in their reports, so each one you send from needs to be added separately.

And there it was: 

![CleanShot 2024-03-08 at 15.49.48@2x](//images.ctfassets.net/7154jijfbyeo/6vKqjHM9kbS1eVzoxSRvss/0e0872510a0f922883d0c83f35473813/CleanShot_2024-03-08_at_15.49.48_2x.png)

The subdomain was marked as "bad". 

That was the root cause of the deliverability issues with Gmail. 

So, why did this happen?

My theory is that given Google has been implementing more stringent measures, the customer's email list might have contained a bunch of bad emails (spam traps, dead inboxes, etc) so when they sent out their newsletter, they crossed the daily threshold for negative signals. This dropped the reputation of the subdomain leading to the "bad" marking in Postmaster and thus the emails were all flagged as spam.

The solution? I've asked them to segment out their active users (i.e., users who logged in the last 30 days), and send their future newsletters at a slower pace (maybe over a few days instead of within a few hours). Once Google sees you're a good actor, your reputation will gradually improve from bad to medium to high within 90 days.

This customer could also try spinning up a new subdomain and sending from there but be warned, if you mess up with that one, you risk having your entire domain flagged which is far from ideal. 

At the end of the day, debugging deliverability issues is a process of trial and error. It's also fairly black and white, so you'll need to test thoroughly to figure out the real cause to not landing in the inbox.

If you find you're having deliverability issues, regardless if you're a Bento customer or not, please reach out to support!

A fun story diving into debugging a customer's issue landing in the inbox.

a closed door. ghibli. myster. pastel --ar 32 a1eb1589-af62-4920-9bcf-344127ffe62a

Debugging Deliverability: A Real Life Example

During the onboarding process for our customers, regardless of their size, we strive to ensure that each one receives the best deliverability advice possible.

One key piece of advice we offer is to encourage our users to send emails via a subdomain rather than their root or apex domain. In other words, use @mail.example.com instead of @example.com.

Why is this important? 

Since the beginning of 2024, we've observed a significant increase in a phenomenon known as "list bombing". This is an attack where users upload a large list of emails through unsecured forms with the intent to spam them. The usual objective is to overwhelm an inbox to conceal password resets or to exploit vulnerabilities to get a scam offer into a user's inbox for free, like this one:

![CleanShot 2024-03-13 at 15.09.39@2x](//images.ctfassets.net/7154jijfbyeo/2KNP4W9RDDbK0fK4dkCUJv/d7abe60b9de9cdeea52564e8e02bb2c9/CleanShot_2024-03-13_at_15.09.39_2x.png) 

If you fall victim to such an attack, you could find your emails landing in spam, or worse, your domain could be blacklisted and take ages to get delisted.

By sending different types of emails via different subdomains, we can mitigate many of these risks.

For instance, just last week, one of our customers had a form spammed with over a million emails. Our platform automatically detected this and stopped sending, but unfortunately, their other email provider that they used for transactional emails did not, and they found themselves on a blacklist for their primary domain, causing significant issues. 

Had that user separated their different email streams across different subdomains, such as @transactional.example.com for their transactional emails on the other provider and @marketing.example.com for their newsletter and automations on Bento, they could have potentially isolated their issue to just one email stream.

In such a scenario, the customer could simply halt the attack, switch to a different subdomain/provider, and continue doing business as usual.

An important note: only rotate the domain/subdomain once you have confirmed the attack has stopped. Incorrectly doing this could blacklist the entire domain. Additionally, you may need to gradually warm up this new subdomain as it'll have a fresh reputation with inbox providers.

Need ideas for the types of subdomains you should use? Here are some suggestions!

**Transactional Emails**
notifications.example.com
orders.example.com
auth.example.com

**Marketing Emails**
updates.example.com
newsletter.example.com
changelog.example.com

Finally, once you have the above setup and all your SPF/DKIM records added, we recommend setting up a global catch-all for email replies. This ensures that when customers reply to these emails, their responses find their way to a support inbox for your team to respond to. Most hosting providers haave an easy way to set this up, so you can do it in a few minutes.

We hope this advice helps safeguard your email deliverability in the future! 

As always, if you have any questions, please ask in our Discord.

During the onboarding process for our customers, regardless of their size, we strive to ensure that each one receives the best deliverability advice possible.

One key piece of advice we offer is to encourage our users to send emails via a subdomain rather than their root or apex domain. In other words, use @mail.example.com instead of @example.com.

Bento blog

Thinking Through Abandon Cart For Software Businesses