Email components

React components for email that look right in Outlook, Gmail, and Apple Mail. Write JSX, call render(), and send the HTML with any provider.

Quickstart

Install the package, write an email in React, and send it.

Write your email as a React component, turn it into HTML with render(), and send it with any provider. The HTML works in Outlook, Gmail, and Apple Mail. You don't need a Unitpost account.

1. Install

Terminal
npm install @unitpost/email zod

React and Next.js apps already have react. In a plain Node project, install it too. zod is a peer dependency. Node 18 or newer.

Or let init set the project up: it adds a starter email to emails/ and an email:dev script to package.json, then prints the install command for anything missing. It keeps files and scripts that are already there.

Terminal
npx @unitpost/email init

2. Create an email

An email is a React component made of the library's components. Pass data in as props, like any other component.

emails/welcome.tsx
import { Section, Heading, Text, Button } from "@unitpost/email/react";

export function WelcomeEmail({ name }: { name: string }) {
  return (
    <Section>
      <Heading>Welcome, {name}</Heading>
      <Text>Thanks for signing up. Confirm your email to get started.</Text>
      <Button href="https://example.com/confirm">Confirm email</Button>
    </Section>
  );
}

3. Render and send

render() returns an HTML string. Send it with the Unitpost SDK, or with the provider you already use (see Integrations).

send.tsx
import { render } from "@unitpost/email/react";
import { Unitpost } from "unitpost";
import { WelcomeEmail } from "./emails/welcome";

const unitpost = new Unitpost(process.env.UNITPOST_API_KEY);

await unitpost.email.send({
  from: "Acme <hello@acme.com>",
  to: "ada@example.com",
  subject: "Welcome to Acme",
  html: render(<WelcomeEmail name="Ada" />),
});

4. Preview while you build

Run the preview server next to your app. It lists every email in emails/, reloads when a file changes, and shows the email at desktop and mobile width, in light and dark, with its HTML, plain text and design checks. Preview props come from Welcome.PreviewProps. It bundles your emails with esbuild, so add it once: npm install -D esbuild. After init, npm run email:dev starts the same server.

Terminal
npx @unitpost/email dev

To see an email in a real inbox, set UNITPOST_API_KEY and UNITPOST_FROM and use Send test.

Using a coding agent?

Run npx skills add unitpostcom/email and your agent learns every component and layout.

Rendering

Which function to call, what it takes, and what it returns.

Most apps only need render(). The other functions are for working without React, or for building editors and tools on top of the library.

FunctionTakesReturnsUse it when
render(<Email />)A React elementAn HTML stringYou write emails in React. Import it from @unitpost/email/react.
parseTsx(source)The same tags, as a stringAn EmailDocument (JSON)You don't use React, or the markup comes from the editor or an agent.
renderToHtml(doc)An EmailDocumentAn HTML stringYou have a document from parseTsx(), fromJsx() or the API.
renderToText(doc)An EmailDocumentA plain-text stringYou want a plain-text part to send with the HTML.
fromJsx(<Email />)A React elementAn EmailDocument (JSON)You want to store an email as data, or turn it into plain text.
printTsx(doc)An EmailDocumentSource code, as a stringYou want to show a document as code. printFragmentTsx() does the same for a layout.

render() is fromJsx() followed by renderToHtml(), and it's synchronous. It runs wherever your code runs: a server, a script, a serverless function. It doesn't use React DOM, so email components can't be mounted on a web page.

Variables

Both render() and renderToHtml() take an optional second argument that fills {{tokens}} when you render. In JSX, write a token as a string, like {"{{first_name}}"}. Values are HTML-escaped, and a token without a value stays as written.

Without React

Write the same tags as a string.

Not using React? Write the same tags as a string, parse it with parseTsx(), and render it with renderToHtml(). It's the format the visual editor and agents use, and it needs no build step.

welcome.ts
import { parseTsx, renderToHtml } from "@unitpost/email";

const doc = parseTsx(`
  <Section>
    <Heading>Welcome, {{first_name}}</Heading>
    <Button href="https://example.com/confirm">Confirm email</Button>
  </Section>
`);

const html = renderToHtml(doc, { first_name: "Ada" });

Props are the same as in React. In a string you can also write them in kebab-case (padding-y), which is how the editor prints them.

Integrations

Send the HTML with Unitpost or the provider you already use.

render() returns plain HTML, so anything that sends HTML email works. Each example sends the WelcomeEmail from the Quickstart.

Unitpost

Send with the Unitpost SDK. Create an API key under Settings → API keys.

send.tsx
// npm install unitpost
import { render } from "@unitpost/email/react";
import { Unitpost } from "unitpost";
import { WelcomeEmail } from "./emails/welcome";

const unitpost = new Unitpost(process.env.UNITPOST_API_KEY);

await unitpost.email.send({
  from: "Acme <hello@acme.com>",
  to: "ada@example.com",
  subject: "Welcome to Acme",
  html: render(<WelcomeEmail name="Ada" />),
});

Unitpost SMTP

Prefer SMTP? Point any SMTP client at the Unitpost relay. The username is always unitpost and the password is an API key with emails:send. This example uses Nodemailer; the SMTP docs cover other frameworks.

send.tsx
// npm install nodemailer
import nodemailer from "nodemailer";
import { render } from "@unitpost/email/react";
import { WelcomeEmail } from "./emails/welcome";

const transporter = nodemailer.createTransport({
  host: "smtp.unitpost.com",
  port: 587,
  secure: false, // STARTTLS
  auth: { user: "unitpost", pass: process.env.UNITPOST_API_KEY },
});

await transporter.sendMail({
  from: "Acme <hello@acme.com>",
  to: "ada@example.com",
  subject: "Welcome to Acme",
  html: render(<WelcomeEmail name="Ada" />),
});

AWS SES

Send with Amazon SES through the AWS SDK.

send.tsx
// npm install @aws-sdk/client-sesv2
import { SESv2Client, SendEmailCommand } from "@aws-sdk/client-sesv2";
import { render } from "@unitpost/email/react";
import { WelcomeEmail } from "./emails/welcome";

const ses = new SESv2Client({ region: "us-east-1" });

await ses.send(
  new SendEmailCommand({
    FromEmailAddress: "hello@acme.com",
    Destination: { ToAddresses: ["ada@example.com"] },
    Content: {
      Simple: {
        Subject: { Data: "Welcome to Acme" },
        Body: { Html: { Data: render(<WelcomeEmail name="Ada" />) } },
      },
    },
  }),
);

Brevo

Send with the Brevo SDK (v6).

send.tsx
// npm install @getbrevo/brevo
import { BrevoClient } from "@getbrevo/brevo";
import { render } from "@unitpost/email/react";
import { WelcomeEmail } from "./emails/welcome";

const brevo = new BrevoClient({ apiKey: process.env.BREVO_API_KEY! });

await brevo.transactionalEmails.sendTransacEmail({
  sender: { name: "Acme", email: "hello@acme.com" },
  to: [{ email: "ada@example.com" }],
  subject: "Welcome to Acme",
  htmlContent: render(<WelcomeEmail name="Ada" />),
});

Cloudflare

Send from a Cloudflare Worker with the Email Service send_email binding. Onboard your sending domain to Email Service first. render() needs Node.js compatibility, which Workers turn on by default from compatibility date 2026-08-04; on older dates, add the nodejs_compat flag.

send.tsx
// wrangler.jsonc
// { "compatibility_flags": ["nodejs_compat"], "send_email": [{ "name": "EMAIL" }] }
import { render } from "@unitpost/email/react";
import { WelcomeEmail } from "./emails/welcome";

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const { messageId } = await env.EMAIL.send({
      from: "hello@acme.com",
      to: "ada@example.com",
      subject: "Welcome to Acme",
      html: render(<WelcomeEmail name="Ada" />),
    });
    return Response.json({ messageId });
  },
};

Mailgun

Send with the Mailgun client.

send.tsx
// npm install mailgun.js form-data
import formData from "form-data";
import Mailgun from "mailgun.js";
import { render } from "@unitpost/email/react";
import { WelcomeEmail } from "./emails/welcome";

const mailgun = new Mailgun(formData).client({
  username: "api",
  key: process.env.MAILGUN_API_KEY!,
});

await mailgun.messages.create("mg.acme.com", {
  from: "Acme <hello@mg.acme.com>",
  to: ["ada@example.com"],
  subject: "Welcome to Acme",
  html: render(<WelcomeEmail name="Ada" />),
});

SendGrid

Send with the SendGrid mail client.

send.tsx
// npm install @sendgrid/mail
import sgMail from "@sendgrid/mail";
import { render } from "@unitpost/email/react";
import { WelcomeEmail } from "./emails/welcome";

sgMail.setApiKey(process.env.SENDGRID_API_KEY!);

await sgMail.send({
  from: "hello@acme.com",
  to: "ada@example.com",
  subject: "Welcome to Acme",
  html: render(<WelcomeEmail name="Ada" />),
});

Postmark

Send with the Postmark client.

send.tsx
// npm install postmark
import { ServerClient } from "postmark";
import { render } from "@unitpost/email/react";
import { WelcomeEmail } from "./emails/welcome";

const postmark = new ServerClient(process.env.POSTMARK_SERVER_TOKEN!);

await postmark.sendEmail({
  From: "hello@acme.com",
  To: "ada@example.com",
  Subject: "Welcome to Acme",
  HtmlBody: render(<WelcomeEmail name="Ada" />),
});

Nodemailer

Send through any SMTP server with Nodemailer.

send.tsx
// npm install nodemailer
import nodemailer from "nodemailer";
import { render } from "@unitpost/email/react";
import { WelcomeEmail } from "./emails/welcome";

const transporter = nodemailer.createTransport({
  host: process.env.SMTP_HOST,
  port: 587,
  secure: false, // STARTTLS
  auth: { user: process.env.SMTP_USER, pass: process.env.SMTP_PASSWORD },
});

await transporter.sendMail({
  from: "Acme <hello@acme.com>",
  to: "ada@example.com",
  subject: "Welcome to Acme",
  html: render(<WelcomeEmail name="Ada" />),
});

AutoSend

Send through the AutoSend REST API.

send.tsx
import { render } from "@unitpost/email/react";
import { WelcomeEmail } from "./emails/welcome";

await fetch("https://api.autosend.com/v1/mails/send", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.AUTOSEND_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    from: { email: "hello@acme.com", name: "Acme" },
    to: { email: "ada@example.com", name: "Ada" },
    subject: "Welcome to Acme",
    html: render(<WelcomeEmail name="Ada" />),
  }),
});

Components

Every building block, with a live preview, its React code, and its props.

Layout

Email

Container

Optional, at most one, and always the outermost element. Its attributes are the page-level settings the Design tab's Page & body panel edits: one parse sets the look along with the blocks, so a branded email is a single write. Without it, the blocks keep the template's current theme.

Open full page

PropTypeDefaultDescription
backgroundColorcolor#f4f4f5Page backdrop around the email card.
bodyColorcolor#ffffffThe email card's background.
contentWidthnumber600Card width (px). 560–640 reads best.
bodyPaddingnumber24Padding inside the card (px). 0 lets full-width sections reach the edges (they bring their own padding).
bodyRadiusnumber0Card corner radius (px).
bodyBorderWidthnumber—Stroke around the card (px); its corners follow body-radius.
bodyBorderStyleenumsolid | dashed | dotted—Stroke style.
bodyBorderColorcolor#e4e4e7Stroke color.
fontFamilystring-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serifDefault font stack (email-safe fonts, with fallbacks).
textColorcolor#1a1a1aDefault text color.
linkColorcolor#2563ebInline link color.
darkModeenumauto | off—"auto" opts in to dark mode: in mail apps set to dark, the card, its text and its links switch to a dark palette (copy on its own background keeps its colours). "off" declares the email light-only. Unset, the email renders as it always has.
darkColorsstring—The dark palette as an object, e.g. {{ bodyColor: "#111111", textColor: "#f5f5f5" }} (backgroundColor, bodyColor, textColor, linkColor). Unset colours are derived.
previewTextstring—Inbox preview text: the snippet shown after the subject.
categoryenumtransactional | marketing—Marketing emails get the managed unsubscribe / postal footer at send — never write it yourself.

Section

Container

Use a Section to band content together — a hero, a card, a footer. It can hold any leaf block and can be nested inside another Section.

Open full page

PropTypeDefaultDescription
backgroundColorcolor—Fill color behind the section.
backgroundImageobject—Optional picture behind the section's content: { src, size: "cover" | "contain" | "auto", position: "center" | "top" | …, repeat: "no-repeat" | "repeat" }. Rendered for every client, Outlook included (VML). Always set background-color too: it shows with images off, and text contrast is checked against it.
paddingXnumber24Horizontal inner padding (px).
paddingYnumber24Vertical inner padding (px).
borderWidthnumber—Border stroke width (px). 0/absent = no visible border.
borderStyleenumsolid | dashed | dotted—Border stroke style.
borderColorcolor—Border stroke color.
borderRadiusnumber—Corner rounding (px). Independent of width — round a filled card without a stroke.

Row

Container

Rows render as a single table row with one cell per column, so they stay side-by-side even in Outlook. A Row may only contain Column components.

Open full page

PropTypeDefaultDescription
columnGapnumber8Horizontal gap (px) between columns. Set 0 for flush.
stackOnMobilebooleantrueBest-effort: let columns wrap on narrow viewports (table emails stay side-by-side in Outlook).
insetXnumber—Optional: pull the row in from the card's edges by this many px on each side, so its background, border and radius sit inside the gutter (a rounded panel with columns).
backgroundColorcolor—Fill color behind the row.
paddingXnumber24Horizontal inner padding (px).
paddingYnumber8Vertical inner padding (px).
borderWidthnumber—Border stroke width (px). 0/absent = no visible border.
borderStyleenumsolid | dashed | dotted—Border stroke style.
borderColorcolor—Border stroke color.
borderRadiusnumber—Corner rounding (px). Independent of width — round a filled card without a stroke.

Column

Container

Columns are table cells. width is a percentage of the row; the widths of the columns in a row should add up to ~100.

Open full page

PropTypeDefaultDescription
widthnumber50Width as a percentage (1–100) of the parent Row.
backgroundColorcolor—Fill color behind the column.
paddingXnumber8Horizontal inner padding (px).
paddingYnumber0Vertical inner padding (px).
borderWidthnumber—Border stroke width (px). 0/absent = no visible border.
borderStyleenumsolid | dashed | dotted—Border stroke style.
borderColorcolor—Border stroke color.
borderRadiusnumber—Corner rounding (px). Independent of width — round a filled card without a stroke.

Content

A title (H1–H4). Inner text supports {{variables}}.

Open full page

PropTypeDefaultDescription
levelenum1 | 2 | 3 | 42Heading level — controls size/weight.
alignenumleft | center | rightleftText alignment.
colorcolor—Text color.
fontSizenumber—Font size (px). Overrides the level's default size (28/22/18/16 for H1–H4).
fontFamilystring—Override the document font for this heading.
fontWeightstring—Font weight (e.g. 400, 600, 700). Overrides the default bold heading weight.
lineHeightstring—Line height — a unitless multiplier (e.g. 1.3) or CSS length.
letterSpacingnumber—Letter spacing (tracking) in px. Great for eyebrow labels.

A bulleted or numbered list. One <li> per item; inline formatting and {{variables}} work inside items.

Open full page

PropTypeDefaultDescription
orderedbooleanfalseNumbered (true) instead of bulleted.
colorcolor—Text color.
fontSizenumber16Font size (px).
lineHeightstring—Line height — a unitless multiplier (e.g. 1.5) or CSS length.

Inner content may include inline HTML for formatting: <strong>, <em>, <u>, <a href>, and <span style> (color / background-color). These round-trip through the visual editor. A pill label (a badge such as "NEW" or a date) is a short Text with custom-css="display:inline-block; padding:4px 10px; border-radius:999px; background-color:#f5f5f4"; set text-align on its Column or Section to place it.

Open full page

PropTypeDefaultDescription
alignenumleft | center | rightleftText alignment.
colorcolor—Text color.
fontSizenumber16Font size (px).
fontFamilystring—Override the document font for this block.
fontWeightstring—Font weight (e.g. 400, 500, 600, 700).
lineHeightstring—Line height — a unitless multiplier (e.g. 1.5) or CSS length.
letterSpacingnumber—Letter spacing (tracking) in px.

Margins are unreliable across clients, so a Spacer renders as an explicit fixed-height cell.

Open full page

PropTypeDefaultDescription
heightrequirednumber24Gap height (px).

A thin horizontal rule to separate sections.

Open full page

PropTypeDefaultDescription
colorcolor#e4e4e7Line color.

Author rich copy in Markdown — compiled to email-safe HTML.

Open full page

PropTypeDefaultDescription
alignenumleft | center | rightleftAlignment.
colorcolor—Base text color.
fontSizenumber16Base font size (px).

A monospace code block — handy for API keys and snippets.

Open full page

PropTypeDefaultDescription
backgroundColorcolor#f4f4f5Block background.
colorcolor#1a1a1aCode text color.

Interactive

A call-to-action — a styled, padded link that looks like a button.

Open full page

PropTypeDefaultDescription
hrefrequiredurl#Destination URL. {{variables}} are allowed.
alignenumleft | center | rightleftHorizontal alignment of the button.
backgroundColorcolor#18181bButton fill color.
textColorcolor#ffffffLabel color.
borderRadiusnumber9999Corner radius (px).
innerPaddingXnumber32Horizontal padding inside the button (px).
innerPaddingYnumber12Vertical padding inside the button (px).

A standalone styled hyperlink (no button background).

Open full page

PropTypeDefaultDescription
hrefrequiredurl#Destination URL. {{variables}} are allowed.
alignenumleft | center | rightleftAlignment.
colorcolor—Link color.
fontSizenumber16Font size (px).
fontFamilystring—Override the document font for this link.
underlinebooleantrueWhether the link is underlined. Defaults to underlined; set false to remove it.

Media

A responsive image, optionally wrapped in a link.

Open full page

PropTypeDefaultDescription
srcrequiredurl—Image URL (use an absolute, hosted URL).
altstring—Alternative text (shown if the image can't load).
hrefurl—Make the image a link to this URL.
widthnumber—Container (frame) width in px. The image scales to fill it; defaults to full content width.
heightnumber—Optional frame height in px. By default the height adapts to the image's aspect ratio — set this to pin an explicit height.
objectFitenumcover | contain | fill—How the image fills the frame when a height is set: cover (crop), contain (letterbox), or fill (stretch). Client support varies.
backgroundColorcolor—Frame background shown around the image when “contain” leaves gaps.
borderRadiusnumber—Corner rounding in px.
alignenumleft | center | rightcenterHorizontal alignment.
borderWidthnumber—Frame border stroke width (px).
borderStyleenumsolid | dashed | dotted—Frame border stroke style.
borderColorcolor—Frame border stroke color.

Advanced

There's no <Html> tag in code mode — any markup that isn't a known component (e.g. a <table> or <div>) automatically becomes an Html block and is emitted verbatim at render. Content passes through the 3-layer HTML sanitizer (scripts, event handlers, and javascript: URLs are stripped) both on save and at render. {{variables}} interpolate inside the markup. Prefer the built-in components when possible — raw HTML is on you to keep Outlook-safe.

Open full page

No component-specific props beyond the common ones.

Common props

Every component accepts these on top of its own props.

PropTypeDefaultDescription
marginBottomnumber16Vertical space (px) below the block.
classNamestring—Tailwind-style utility classes compiled to inline CSS at render (e.g. "mt-4 text-zinc-500 sm:hidden"). Responsive/pseudo variants are hoisted into a <style> block. class and tw are accepted as aliases in code.
customCsscss—Extra inline CSS declarations merged onto the block's root element (e.g. "letter-spacing: 1px; opacity: 0.9"). Inlined so it survives every client.

Set one side at a time with the padding and margin objects in the visual editor's inspector.

Layouts

Ready-made sections built from the components above. Copy the React code into your app, or insert them from the Layouts rail in the editor. The HTML is the same either way.

Header

Centered logo mark — the classic email opener.

Logo + links

Logo on the left, quick links on the right.

Brand header

Logo and brand name on the left, a small label pill on the right (issue, date, 'New').

Wordmark header

The brand name set as a wordmark — the header for a brand with no logo image yet.

Centred header

The logo or wordmark centred, with a small line under it: the issue, the month, 'Your monthly letter'.

Header strip

A thin strip above the logo with one to three facts: free delivery over an amount, the order-by date, the code.

Hero

Simple hero

Big headline, supporting line, and a pill CTA — the transactional first screen.

Image hero

Full-width image above a headline, copy, and CTA — the announcement opener.

Status hero

Eyebrow label + headline + copy — confirmations and status updates.

Headline hero

Overline, big headline, one or two lines and a pill button, left-aligned — the default opener for product and marketing email.

Contrast hero

A full-width brand-coloured (or near-black) band with light text and a light button — launches, sales, big news.

Gradient hero

The contrast hero on a brand gradient. Clients without gradient support (Outlook, Yahoo) show the solid band colour, so text stays readable.

Status hero

A centred status chip, label, headline and line — order confirmed, payment received, booking set.

Media hero

A wide image (a placeholder until you add yours), then headline, line and button — image-led launches.

Banner hero

Rounded campaign art across the email, then a centred headline, line and button: seasonal promos, welcomes, announcements with a mood.

Panel hero

A rounded panel in the brand colour fading into a neighbouring hue: a date pill, a big title, a line and art inside. The cover of a monthly update or digest.

Soft panel hero

The panel hero as a pale two-tone wash of the brand with dark text and the brand button: gentle news, roundups, letters.

Photo panel hero

The panel hero with a photo behind the words (live text over the picture, Outlook included). Pick a dark or quiet photo; the panel colour shows where images don't.

Split panel hero

A rounded colour panel inside the gutter with the title, line and button beside a picture; stacks on phones. The cover of a monthly roundup or a launch.

Event poster hero

A near-black panel: key art first, then the date, time and place as a pill above the event title and the button. Invites, webinars, save-the-dates.

Poster hero

A big upper-case title on the brand colour in a pale frame with a fine inset rule. Needs no image: sales, loyalty, statements, re-engagement.

Newsletter masthead

The publication's name set large over the issue line between two rules, with optional masthead art above: the fixed frame of a recurring newsletter.

Editorial masthead

The masthead in serif with an italic tagline: essays, long reads, curated letters.

Spot hero

One round picture centred over a big title, a subtitle in the brand colour and a hairline: monthly letters, welcomes, gentle news.

Split hero

A brand-colour band edge to edge: the headline, line and button beside a rounded picture, stacking on phones. Webinars, reports, B2B news.

Photo hero

A photo bleeding to the card's edges over a band of the brand colour with the headline and button. Place it under a header.

Content

Card

A soft tinted card for grouped details — receipts, key facts, summaries.

Detail rows

Label/value lines in a tinted card — order summaries and invoices.

Verification code

A big spaced code inside a tinted card — OTP and verification emails.

Quote / callout

An indented callout for a quote or an important note.

Action feature

An emoji icon, a headline, and a button — perfect for calling out a specific setting or next step.

Announcement banner

A tinted callout card with an icon, headline, and link — great for product updates.

Article feature

An eyebrow label, headline, full-width image, and a link — for deep dives and sponsored content.

Feature section

Overline, section headline, a paragraph, three bullets and a text link — one topic of a launch or newsletter.

Icon rows

Three rows of icon + title + line — getting-started steps, what's included, why it matters.

Stats row

Three big numbers with labels on a tinted band — a digest, a year in review, results.

Order summary

A tinted band of label/value lines with a bold total — receipts, invoices, order and booking summaries.

Code card

A big spaced one-time code in a tinted card, with how long it lasts — sign-in and verification.

Callout card

A brand-tinted card with a label, headline, line and link — a 'coming soon', a tip, a side note.

Offer card

A contrast card with the offer as the headline, the code in a pill and a light button — sales and promos.

Event details

Date, time and place (or video link) as icon rows, then an add-to-calendar link — invites, bookings, reminders.

Byline

Who wrote it: a round photo, the name and the date with read time, and a 'Read online' link on the right.

In this issue

A numbered list of what's inside a long issue, each with its read time.

Story rows

Secondary stories: a rounded thumbnail beside an overline, a linked title and a line, with hairlines between.

Quote band

A quote set large on a tinted band, with the person's round photo, name and role. Testimonials, pull quotes, closers.

Sponsor slot

A paid placement, labelled 'Together with …', in a dashed card: a title, two lines and a link.

Curated links: a big accent numeral, the linked title, one line on why, and the source with its read time.

Section label

A tinted bar with an icon and a section's name: opens each section of a long newsletter.

Numbered steps

Big accent numerals with a title and a line each: onboarding steps, a how-to, three reasons.

Trust strip

Three or four facts that remove a doubt (delivery, returns, warranty, secure checkout), an icon over two or three words each.

Price list

Menu-style rows: a name and a line on the left, the price on the right (the old price struck through when there's a real one), hairlines between.

Columns

Split 50/50

Image beside copy — the classic feature split (stacks on mobile).

Two cards

Side-by-side bordered cards — check-in/checkout, before/after, plan A/B.

Three features

Three equal columns for a compact feature or stats strip.

Numbered steps

A stacked 1-2-3 list — onboarding and how-it-works flows.

Product grid

Two product tiles (image, name, price, link) — promos, new arrivals, abandoned cart. Placeholders until you add photos.

Media row

A picture on one side, an overline, title, paragraph and link on the other. Alternate sides from row to row.

Two cards

Two cards side by side on a tinted band: picture, overline, title, two lines and a link. Highlights, articles, offers.

Three pictures in a row with captions: a collection, an event recap, a gallery. Stays side by side on phones.

Reviews

Two short reviews on tinted cards: stars as text, the quote, the name. Real reviews only.

CTA band

A filled band with a headline and a contrasting pill button.

Centered CTA

Just a headline and a pill button — minimal and direct.

Contrast CTA

A rounded brand (or near-black) card with a headline, a line and a light button — the closing ask.

Hairline and a friendly help line — the transactional closer. No postal address or unsubscribe (marketing emails get those from the managed compliance footer automatically).

Logo and a links row (blog, help, contact). No unsubscribe or postal address — those are added automatically by the managed compliance footer.

Two-column footer: a short tagline on the left, app/store links on the right. No unsubscribe or postal address — the managed compliance footer adds those automatically.

A hairline, a 'just reply' help line and a team sign-off. No unsubscribe or address — the managed footer adds those to marketing email.

A closing line, then the sender's round photo, name and role: letters, founder notes, newsletters.

A P.S., a one-click 'Was this useful? Yes · No' and a 'Forwarded this? Subscribe' line. Links only.

The brand's name set large in a soft grey at the very end: a quiet signature before the footer.

Playground

Write email code and see the exact HTML our engine produces — live, in your browser, with nothing to install. It renders through the same pipeline the editor's exact preview and the send engine use.

Open the playground

Search docs and guides

Search the docs and product guides.