Why every transactional email needs a plain-text part
The text/plain alternative helps accessibility, privacy-minded readers, smartwatches and some filters. How to generate a good one rather than a strip.

On this page(10 sections)
- What the text part is
- Who actually reads the text part
- What bad text parts look like
- Missing entirely
- Auto-stripped HTML
- The browser redirect
- What a good text part looks like
- Generating text parts well
- Encoding and character set
- Security and privacy benefits
- Where the text part matters most
- Checklist
- Key takeaways
The plain-text part of an email is the one almost nobody looks at, which is why it is so often broken. Many transactional messages ship with a text alternative that is empty, a wall of stripped markup, or a single line saying "View this email in a browser." That is a missed opportunity, and occasionally a real problem.
What the text part is
A typical HTML email is sent as a MIME multipart/alternative message with two versions of the same content:
Content-Type: multipart/alternative; boundary="b1"
--b1
Content-Type: text/plain; charset="UTF-8"
Your password reset code is 482913. It expires in 15 minutes.
--b1
Content-Type: text/html; charset="UTF-8"
<html>...</html>
--b1--
The order matters: RFC 2046 says alternatives are listed from least to most preferred, so the plain-text part comes first and the HTML part last. A client displays the richest version it can handle and falls back to the others.
Who actually reads the text part
More people and systems than you would expect:
- Users who disable HTML. Some security-conscious users and organizations configure clients to display plain text only, to avoid tracking pixels and rendering exploits.
- Screen reader users, some of whom find plain text easier to navigate than complex HTML layouts.
- Smartwatches and notification previews, which often draw from the text content.
- Terminal and lightweight clients used by developers and system administrators.
- Automated systems, such as ticketing tools and forwarding scripts that only parse text.
- Spam filters, which may compare the two parts. A text part that bears no resemblance to the HTML, or is missing entirely, is a mild negative signal in some filters. It is rarely decisive on its own, but there is no reason to give filters anything to wonder about.
For transactional mail, the case is even stronger. A password reset code or an order confirmation needs to be usable in every context, including a watch face.
What bad text parts look like
Missing entirely
An HTML-only message works in most clients, but loses everything above. Some sending libraries make the text part optional and developers never fill it in.
Auto-stripped HTML
Removing tags from HTML produces something like:
Your order Order number A-10293 Item Qty Price Annual plan 1 $120.00 Total $120.00 View receipt Questions? Contact support Unsubscribe 123 Example St
Table cells run together, links vanish, and the structure that made the HTML readable is gone.
The browser redirect
"This email requires an HTML-capable client. View it online at..." helps nobody who chose plain text on purpose, and it moves sensitive content, like a reset link, onto a web page.
What a good text part looks like
A good text part is written, or at least generated thoughtfully, as its own format:
Your order has shipped
Order: A-10293
Shipped: September 14, 2026
Carrier: Example Post, tracking 9400 1000 0000 0000
Track your package:
https://example.com/orders/A-10293/track
Items
- Annual plan x1 ........ $120.00
Total: $120.00
Questions? Reply to this email or visit https://example.com/help
Example Inc., 123 Example Street, Springfield
Notice the conventions:
- A clear first line that states what happened.
- Key facts as labeled lines, easy to scan.
- Full URLs on their own lines, so they are clickable in clients that auto-link and copyable everywhere else.
- Simple lists with hyphens instead of tables.
- Short lines, ideally under about 78 characters, which RFC 5322 recommends, and certainly under the hard limit of 998.
- The same essential content as the HTML version, not a summary of it.
Generating text parts well
Writing every text part by hand is ideal for a handful of critical templates. For larger template sets, generate it, but generate it from structure, not from finished HTML:
- Keep separate text templates that share the same data and partials as the HTML templates. This is the most reliable approach and easy to review.
- Use an HTML-to-text converter that understands structure as a fallback. Good converters turn headings into underlined lines, links into text followed by the URL, and lists into hyphenated items. Configure it to keep link URLs visible.
- Snapshot test the output alongside the HTML so changes are reviewed.
Whichever you choose, render a few examples and read them in a plain-text view before shipping. Ten seconds of reading catches most problems.
Encoding and character set
Declare charset="UTF-8" on the text part and choose a transfer encoding that keeps lines intact. For mostly-ASCII content, quoted-printable is common: readable in raw form and safe for any non-ASCII characters. Base64 also works but makes the raw source unreadable for debugging. Either way, use CRLF line endings on the wire, as SMTP requires; most mail libraries handle this for you.
Beware of smart quotes, em dashes and non-breaking spaces copied from design tools. They are valid UTF-8, but an incorrectly declared charset turns them into mojibake like ’.
Security and privacy benefits
A plain-text part contains no tracking pixel and no remote images, which is exactly why some users prefer it. It also renders no scripts, styles or forms. For security-sensitive messages such as login codes, a clear text part means recipients who distrust HTML still get what they need without lowering their guard.
Be careful that the text part does not leak anything the HTML deliberately hides. If your HTML truncates an account number to the last four digits, the text part must too.
Where the text part matters most
If you only have time to hand-write a few text parts, prioritize by consequence:
- Authentication messages: sign-in codes, magic links, password resets and email verification. These must work on a watch, in a terminal and with HTML disabled.
- Security notifications: new device sign-ins, password changes, API key creation. Recipients who distrust HTML are exactly the audience for these.
- Money: receipts, invoices, failed payment notices and refunds, where the amounts and references must be unambiguous.
- Everything else, generated from structure with a good converter.
Checklist
- Every transactional message includes a
text/plainalternative listed before the HTML part. - The text part contains the same essential facts and actions as the HTML.
- Links appear as full URLs on their own lines.
- Lists use hyphens; tables become labeled lines.
- Lines are short, and the charset is declared as UTF-8.
- Text output is snapshot-tested and read by a human before release.
- Sensitive data is masked identically in both parts.
Key takeaways
- The plain-text part serves users who disable HTML, screen readers, watches, automation and some filters.
- Stripping tags from HTML produces an unreadable text part; generate it from structure or write it.
- Put full URLs on their own lines and keep every key fact as live text.
- Test the text part like any other output, because nobody notices when it breaks.
Start with Koltrix
Your domain, one inbox, and an API that sends.
A team inbox where AI sorts and drafts (nothing is sent without your click), plus the transactional API and SMTP relay your product sends with. 7 days free, no card.

