How to Choose an HTML Email Builder and Sender in 2026

Short answer: a developer-led SaaS team that wants transactional templates written in code should start with React Email for the templates and Resend for delivery. Resend's free plan covers 3,000 emails a month, and its Pro plan is $20 a month for up to 50,000 emails, so the first paid step is cheap and predictable. A marketing team that produces newsletters from a visual editor should start from the other end: pick a builder such as Stripo, BEE or Unlayer together with the sender the team already uses, because the editor and the sending service have to work together every week.

This guide treats the builder and the sender as two separate decisions. It covers six template tools (MJML, React Email, Maizzle, Stripo, BEE and Unlayer) and the senders most often paired with them. It gives entry prices where the vendor publishes them, shows what three realistic list sizes cost, and ends with a checklist for moving templates without breaking them. Prices change, so confirm each figure on the vendor's pricing page before you buy.

Split the decision: the builder makes the email, the sender delivers it

Most shortlists mix two jobs. The builder decides how the message is written: markup, components, a drag-and-drop canvas, merge fields, or a reusable block library. The sender decides how the message leaves your system: an API or SMTP connection, domain authentication, bounce and complaint handling, suppression lists, sending limits, and the meter that drives your invoice. Some products do both, but the two jobs still have different owners in most companies, and the cost of each one behaves differently as you grow.

The practical question is where the HTML lives. If templates live in a Git repository and ship with application code, a code-first builder is the natural fit and the sender only needs to accept HTML and report events. If marketers write the newsletter every week, the editor they use every day matters more than the rendering library, and the sender should accept exports from that editor without manual cleanup. Decide that first, and the shortlist shrinks quickly.

What any builder has to survive

An email is rendered by a mail client, not a browser, and the client decides which CSS survives. Outlook on Windows uses a Word-based rendering engine that ignores many modern layout techniques, including several flexbox and grid patterns. Dark mode inverts or overrides colours in ways the sender does not control. Many clients block images by default, so a message whose meaning depends on an image needs live text and alt text. Narrow mobile widths expose fixed-width tables and oversized buttons.

Those four conditions are a practical checklist, not a guarantee. Use a fixed set of test messages: one long newsletter, one short transactional email with a call to action, and one message with dynamic blocks. Render each one in the clients your audience actually uses, with images on and off and in dark mode. A builder that produces clean markup can still land in spam if authentication is missing or the list is poor, so rendering checks belong next to deliverability checks, not in place of them.

Code-first builders

MJML

MJML is an open-source markup language for responsive email. You write a small set of components, and the compiler outputs table-based HTML that is designed to work across many clients. It suits teams that keep templates in a repository, want consistent structure across a large set of emails, and do not want to hand-write table layouts. Because the output is compiled, reviewers see the source components rather than thousands of nested table cells.

MJML falls short in three places. It adds a compile step to the build, which means a new failure mode in continuous integration. Marketers who expect a visual canvas will not get one from MJML alone. And the markup still has to be checked in each target client, because a clean structure does not remove client quirks. The framework itself carries no licence fee. Source and documentation are on the official site at mjml.io.

React Email

React Email lets you write email templates as React components and render them to HTML. It is a good match for a SaaS team that already writes React for its product, because the same developers can reuse components, preview templates locally, and send the rendered HTML through any provider that accepts it. Product emails such as receipts, invitations and password resets often share a header, a footer and a button, and components make that reuse explicit.

The main limitation is that it is a developer tool. Non-developers cannot edit a template without a code workflow, which is fine for transactional mail and awkward for a weekly newsletter. You also still need to pick a sender, and the component library does not make delivery decisions for you. The framework is open source. Documentation is on react.email.

Maizzle

Maizzle is an open-source framework that builds email templates with utility CSS and a Node.js build step. It is aimed at developers who prefer writing HTML and CSS directly, with a build that handles inlining styles, variables and the output for each environment. For a team already comfortable with utility-first CSS in web projects, the learning curve is short and the templates stay readable.

Its weakness is the same as other code-first options: the people who edit templates are the people who run the build. Marketing still needs a separate editing process for ad hoc sends, and the team has to decide whether to keep a shared component library. The framework has no licence fee in its open-source form. The project is documented at maizzle.com.

Visual editors

Stripo

Stripo is a drag-and-drop email editor with templates, reusable blocks and export options for common sending platforms. It suits marketing teams that produce many newsletters and want a canvas that non-developers can use without breaking the layout. Integrations with sending platforms reduce the copy-and-paste work that causes most broken newsletters.

The risk is drift. Templates built in a visual editor can slowly diverge from brand rules, and the exported markup depends on the editor's output. Check how the export handles your sender's merge tags, dynamic blocks and unsubscribe links before committing. Stripo does not publish a price in this guide, so request a quote or read the plans on the official site at stripo.email. Pricing on request.

BEE (Beefree)

BEE is a visual builder that can be used directly or embedded in other products through its plugin and SDK approach. It fits teams that want a familiar editing experience for marketers and the option to embed the same builder inside their own application. The builder's block structure keeps layouts consistent when several people edit the same campaign.

Embedding is a product project, not a checkbox. Someone has to own the plugin configuration, the saved templates and the output rules. Output still needs review in each client, especially for dark mode and narrow screens. Pricing is on request; see beefree.io for current options. Pricing on request.

Unlayer

Unlayer is an embeddable editor SDK. It is designed for SaaS products that want their own customers to build emails inside the product, such as a help-desk tool letting support teams compose replies, or a form tool letting users design notification emails. In that setting, the editor is part of the product, and the product team controls the blocks, merge tags and export format.

The cost of that flexibility is support load. A customer-facing builder produces customer-facing mistakes, and you will need rules for what the editor can and cannot output. If your need is an internal newsletter editor rather than a product feature, a standalone tool will be simpler. Pricing is on request at unlayer.com. Pricing on request.

Senders to pair with them

The prices below are the entry prices shown on each vendor's pricing page. Read the meter carefully: some vendors bill by emails sent, some by contacts or profiles, and some by a combination.

Resend

Best for: developers who want a focused API for product email. Resend's free plan includes 3,000 emails a month, 100 emails a day and three domains. The Pro plan is $20 a month for 50,000 emails, which is the most common first paid step for a product that grows past the free allowance. It works well with React Email because the templates render to HTML that the API accepts directly.

Falls short: the marketing product is metered separately by contacts. For example, Pro marketing at 5,000 contacts is $40 a month, billed monthly, and unlimited broadcast sending is part of that tier. Resend is not a CRM, so a team that needs deep segmentation and sales workflows will need another system. Pricing: resend.com/pricing.

Postmark

Best for: teams whose most important mail is transactional and time-sensitive. Postmark separates transactional and broadcast message streams, which keeps password resets and receipts apart from optional marketing mail. The free plan includes 100 emails a month. The Basic plan starts at $15 a month for 10,000 emails, and the Basic plan at 50,000 emails is $55 a month.

Falls short: plan jumps are large relative to the entry price, and Postmark is not built for behavioural lifecycle journeys. Pair it with a lifecycle tool if you need branching. Pricing: postmarkapp.com/pricing.

Amazon SES

Best for: engineering teams already running on AWS who want low per-message cost and full control of the sending infrastructure. The published rate is $0.16 per 1,000 emails for the 0 to 10 million emails a month band. Eligible new AWS customers can receive up to $200 in credits, and the free plan runs for six months after account creation.

Falls short: SES gives you building blocks rather than a finished product. You own bounce and complaint handling, suppression logic, dashboards and compliance. The per-1,000 rate does not include other AWS services, so model the full bill before you commit. Pricing: aws.amazon.com/ses/pricing.

SendGrid

Best for: teams that want an API for product email and a marketing product from the same vendor. The marketing free plan includes up to 2,000 contacts and 6,000 emails a month. The Basic plan is $15 a month for up to 100,000 contacts and 300,000 emails in the plan selector, and Essentials is $19.95 a month for 50,000 to 100,000 emails.

Falls short: the API and marketing products have different plan boundaries, so the comparison is less direct than it looks. Check which product area you will operate before choosing a tier. Pricing: twilio.com/en-us/products/email-api/pricing.

Mailgun

Best for: engineering teams that want an API and SMTP relay with validation and programmatic control. The free plan allows 100 emails a day. Basic is $15 a month for 10,000 emails. Foundation is $35 a month for 50,000 emails, billed at that price after the first month.

Falls short: editorial marketing campaigns need a separate system, and overage and validation charges can add to the plan price. Pricing: mailgun.com/pricing.

Loops

Best for: product-led SaaS teams that want a focused lifecycle email product with its own editor. The Early Stage plan is free for up to 4,000 sends in any rolling 30 days to the 1,000 newest contacts, with all features included. The Growing Audience plan is $99 a month and includes unlimited sends to subscribers and transactional sends to users outside your audience.

Falls short: the free plan adds a Loops footer and limits sending to 10 emails per second. Confirm the reporting, permissions and API behaviour you need before you build on it. Pricing: loops.so/pricing.

Mailchimp

Best for: marketing teams that want a familiar campaign workflow and a large integration catalogue. The free plan covers up to 250 contacts and 500 sends a month. Standard starts at $20 a month on the default 500-contact selector, and the 5,001 to 10,000 contact tier is $135 a month for up to 120,000 emails.

Falls short: cost rises with contact count, and duplicate contacts can inflate the bill. Mailchimp is broad rather than SaaS-specific, so event-driven product messaging takes more setup. Pricing: mailchimp.com/pricing.

Klaviyo

Best for: ecommerce and commerce-adjacent teams that need profile data, segmentation and revenue-oriented flows. The free plan covers 250 profiles and 500 email sends a month. The email plans start at $20 a month for 500 profiles, rise to $60 a month for 2,500 profiles, and reach $150 a month for 10,000 profiles.

Falls short: the platform is more than a small SaaS team usually needs, and its value depends on clean order and property mapping. Pricing: klaviyo.com/pricing.

Customer.io

Best for: event-driven lifecycle programmes with branching journeys across several channels. Essentials is billed monthly and starts at $145 a month for 10,000 profiles, $235 a month for 20,000, and $325 a month for 30,000. The 50,000-plus band is shown from $505 a month. Eligible early-stage companies that have raised under $10 million can receive 12 months free through the Startup Program.

Falls short: the quality of the journeys depends on event names, identity resolution and ownership of changes. Without governance, a sophisticated tool produces confusing automation. Pricing: customer.io/pricing.

What it costs at realistic list sizes

The table below uses the meter each vendor publishes and shows only prices that vendors list for those sizes. Where a vendor does not publish a price for a size, the cell says so rather than estimating. Amazon SES is shown as arithmetic from its published rate: 1,000 emails cost $0.16, 10,000 emails cost 10 × $0.16 = $1.60, and 50,000 emails cost 50 × $0.16 = $8.00 before other AWS charges.

Vendor and plan (meter)	1,000 contacts or emails	10,000 contacts or emails	50,000 contacts or emails
Resend Pro (emails per month)	$0 on Free (3,000 emails a month)	$20 a month (Pro, 50,000 emails)	$20 a month (Pro, 50,000 emails)
Postmark Basic (emails per month)	Free covers 100 emails; paid from $15 a month at 10,000	$15 a month (Basic, from 10,000 emails)	$55 a month (Basic, 50,000 emails)
Amazon SES Essentials (per 1,000 emails)	$0.16	$1.60 (10 × $0.16)	$8.00 (50 × $0.16)
SendGrid (emails per month)	$0 on Marketing Free (6,000 emails, up to 2,000 contacts)	$15 a month (Basic)	$19.95 a month (Essentials, 50,000 to 100,000 emails)
Mailgun (emails per month)	$0 on Free (100 emails a day)	$15 a month (Basic, 10,000 emails)	$35 a month (Foundation, 50,000 emails, after the first month)
Loops (contacts, sends)	$0 on Early Stage (up to 4,000 sends in 30 days)	Pricing on request	Pricing on request
Mailchimp Standard (contacts)	Pricing on request	$135 a month (5,001 to 10,000 contacts)	Pricing on request
Klaviyo Email plan (profiles)	$30 a month (1,000 profiles)	$150 a month (10,000 profiles)	Pricing on request (plan list ends at 25,000 profiles, $400 a month)
Customer.io Essentials (profiles, billed monthly)	Pricing on request	$145 a month (10,000 profiles)	$505 a month or more (50,000-plus band)

Two patterns stand out. Transactional senders priced per email stay cheap until volume grows, but the first plan jump can be large, as with Postmark moving from $15 at 10,000 emails to $55 at 50,000. Contact-based marketing tools cost little at a few thousand contacts and climb steeply after that, so a list that grows quickly should be modelled at the next band before you sign.

Decision table: which builder and sender fit which job

Use the table below as a starting point, then check it against your own template count, team skills and sending volume.

If you need	Start with	Because
Product email kept in the same repository as the app	React Email with Resend or Postmark	Components render to HTML, and the sender takes that HTML through an API
Responsive templates from a small markup language	MJML with any API sender	The compiler outputs table-based HTML for a wide range of clients
Utility CSS and a Node build for HTML templates	Maizzle with any API sender	Styles are inlined at build time, and the templates stay plain HTML
A visual editor for a marketing team's newsletters	Stripo, BEE or Unlayer with the team's existing sender	Non-developers can edit blocks without breaking the layout
An editor inside your own product for customers	Unlayer or BEE as an embedded SDK	The builder is part of the product, and the product controls blocks and export
The lowest per-message cost at high volume on AWS	Amazon SES	The published rate is per 1,000 emails, and you already run infrastructure on AWS
Branching journeys driven by product events	Customer.io or Loops	Event-triggered flows and segments are the core product, not an add-on
Ecommerce segmentation from orders and catalogue data	Klaviyo	Profile and order data drive the flows, and the platform is built around them
A familiar campaign tool for a broad marketing team	Mailchimp or SendGrid's marketing product	Editors and reporting are established, and the integration list is long

How to choose, step by step

Start with the people. List who will write and edit templates in the next twelve months. If the answer is only developers, a code-first builder is likely to stay maintainable. If marketers will edit weekly, a visual editor with a clean export to your sender matters more than the rendering library behind it.

Next, count your templates and modules. Ten templates that share a header and footer suit a component library. Forty campaign layouts that change every week suit a canvas with saved blocks. Then count volume in both directions: sends per month for transactional mail and contacts or profiles for marketing. Model the next plan band, not only the entry price.

Then check the sender's operational limits. A free plan that allows 100 emails a day is fine for a staging environment and a launch week, but it will fail on a product that sends signup codes in bulk. Confirm daily caps, domain limits, suppression behaviour and what happens to bounced addresses. Finally, check the exit route: can you export templates, contacts, suppression lists and event mappings? A tool you cannot leave is a bigger risk than a slightly higher price.

Workflow: template in code, preview, send

For a code-first setup, keep each template in the repository next to the code that triggers it. Give every template a stable name that the application references, so a change to the template does not silently change the trigger. Render the template in a local preview, then run a build that produces the final HTML and a plain-text version. Send the rendered message to a seed list that covers the clients your audience uses. Only after that should the API call from the application go live, behind a feature flag for the first few days.

For a visual-editor setup, define a small library of approved blocks: header, hero, product card, footer with the unsubscribe link. Require that every campaign is built from those blocks. Test each campaign with images off and in dark mode before it is scheduled. Store the exported HTML with the campaign record so you can roll back to a previous version when a link breaks.

Migration checklist

Moving templates between builders or senders is where most broken emails come from. Use the checklist below before cutting over, and keep the old sender running in parallel until the new one has delivered a full cycle of mail.

Step	What to check	Done when
Inventory templates	List every template, its trigger or schedule, its merge fields and its owner	Every live template appears on the list with an owner
Export and convert	Export HTML from the old editor or source; check merge tags and unsubscribe links in the output	Each converted template renders with the same content as the original
Authenticate the new sender	Add SPF, DKIM and DMARC records for the sending domain	The new sender reports passing authentication on the test domain
Map events and suppressions	Move unsubscribes, hard bounces and complaints into the new sender's suppression list	A suppressed test address is blocked on the new sender
Run both in parallel	Send a small share of traffic through the new sender while the old one stays live	A full cycle of mail has delivered with no unexplained bounces
Check every client	Render each converted template with images on and off, in dark mode and at a narrow width	Each template passes the same checks as the original
Cut over and keep a fallback	Switch traffic, keep the old sender configured for two weeks	No delivery incidents remain open, and the fallback is documented

Where to read next

For a deeper look at building templates, read our HTML email builder guide. For the authentication and list-hygiene side of delivery, read the email deliverability guide. Side-by-side pages are in the email tool comparisons. Apply the same render checks and cost checks to every candidate before you sign.

Frequently asked questions

Do I need both a builder and a sender, or can one tool do both?

Some products cover both jobs, and that can simplify billing and support. The trade-off is that a single tool's editor may not be the best editor for your team, and its sender may not be the best sender for your volume. Choose the combined product when the editor and the sender are both good enough for the people who use them.

Is MJML or React Email better for a small team?

It depends on who writes the templates. If the team already writes React for its product, React Email keeps templates close to the code that triggers them. If the team prefers writing markup directly and wants a compiler to handle table structure, MJML is the more direct choice. Either way, the sender is a separate decision.

Which tool renders best in Outlook?

No single builder renders every message correctly in every client. Outlook on Windows is the most restrictive, and output from any builder should be checked there. Choose the builder whose output you can review and fix quickly, and keep a set of test messages for each client your audience uses.

How do I avoid hitting a free-plan limit during a launch?

Work out the daily and monthly volume of your launch week, then compare it with the free allowance. Resend's free plan is limited to 100 emails a day, Mailgun's free plan to 100 emails a day, and Loops' Early Stage plan to 4,000 sends in any rolling 30 days. Move to a paid plan before the launch, not during it, and keep the old sender live as a fallback.

When does a visual editor make sense for a SaaS team?

A visual editor makes sense when non-developers send frequent newsletters or onboarding campaigns and need to change copy and layout without a deployment. It makes less sense for transactional mail, where templates change rarely and every change should be reviewed as code.

Can I switch senders later without rebuilding templates?

Usually yes, if the templates are plain HTML with standard merge tags and the unsubscribe link is generated in a predictable place. Check the export before you commit to a builder. If the templates depend on a proprietary block format, switching later means rebuilding each template by hand.

Are the prices in this guide current?

The prices shown are the entry prices published on each vendor's pricing page when this guide was prepared. Vendors change plans and allowances without notice, so confirm the current price and meter before you buy and again at each renewal.