How to Add Line Breaks in Email Descriptions Using Power Automate?

How to Add Line Breaks in Email Descriptions Using Power Automate (2026 Guide)

You built the flow. You tested it. The email arrived — and every carefully written paragraph collapsed into one unreadable wall of text. If that sounds familiar, you are in good company. Line break formatting is one of the most searched Power Automate troubleshooting topics in the Microsoft community, and in 2026 it remains a genuine pain point despite the platform’s rapid evolution. With Power Platform now serving over 33 million monthly active users and more than 500 pre-built connectors at your disposal, getting email formatting right is no longer optional — it is a professional baseline.

Table of Contents

Table of Contents

This refreshed guide walks you through every reliable method for adding line breaks in email descriptions using Power Automate, updated for the platform improvements that shipped through 2026 and into 2026.

What Is Power Automate and Why Does Email Formatting Matter?

Power Automate (formerly Microsoft Flow) is Microsoft’s low-code automation platform that connects apps, services, and data sources through automated workflows. From routing SharePoint approvals to sending Dataverse-triggered notifications, Power Automate handles repetitive tasks so professionals can focus on higher-value work — a need underscored by Microsoft’s Work Trend Index finding that 70% of employees say they lack sufficient time to focus on core work.

When Power Automate sends an email, it does not behave like a standard email client where you press Enter and a new line appears. Instead, the email body is rendered as HTML. That distinction is the root cause of almost every line break problem you will encounter.

Why Line Breaks Disappear in Power Automate Emails

In HTML, a plain newline character (\n) is treated as white space and collapsed by the browser or email client rendering engine. Unless you explicitly tell the email client to break the line using an HTML tag, your carefully formatted text arrives as a single, unbroken block.

This behavior affects an estimated 60%+ of email clients when HTML rendering inconsistencies are factored in, making correct line break syntax one of the most impactful formatting decisions you can make inside a Power Automate flow.

What changed for 2026: Microsoft’s updated expression engine (rolled out progressively through 2026) now surfaces clearer IntelliSense hints inside the expression editor, making it easier to spot where a \n character will be stripped. The editor no longer silently accepts \n in plain-text fields without a warning indicator — a small but meaningful quality-of-life improvement for flow builders.

Understanding HTML in Power Automate Email Actions

Before jumping into solutions, it helps to understand the two modes available in Power Automate’s Send an email (V2) action:

• Plain text mode — Line breaks entered in the editor are stripped during HTML rendering.
• HTML mode (Is HTML = Yes) — The body field accepts raw HTML tags, giving you full control over formatting.

Switching to HTML mode is the single most important step you can take before applying any of the techniques below. Without it, even correctly written <br> tags will appear as literal text in the recipient’s inbox.

How to Enable HTML Mode in Send an Email (V2)

1. Open your Send an email (V2) action in Power Automate.
2. Click Show advanced options at the bottom of the action card.
3. Locate the Is HTML field and set it to Yes.
4. Now build your email body using HTML tags for all formatting.

This single toggle unlocks the full range of formatting options covered in the rest of this guide. For a deeper dive into the email action itself, Microsoft’s official Power Automate Email Overview is the authoritative starting point.

Method 1 — Using the <br> HTML Tag Directly

The simplest and most universally supported method is to insert <br> tags directly into your email body wherever you want a line break.

How to Apply It

In the Body field of your Send an email (V2) action (with Is HTML set to Yes), write your content like this:

Dear [Name],<br><br>
Thank you for your submission.<br>
We will review your request within two business days.<br><br>
Best regards,<br>
[Your Name]

Each <br> produces a single line break. Two consecutive <br><br> tags create a blank line between paragraphs — the equivalent of pressing Enter twice in a word processor.

When to Use This Method

• Static email templates where the body text does not change
• Simple notification emails triggered by SharePoint or Dataverse events
• Flows built by users who are comfortable with minimal HTML

Pros and Cons

Pros: – Works in virtually every email client (Outlook, Gmail, Apple Mail) – No expressions required – Easy to read and maintain inside the flow editor

Cons: – Becomes cumbersome in long, dynamic emails – Requires manual insertion of tags for every break – Not suitable when line breaks need to be inserted programmatically into dynamic content

What changed for 2026: The Power Automate flow editor now renders a live preview of HTML content in the email body field when Is HTML is set to Yes. This means you can see formatted line breaks directly in the designer without sending a test email — a significant time-saver introduced in the 2026 designer refresh.

Method 2 — Using the replace() Expression to Convert Newlines

When your email body pulls dynamic content from a SharePoint list column, a Dataverse field, or a form response, that content often contains plain newline characters (\n) rather than HTML <br> tags. The replace() expression converts those characters automatically.

The Expression Syntax

In the Body field of your email action, use the expression editor to write:

replace(triggerBody()?['YourFieldName'], '\n', '<br>')

Replace triggerBody()?['YourFieldName'] with the actual dynamic content reference for your field — for example, the description column from a SharePoint list item or a multiline text field from a Dataverse record.

Step-by-Step Setup

1. In your Send an email (V2) action, click inside the Body field.
2. Switch from the Dynamic content tab to the Expression tab.
3. Enter the replace() expression, referencing your dynamic content source.
4. Click OK to insert it.
5. Ensure Is HTML is set to Yes.

For a full reference on Power Automate expression syntax, Microsoft Learn’s guide on using expressions in Power Automate covers the complete function library.

Handling Both \n and \r\n

Windows-style line endings use a carriage return plus newline (\r\n). If your source data comes from a Windows environment or a legacy system, you may need to chain two replace() calls:

replace(replace(triggerBody()?['YourFieldName'], '\r\n', '<br>'), '\n', '<br>')

This ensures both line ending styles are caught and converted correctly.

When to Use This Method

• Dynamic content from SharePoint multiline text columns
• Dataverse multiline fields feeding into email descriptions
• Form responses from Microsoft Forms or third-party form connectors
• Any scenario where the source data contains plain newline characters

What changed for 2026: The updated expression engine introduced in 2026 now supports improved error messaging when a replace() expression receives a null value — previously a common silent failure. You will now see a clear runtime error rather than an empty email body, making debugging significantly faster.

Method 3 — Using decodeUriComponent('%0A') for Dynamic Line Breaks

A lesser-known but highly reliable technique is using the decodeUriComponent('%0A') expression to generate a newline character dynamically, which you then embed in a Compose action or concatenate with your email content.

Why This Works

%0A is the URL-encoded representation of a newline character (\n). The decodeUriComponent() function decodes it back into an actual newline. When combined with a subsequent replace() expression or used inside an HTML-enabled email body, this gives you a programmatic way to insert line breaks without hardcoding <br> tags in every expression.

Practical Implementation

Step 1: Add a Compose action before your email action. In the Inputs field, enter:

decodeUriComponent('%0A')

Name this Compose action something clear, like NewLine.

Step 2: In your email body expression, reference this Compose output wherever you need a line break:

concat('Line one', outputs('NewLine'), 'Line two', outputs('NewLine'), outputs('NewLine'), 'Line three')

Step 3: Wrap the entire result in a replace() to convert those newlines to <br> tags before they reach the email renderer:

replace(concat('Line one', outputs('NewLine'), 'Line two'), outputs('NewLine'), '<br>')

When to Use This Method

• Complex email templates built entirely through expressions
• Flows where line breaks need to be inserted conditionally based on data values
• Scenarios where you want to centralize the line break character in one reusable Compose action

What changed for 2026: Compose actions can now be renamed and grouped into action folders in the updated Power Automate designer, making it much easier to manage helper Compose actions like a NewLine variable in larger, more complex flows.

Method 4 — Using HTML Paragraph Tags for Multi-Section Emails

For emails with clearly defined sections — an introduction, a details block, and a closing — using <p> tags instead of <br> tags produces cleaner, more readable output across all major email clients.

<br> vs. <p> — Which Should You Use?

Example Structure

<p>Dear [Name],</p>
<p>Thank you for submitting your request. Our team has received your information and will begin processing it shortly.</p>
<p><strong>Request Details:</strong><br>
Reference Number: [Ref]<br>
Submitted: [Date]<br>
Priority: [Priority]</p>
<p>Please do not hesitate to contact us if you have any questions.</p>
<p>Best regards,<br>[Your Name]</p>

This structure uses <p> tags for section separation and <br> tags for line breaks within a section — a combination that renders consistently across Outlook, Gmail, and Teams email notifications.

Cross-Platform Rendering Considerations in 2026

HTML email rendering inconsistencies remain a real-world challenge. According to Litmus email client market share data, HTML rendering behavior varies meaningfully across clients, which is why sticking to the most basic HTML tags (<br>, <p>, <strong>, <a>) gives you the widest compatibility. Avoid CSS margin or padding properties in inline styles for line spacing — many email clients, including some versions of Outlook, ignore them.

What changed for 2026: Microsoft Teams notifications triggered by Power Automate flows now render basic HTML including <br> and <p> tags in the notification body, a capability that was inconsistent in earlier versions. If your flow sends both an email and a Teams notification, you can now use the same HTML-formatted body for both actions without a separate plain-text fallback.

Method 5 — Using Compose Actions to Build Dynamic Email Templates

For professional-grade email automation, using a series of Compose actions to assemble your email body before passing it to the Send an email action is the most maintainable and scalable approach.

Why Compose Actions Are Worth the Extra Steps

• Each section of your email lives in its own Compose action, making it easy to update individual parts without touching the entire expression
• You can apply replace() and concat() expressions at each stage rather than writing one enormous nested expression
• The flow becomes self-documenting when Compose actions are named clearly

Sample Flow Structure

Compose — Header:

concat('<p><strong>Hello ', triggerBody()?['SubmitterName'], ',</strong></p>')

Compose — Body:

replace(triggerBody()?['Description'], '\n', '<br>')

Compose — Footer:

'<p>Best regards,<br>The Automation Team</p>'

Compose — Full Email:

concat(outputs('Compose_Header'), outputs('Compose_Body'), outputs('Compose_Footer'))

Send an email (V2) — Body:

outputs('Compose_Full_Email')

This modular approach makes it straightforward to add new sections, swap out dynamic content sources, or adjust formatting without rewriting the entire email body expression.

For a deeper look at building dynamic templates with Compose actions, explore how to use Compose actions in Power Automate to build dynamic email templates — a technique that scales from simple notifications to complex multi-section reports.

Formatting Email Descriptions in Microsoft Dataverse

When your Power Automate flow pulls email content from Microsoft Dataverse — for example, populating the description field of an email activity record — line break handling requires an additional consideration: Dataverse stores multiline text in plain text format, meaning your HTML tags need to be applied after the data leaves Dataverse, not before it is stored.

The Recommended Approach for Dataverse Email Descriptions

1. Retrieve your Dataverse record using the Get a row by ID or List rows action.
2. Apply a Compose action with a replace() expression to convert \n characters in the description field to <br> tags.
3. Pass the Compose output to the Body field of your Send an email (V2) action.
4. Set Is HTML to Yes on the email action.

Example Expression for a Dataverse Description Field

replace(outputs('Get_a_row_by_ID')?['body/description'], '\n', '<br>')

This converts every plain newline in the Dataverse description field into an HTML line break before the content reaches the email renderer.

Preserve Newlines When Writing to Dataverse

If your flow also writes email descriptions back to Dataverse (for example, logging an outbound email), store the content with plain \n characters rather than <br> tags. Dataverse is a data store, not an HTML renderer — keeping your stored data clean and format-neutral makes it reusable across different output channels (email, Teams, PDF reports) without reformatting each time.

What changed for 2026: Dataverse’s Elastic Tables feature, which reached broader availability through 2026, now supports richer text field types that can store lightweight HTML. If your organization has migrated relevant tables to Elastic Tables with rich text columns, you may be able to store and retrieve <br>-formatted content directly — check with your Dataverse administrator before assuming the standard plain-text behavior applies.

Copilot in Power Automate: AI-Assisted Email Formatting in 2026

One of the most significant platform changes affecting email formatting workflows is the general availability of Copilot in Power Automate, which reached GA status in 2026. Copilot allows you to describe a flow in natural language and have the AI suggest actions, expressions, and configurations automatically.

What Copilot Can Do for Line Break Formatting

When you describe your email formatting requirement to Copilot — for example, “Send an email with the SharePoint item description, preserving line breaks” — Copilot will often suggest:

• Enabling the Is HTML toggle on the Send an email action
• Adding a replace() expression to convert \n to <br>
• Structuring the email body with <p> tags for readability

This does not replace understanding the underlying techniques — Copilot suggestions should always be reviewed before publishing a flow — but it meaningfully accelerates the initial build, especially for users newer to expression syntax.

Using Copilot for AI-Generated Email Summaries with Dynamic Line Breaks

For flows that generate email content using AI Builder or Microsoft 365 Copilot integration, the output text often contains natural paragraph breaks. Applying a replace() expression to the AI-generated output before passing it to the email body converts those paragraph breaks into properly rendered HTML line breaks — the same technique used for Dataverse and SharePoint fields.

What changed for 2026: Copilot in Power Automate now surfaces formatting suggestions proactively when it detects that a flow sends an email with dynamic multiline content. You will see an inline suggestion banner in the designer recommending that you enable HTML mode and apply a replace() expression — a contextual hint that was not available in earlier versions.

Troubleshooting Common Line Break Problems

Even with the correct techniques in place, you may encounter edge cases. Here are the most common issues and their solutions.

Line Breaks Appear in the Flow Editor but Not in the Received Email

Cause: The Is HTML toggle is set to No, so <br> tags are rendered as literal text rather than HTML.

Fix: Set Is HTML to Yes in the advanced options of your Send an email (V2) action.

The replace() Expression Returns an Error

Cause: The source field contains a null value — common when a SharePoint column or Dataverse field is empty.

Fix: Wrap your expression in a null check:

if(empty(triggerBody()?['YourFieldName']), '', replace(triggerBody()?['YourFieldName'], '\n', '<br>'))

Line Breaks Work in Outlook but Not in Gmail

Cause: Gmail strips certain HTML attributes and handles <br> tags differently when the email is sent with mixed plain-text and HTML content.

Fix: Ensure your entire email body is HTML-formatted (not a mix of plain text and HTML tags). Wrapping the full body in a <div> or using <p> tags consistently across all sections improves cross-client compatibility.

Multiple Consecutive Line Breaks Collapse into One

Cause: Some email clients collapse multiple <br> tags into a single line break.

Fix: Replace double line breaks with a <p>&nbsp;</p> block to force a visible blank line:

replace(replace(body, '\n\n', '<p>&nbsp;</p>'), '\n', '<br>')

Low-Code vs. Pro-Code: When to Use Power Automate vs. the Graph API

For the vast majority of email formatting use cases, Power Automate’s built-in Send an email (V2) action with HTML enabled is the right tool. However, there are scenarios where calling the Microsoft Graph API directly — via an HTTP action in Power Automate or through a custom connector — gives you capabilities that the standard email action does not.

When Power Automate’s Built-In Action Is Sufficient

• Standard line break formatting using <br> and <p> tags
• Dynamic content from SharePoint, Dataverse, or Forms
• Emails sent to internal recipients via Microsoft 365
• Flows built and maintained by non-developer professionals

When the Graph API Adds Value

• Sending emails with complex inline images or custom MIME types
• Programmatically setting reply-to addresses, importance flags, or custom headers
• High-volume email scenarios requiring batching through the Graph API’s batch endpoint
• Organizations that need audit-level logging of every email send at the API layer

Gartner projected that by 2026, 70% of new enterprise applications would use low-code or no-code technologies, up from less than 25% in 2020 — a trajectory that continues into 2026. For most professionals, that means Power Automate’s built-in actions will handle their email formatting needs without any custom code. The Graph API remains a pro-code option for edge cases, not a replacement for the standard approach.

Frequently Asked Questions

What is the correct expression to add a line break in a Power Automate email body?

The most reliable approach is to use replace(yourDynamicContent, '\n', '<br>') in the email body field, with Is HTML set to Yes on your Send an email (V2) action. For static content, you can type <br> directly into the body field. Avoid relying on \n alone — it will not render as a visible line break in HTML email clients.

Why does my Power Automate email show line breaks in the flow editor but not in the received email?

This is almost always caused by the Is HTML toggle being set to No. When Is HTML is No, the email body is treated as plain text and <br> tags appear as literal characters rather than line breaks. Set Is HTML to Yes and the formatting will render correctly.

How do I add multiple blank lines between sections in a Power Automate email?

Use <br><br> for two consecutive line breaks, or wrap each section in <p>...</p> tags, which automatically add spacing above and below each paragraph. For a forced blank line in clients that collapse multiple <br> tags, use <p>&nbsp;</p>.

Can I use decodeUriComponent('%0A') to insert line breaks in Power Automate?

Yes. decodeUriComponent('%0A') generates a newline character that you can store in a Compose action and reference throughout your flow. It is particularly useful when you want to build email content through concat() expressions and then apply a single replace() to convert all newlines to <br> tags at the end.

How do I handle line breaks when pulling content from a SharePoint multiline text column?

Use replace(triggerBody()?['YourColumnName'], '\n', '<br>') in your email body expression. If the SharePoint column uses Windows-style line endings, chain a second replace: replace(replace(triggerBody()?['YourColumnName'], '\r\n', '<br>'), '\n', '<br>'). Always set Is HTML to Yes on your email action.

Does Copilot in Power Automate automatically handle line break formatting?

Copilot can suggest the correct approach — enabling HTML mode and applying a replace() expression — when it detects that your flow sends an email with dynamic multiline content. However, you should always review and test Copilot-generated expressions before publishing your flow, as suggestions may need adjustment based on your specific data source and formatting requirements.

Conclusion

Adding line breaks in email descriptions using Power Automate is a solvable problem once you understand the core principle: Power Automate emails are HTML, and HTML requires explicit tags to render line breaks correctly. Whether you use <br> tags directly, the replace() expression for dynamic content, decodeUriComponent('%0A') for programmatic line break generation, or a modular Compose action structure for complex templates, each method has a clear use case and a straightforward implementation path.

Start with Method 1 or Method 2 for most flows, and graduate to the Compose-based approach as your email templates grow in complexity. If you are building new flows in 2026, let Copilot in Power Automate accelerate your initial setup — then verify the output before going live.

Have a specific formatting challenge not covered here? Drop your question in the Microsoft Power Automate Community Forum — it is one of the most active and helpful communities in the Microsoft ecosystem.

#MSFTAdvocate #AbhishekDhoriya #LearnWithAbhishekDhoriya #DynamixAcademy

References & Read More

Related Wealth Stack guides:

• Agent flows vs Power Automate
• Copilot in Power Automate
• Power Fx split function guide

External sources:

• Microsoft Learn – Power Automate Email Overview
• Microsoft Learn – Use Expressions in Power Automate
• Microsoft Learn – Create a Flow in Power Automate
• Microsoft Power Automate Community Forum