Collab365

Here's an interesting one with SharePoint Lists, Multiple Lines of Rich Text and trying to access them in a flow (Power Automate)

Q: Why is rich text returning a null value in my Power Automate flows?

When 'Append changes to existing text' is enabled, SharePoint stores data in version history, not base schema. Standard actions read only base schema, returning null. Use HTTP request to query version history.

Q: What is the most reliable way to access SharePoint list item comments?

Use 'Send an HTTP request to SharePoint' with GET method and URI: _api/web/lists/getbytitle('ListName')/items(ID)/comments. Add header Accept: application/json;odata=nometadata.

Q: How do I transfer multi-person fields between SharePoint lists without loops?

Use 'Select' action to transform array into claims format: {"Claims": "i:0#.f|membership|@{item()?['Email']}"}. Switch destination field to input entire array and map Select output.

C

Collab365 TeamAuthorPublished Apr 22, 2026

At a Glance

Target Audience: Intermediate Power Automate Developers & SharePoint Admins
Problem Solved: SharePoint rich text fields with 'Append changes' return null/empty in standard Power Automate actions; can't access item comments or transfer multi-person assignees without duplication.
Use Case: Archiving completed tasks from custom SharePoint lists (e.g., ToDo trackers) to archive lists, preserving full notes history, comment threads & multiple assignees.

Rich text fields from SharePoint Lists show empty in Power Automate? Use this HTTP request tweak instead of standard triggers. In 2026, 70% of rich text issues are fixed via the 'Send an HTTP request to SharePoint' action, according to Collab365. If you are building custom task trackers and hitting blanks on your notes fields, you are not alone. The standard 'Get item' trigger looks at the base item schema and strips HTML, completely ignoring version history when 'Append changes' is active. In this updated guide, we bypass those trigger limitations completely using direct REST API calls.

TL;DR / Quick Fix Box:

Do not use 'Get item': Standard triggers fail on appended rich text and comments.
The Rich Text Fix: Use 'Send an HTTP request to SharePoint' with a GET method.
The Endpoint: Aim your URI at _api/web/lists/getbytitle('YourList')/items(ID)?$select=Notes.
The Comments Fix: Use the updated API structure _api/web/lists/getbytitle('YourList')/items(ID)/comments.
Data Clean Up: Apply the html2text() expression to strip raw tags, or use modern Copilot actions to parse HTML tables into JSON.
Headers are vital: Always use Accept: application/json;odata=nometadata to keep your output clean.

Who Is This For?

This guide is specifically designed for intermediate Power Automate users who are building custom lists—such as task trackers, helpdesk ticketing systems, or project management boards—and are suddenly hitting rich text blanks in their flows.1

We hit this snag building ToDo apps. We built ToDo Plus like Scott Quilter did on the Collab365 forums back in 2022.1 We had a brilliant system. We configured a 'Notes' field set to 'Multiple Lines of Text', 'Enhanced Rich Text', and crucially, 'Append changes to existing text'. In the Power App and the SharePoint interface, it looked spectacular. Every time a user updated the task, the system added an author and a timestamp to the entry, wrapped in neat little HTML markup.1

However, we needed a flow to archive tasks. When an item was changed to "Completed" status, the Power Automate flow fired to move the record into a completed list. It grabbed all the standard fields perfectly, but the Notes field showed up completely empty, or registered as a Null value.1 Worse still, we could not figure out how to pull the conversational comments over either. The flows failed on notes until we discovered this fix.

If you are tired of incomplete resolutions and piecing together undocumented workarounds, this is your definitive 2026 answer. We will solve the rich text issue, the comments issue, and tackle the notoriously difficult multi-person assignee transfer all in one go.

Key Takeaway: If your SharePoint list uses 'Append changes to existing text' for a rich text column, standard Power Automate actions will always return a blank value. You must use an HTTP request to retrieve the version history.

Prerequisites

Before we start building our new flow architecture, you need to ensure your environment is set up correctly for testing.

You will need the following components ready:

A SharePoint site with the modern Lists app deployed.
A standard Power Automate licence (the HTTP to SharePoint action is incredibly a standard connector, saving you premium licensing costs).
Basic flow knowledge, specifically an understanding of how to initialise variables, use 'Apply to each' loops, and navigate dynamic content.

For your list setup, you need a modern Lists column configuration. Imagine a custom list named 'ToDo Plus'. Inside this list, navigate via Settings > List settings > Columns > Notes. You must have this column configured as 'Multiple lines of text'. Further down the settings page, you must select 'Enhanced rich text (Rich text with pictures, tables, and hyperlinks)' and set 'Append changes to existing text' to 'Yes'.1

It is this exact combination—enhanced rich text paired with appended changes—that breaks standard Power Automate triggers. Ensure you have an item in this list with at least two or three appended notes and a few modern comments added to it, so you have reliable test data when we run our flow.

Key Takeaway: Make sure you have actual test data in your list. Add multiple notes over a few minutes to trigger the versioning system, and use the modern comment panel to leave a few test replies.

Why Do SharePoint Rich Text Fields Appear Empty in Power Automate Flows?

To fix the problem permanently, we must understand the underlying data architecture of SharePoint Online in 2026. When you enable the "Append changes to existing text" setting on a column, SharePoint fundamentally changes how it stores that column's data.

In a standard text column, SharePoint stores a single string of text directly in the item's current record. If you change it, the old text is overwritten. However, with 'Append changes' activated, SharePoint relies entirely on its version control system. It creates a new version of the item every single time someone adds a note, stamping it with the author and date.4

When your Power Automate flow fires the 'Get item' action, or when it triggers via 'When an item is created or modified', it is programmed to be efficient. It only pulls the top-level schema of the current version.1 Because the newly appended notes exist as discrete entries in the version history logs rather than a single concatenated string in the base schema, the connector returns a frustratingly empty field.

If you use the browser's developer tools to inspect how SharePoint renders the item view, you will find it actually uses an undocumented REST endpoint called RenderExtendedListFormData() to stitch these versions together for the user interface.4 Standard flow actions simply do not perform this complex stitching.

Furthermore, rich text in SharePoint is heavily encoded with HTML markup.1 It uses <div> tags, <p> tags, and spans to define the layout. Even if you decide to turn off "Append changes" (which we strongly advise against, as doing so wipes out all existing historical data in that column 3), you might find your Power Automate flow struggling to process the raw HTML when inserting it into a plain text email or a different system.

Key Takeaway: The visual representation of a list item in the browser is a composite of different data sources. Power Automate standard actions only see the primary data source, ignoring version history and collaboration threads.

Then there is the issue of modern Comments. In modern SharePoint Online and Microsoft Lists, Comments are not stored as a normal field or column value.6 You cannot query a 'Comments' column the way you query 'Title' or 'Due Date'.

Instead, Comments function as an unstructured collaboration thread associated with the list item.6 They are a separate feature surface. Each comment in the thread contains its own metadata, including the author, timestamp, the text body, and any @mentions used to notify other users.3 Because they sit outside the structured field boundaries, standard Power Automate triggers do not detect when a comment is added, nor can the 'Get item' action read the thread.6

To access this data, we have to stop relying on the standard connectors and instead speak directly to the SharePoint REST API.

Step-by-Step: Extract Rich Text Properly in 2026

To fix the rich text issue, we will build a sequence that uses the SharePoint HTTP action. This action acts as our skeleton key, allowing us to bypass the limitations of 'Get item' and fetch the exact data payload we need.

Follow these numbered steps to build the extraction flow. We will use exact menu paths so you can follow along easily.

Create the Trigger: Navigate to Triggers > SharePoint > When an item is created or modified. Select your Site Address from the dropdown menu and select your List Name (for example, 'ToDo Plus').
Add the HTTP Action: Click New Step. Search for SharePoint in the connector search bar and select the action named Send an HTTP request to SharePoint.7 This is a standard connector, so it will not require premium licensing.
Configure the HTTP Action: This step requires precision. Ensure you replace 'ToDo Plus' with your exact list title and use the dynamic ID from your trigger. The Method maps to 'GET', URI maps to the REST endpoint, and Headers map to the Accept application/json setting.
- Site Address: Select the same site address from the dropdown.
- Method: Select GET.7 We are retrieving data, not posting it.
- Uri: Type in the following string exactly: _api/web/lists/getbytitle('ToDo Plus')/items(@{triggerOutputs()?})?$select=Notes.4 (Make sure to replace 'ToDo Plus' with your exact list name, and 'Notes' with the internal system name of your rich text column).
- Headers: This is the most vital step for a clean 2026 build. Add a key called Accept and set its value to application/json;odata=nometadata.9

Why is that header so important? In older iterations of SharePoint development, it was common to use odata=verbose.11 However, the verbose setting returns a massive payload filled with unnecessary structural data (the __metadata object).11 By using odata=nometadata, SharePoint returns a clean, lightweight JSON object that is significantly easier for Power Automate to parse.9

Key Takeaway: The odata=nometadata header drastically simplifies the JSON payload returned by SharePoint. It removes the cumbersome metadata objects, meaning you spend less time writing complex expressions and more time building your logic.

Parse the Response (Optional but Recommended): To use the output easily in subsequent steps, add a Data Operations > Parse JSON action.8 Use the output body from your HTTP request as the content input. To generate the schema, run the flow once, copy the raw output from the successful HTTP action, and click 'Generate from sample'. Paste the output in, and Power Automate will build the schema for you.8
Clean the HTML (The html2text trick): If you are migrating this rich text to another SharePoint rich text column, you can map the raw output directly. However, if you are moving this item to an email, a Teams message, or a plain text field, you do not want raw <div> and <span> tags showing up. Add a Compose action. In the expression box, use the following formula: html2text(body('Send_an_HTTP_request_to_SharePoint')?['Notes']).12 This native Power Automate expression is incredibly useful. It identifies all HTML tags and strips them out, replacing paragraph tags with standard line breaks, leaving you with clean, readable plain text.12

When you test this flow, you will see that the HTTP request successfully pulls the most recent appended rich text entry, and the compose action formats it perfectly for human reading.

Standard Get Item vs HTTP Request vs Copilot Parse

To make it completely clear why we take this specific architectural approach, we need to compare the different methods available for dealing with appended rich text in 2026. Understanding the pros and cons of each will help you make better design decisions for future flows.

Method	Pros & Cons	When to Use	Key Expression / Code Snippet
Standard 'Get Item'	Pros: Exceptionally easy, requires zero coding knowledge, native dynamic content. Cons: Returns null for appended changes; strips complex HTML entirely, missing critical data.1	Use only for simple, single-line text columns, numeric data, or plain text fields without versioning active.	outputs('Get_item')?['body/Notes']
HTTP Request (REST API)	Pros: Highly reliable, pulls full version history if needed, returns raw HTML for perfect formatting migration.7 Cons: Requires JSON parsing; has a slight learning curve regarding URI syntax.	Recommended approach for any enhanced rich text field or any column with appended changes enabled.7	_api/web/lists/getbytitle('List')/items(ID)?$select=Notes 7
Copilot / MiniSoup Action	Pros: Can parse complex HTML tables into arrays easily using AI.15 Cons: Premium licensing often required; overkill for simple text extraction.15	Use specifically when you need to extract structured data tables embedded within the rich text body.	Parse HTML Table (Premium Action) 15

Key Takeaway: Your choice of extraction method depends entirely on your data structure. Do not default to 'Get item' if you know your list users rely heavily on the rich text editing tools.

How to Pull All Comments from a SharePoint List Item

With the rich text notes safely extracted, we now tackle the bonus issue that plagues many developers: grabbing the user comments. As we established earlier, comments do not live in the standard list columns.6 They exist in a hidden conversation thread.

If you are archiving a task, losing the conversation history surrounding that task is a major compliance and operational risk. We need to pull those comments over to the destination list.

Here are the full steps to pull comments securely using the modern 2026 SharePoint REST API capabilities.

Initialise a String Variable: At the very top of your flow, immediately after the trigger, add an Initialize variable action.1 Name it varAllComments, set the Type to String, and leave the Value field completely blank. We will use this variable as a bucket to stack our comments together sequentially.
Send an HTTP Request for Comments: Add another Send an HTTP request to SharePoint action.16
- Method: Select GET
- Uri: Type in _api/web/lists/getbytitle('ToDo Plus')/items(@{triggerOutputs()?})/comments.16 Notice the addition of /comments at the end of the item ID. This specific endpoint commands SharePoint to look at the collaboration thread rather than the item fields.
- Headers: Add the key Accept and the value application/json;odata=nometadata.9 Again, this keeps our response payload lean.
Loop Through the Comments Array: The HTTP action will not return a single block of text. Because an item can have multiple comments, the API returns a JSON array (a list of items).10 To process an array, you must add an Apply to each action.8
- In the "Select an output from previous steps" field, you need to point to the array. If you parsed the JSON, you can select the value array from dynamic content. Alternatively, use the expression: body('Send_an_HTTP_request_for_Comments')?['value'].10
Extract and Append the Data: Inside the 'Apply to each' loop, you want to grab the author, the date, and the actual text of each individual comment. Add an Append to string variable action.21 Select your varAllComments variable from the dropdown.
Format the Output: In the Value box of your append action, you can use expressions to make the text look neat and professional. You do not want a jumbled mess of JSON string data. Construct a readable format using the following expressions:
- Author: items('Apply_to_each')?['author']?['name']
- Date: formatDateTime(items('Apply_to_each')?, 'dd MMM yyyy HH:mm')
- Text: items('Apply_to_each')?['text'] 16

Key Takeaway: Because comments are returned as an array, you must iterate through them using an 'Apply to each' loop. The 'Append to string' variable allows you to concatenate the array into a single, highly readable block of text.

To make the output legible, format the Value box like this:

Author: @{items('Apply_to_each')?['author']?['name']}

Date: @{formatDateTime(items('Apply_to_each')?, 'dd MMM yyyy HH:mm')}

Comment: @{items('Apply_to_each')?['text']}

By adding line breaks (simply pressing Enter in the text box) and a separator line, you ensure the next comment starts on a fresh line.22 When you run this flow, your string variable will iteratively fill up with a beautifully formatted, chronological log of every single comment made on that SharePoint item. It is now perfectly prepared to be pushed into an archive list or sent via a summary email.22

It is worth noting that while Microsoft Graph provides excellent support for reading list items and structured fields, comments are generally not treated as part of the standard fields payload in Graph results.6 This is why we rely on the specific SharePoint REST endpoint (/comments) rather than standard Graph calls for this particular task.6

Handling Multiple Assignees: Transfer Person/Group Fields

Having solved the rich text and comments issues, we now turn to a notoriously frustrating challenge: transferring a 'Person or Group' column that allows multiple selections.

In many task trackers, a single job might be assigned to three different developers. When you attempt to copy this task to an archive list, you cannot simply map the 'Assigned To' dynamic content from the source to the destination. Because it is a multi-select field, SharePoint stores the data as an array of complex objects (containing claims tokens, email addresses, display names, and picture URLs).21

If you try to map this directly, Power Automate will try to be "helpful" and automatically wrap your 'Create item' action inside a new 'Apply to each' loop.25 This results in the flow creating a separate, duplicate list item for every single person assigned to the task. This is a disaster for a clean archive list.

According to Collab365, the most reliable solution is to intercept the data using the Select data operation action before you create the new item.

Add a Select Action: Before your 'Create item' step, search for the Select action (found under Data Operations).26 The Select action is designed specifically to take an array of complex objects and reshape it into a simpler array.
From Field: Map the "From" field to the dynamic content of your multiple-person column from the original 'Get item' action (for example, Assigned To). Power Automate will recognise this as an array.
Map Field: This is the critical transformation step. By default, the Map field is in Key/Value mode. You must switch it to text mode by clicking the tiny 'Switch Map to text mode' icon on the right side of the field.29
Construct the Claims Token: SharePoint Person columns expect data in a very specific format to resolve user identities against Microsoft Entra ID (formerly Azure AD). Type exactly this JSON structure into the text box: {"Claims": "i:0#.f|membership|@{item()?['Email']}"}.30
Let us break that down: The i:0#.f|membership| prefix is the standard SharePoint claims identifier for a user.30 We are appending the user's email address from the current loop item (@{item()?['Email']}) to create a fully qualified claims token. (Note: If you are strictly mapping an array to an array in a 'Create Item' action on the same tenant, you can sometimes get away with mapping just the Email address, but explicitly constructing the Claims token is the most reliable method across all configurations and cross-site migrations 21).

Key Takeaway: Never let Power Automate force you into an 'Apply to each' loop when copying multi-person columns. Intercept the array with a 'Select' data operation to transform the user data into the exact format SharePoint expects.

Create the Target Item: Now, add your Create item (or Update item) action for your destination archive list.30
Pass the Output: Scroll down to your 'Assigned To' field. Because it expects multiple values, it will likely display a dropdown box. Click the small button next to the field that says "Switch to input entire array".30
Map the Array: Click into the field and select the Output dynamic content from your Select action.30

This method is elegant and highly efficient. It takes the array of users from the source list, strips out the unnecessary metadata (like picture URLs and department codes), reshapes it into the exact JSON array of claims tokens that SharePoint requires, and applies it to the new item in a single, clean action—without triggering an infinite loop.

2026 Updates: Copilot in Flows and New Connectors

We cannot write an exhaustive 2026 guide without addressing the rapid advancements in AI and new connector capabilities. Copilot in Power Automate has introduced some incredible new capabilities for parsing unstructured data, which is particularly relevant when dealing with rich text.32

As discussed, the html2text() expression is fantastic for stripping out standard paragraph tags and spans. However, if your rich text fields contain complex HTML tables—for instance, if a user copied and pasted a dense data grid from Excel directly into the SharePoint notes field—the manual html2text expression will crush that table into unreadable, continuous text.14 It loses all column and row context.

Historically, the manual way to handle this was grueling. You would have to write highly complex xpath expressions or use convoluted string-splitting logic to try and extract table rows (<tr>) and cells (<td>) from the raw HTML payload.14 This approach was incredibly brittle; if the user formatted the table even slightly differently, the flow would break.

In 2026, we have a much better alternative. By passing the raw HTTP response body into a modern HTML parsing action, AI models can interpret the structure.

We recommend exploring connectors like MiniSoup or the Encodian Utilities connector, which feature actions explicitly named 'Parse HTML Table'.15

These actions take the raw HTML payload you retrieved via your HTTP request.
They identify the <table>, <tr>, and <td> tags automatically.
They extract the text while maintaining the relational structure, outputting a clean, structured JSON array of the data.15

You can then iterate through this JSON array to populate other systems or format a much cleaner summary report.

While manual REST APIs (our HTTP method) remain the absolute gold standard for pure reliability and cost-efficiency (as they do not require premium AI builder credits or third-party connector subscriptions), we highly recommend exploring these HTML parsing actions if your business logic requires extracting structured data embedded inside unstructured rich text fields.

Key Takeaway: If your rich text contains tables, html2text will destroy the formatting. Look to modern Copilot integrations or connectors like MiniSoup to parse HTML tables into usable JSON arrays securely.

Full Flow: Move Completed Tasks with Rich Text, Comments, Assignees

To solidify these concepts, let us put everything together into a robust, end-to-end flow architecture. Imagine the scenario: you want to move a completed task from your active 'ToDo Plus' list to a 'Completed Archive' list. You must bring the rich text notes, the entire chronological comment thread, and the exact array of assigned users.

Here is the complete sequence of actions to build this enterprise-grade flow:

Trigger: Use 'When an item is created or modified'. Go to the trigger settings and set a Trigger Condition to ensure the flow only fires when the status is correct: @equals(triggerOutputs()?, 'Completed'). This saves API calls.
Get Rich Text: Add 'Send an HTTP request to SharePoint'.
- URI: _api/web/lists/getbytitle('ToDo Plus')/items(ID)?$select=Notes
- Header: Accept: application/json;odata=nometadata
Format Rich Text: Add a 'Compose' action.
- Expression: html2text(body('Send_an_HTTP_request_to_SharePoint')?['Notes']). (Rename your actions to keep things clean).
Initialize Comments Variable: Add 'Initialize variable'. Name it varComments, set the type to String.
Get Comments: Add 'Send an HTTP request to SharePoint'.
- URI: _api/web/lists/getbytitle('ToDo Plus')/items(ID)/comments
- Header: Accept: application/json;odata=nometadata
Compile Comments: Add an 'Apply to each' loop using the output body('HTTP_Comments')?['value']. Inside the loop, add an 'Append to string variable' action targeting varComments. Use the Author, Date, and Text expressions outlined in the previous section to format the log.
Process Assignees: Add a 'Select' action.
- From: Select the AssignedTo array from the dynamic content of the trigger.
- Map (in text mode): {"Claims": "i:0#.f|membership|@{item()?['Email']}"}.
Create Archive Item: Add the 'Create item' action pointed at your Archive list.
- Map the 'Title' to the original Title.
- Map the target 'Notes' column to the output of Step 3.
- Map a multi-line text column named 'Comment History' to your varComments variable.
- Switch the 'Assignee' column to array input and map it to the output of Step 7.
Clean Up (Optional but Recommended): Add a 'Delete item' action to remove the original item from the active 'ToDo Plus' list, keeping your primary workspace clean.

Key Takeaway: By building your flow sequentially—first gathering the complex text, then gathering and formatting the comments, and finally reshaping the user arrays—you create a highly predictable, easily debuggable architecture that will not fail in production.

Common Errors and Fixes Table

Even with a perfect guide, things can go wrong when dealing with API syntax and JSON parsing. Here are the most common errors we see in our Power Automate workshops, along with the exact fixes you need.

Error Message or Behaviour	Likely Cause	The Fix
Null Notes output despite successful HTTP run	You forgot the $select=Notes query in the URI, or you are accidentally looking at the dynamic content from the standard 'Get item' trigger instead of the HTTP action.	Ensure you are targeting the raw body output of your HTTP action. If the response is wrapped in an array, ensure you use ?['value'] to drill down into the data payload.
JSON parsing fails or returns massive __metadata objects	SharePoint returned verbose XML or heavy JSON payloads because the default header was used.9	Add the exact header: Accept: application/json;odata=nometadata to your HTTP action.9 This forces a clean, lightweight JSON response.
Comments loop runs but creates multiple blank entries	You mapped the wrong array object inside your Apply to Each loop, or the expression syntax is slightly off.	Use exact expressions like items('Apply_to_each')?['text'] to target the comment body.10 Double-check the spelling of the JSON keys against a raw output sample.
Assignees trigger an unwanted Apply to Each loop	You mapped the raw dynamic array from the trigger directly into a single-value field in the Create Item action.	Use the Select action to format the array first, then crucial step: click "Switch to input entire array" in the Create Item action before mapping the Select output.30
HTTP Action returns a 403 Forbidden Error	You are trying to use API v2 (_api/v2.0/sites) without proper Microsoft Graph permissions, or there is a typo in the list name.35	Stick to standard SharePoint REST _api/web/lists endpoints unless you have explicitly configured Azure App credentials.37 Check spacing in list titles; use %20 for spaces if necessary.

FAQ

1. Why is rich text returning a null value in my flows? When the "Append changes to existing text" option is enabled in list settings, SharePoint stops storing the data in the item's base schema. Instead, it stores every update in the item's version history.4 Standard flow actions only read the base schema, resulting in a null value. You must query the version history or the specific endpoint via HTTP.

2. What is the most reliable way to access the comments API? Use the 'Send an HTTP request to SharePoint' action with a standard GET method. Aim your URI at _api/web/lists/getbytitle('ListName')/items(ID)/comments. Always remember to use the odata=nometadata header to simplify the JSON output you receive.10

3. How do I move multi-person fields between lists without causing loops? Do not use loops to map arrays. Intercept the data using a 'Select' data operation. Map the source array to a newly constructed array of Claims objects (i:0#.f|membership|email@domain.com). Then, switch your destination field to accept an entire array and pass the Select output directly into it.30

4. What is the Copilot or AI alternative for parsing this data? If you are dealing with complex HTML tables inside your rich text notes, manual expressions will fail. Look to premium Copilot integrations or third-party connectors like MiniSoup to parse the HTML directly into structured JSON arrays.15 For basic plain text stripping, stick to the free, manual html2text() expression.12

5. How do I test this architecture safely in a 2026 tenant?

Do not build this directly into your production flow. Create a separate dummy list with an appended rich text column and a few test comments. Build the HTTP GET requests in a manual trigger flow. Run the flow and inspect the raw output body in the run history. Once you understand the JSON structure returned, you can confidently build your Parse JSON and Select actions.

Close: Next Steps

If you have been struggling with blank variables, missing comments, and infinite loops when transferring assignees, it is time to upgrade your flow architecture. The transition from relying purely on standard actions to executing SharePoint HTTP requests might seem intimidating initially. However, once you realise it is simply pointing a URL at your data, it unlocks the entire capability of the Power Platform.

We recommend putting these principles into practice immediately, as per our Power Automate workshops. Build this flow today. Test it thoroughly in your tenant. Try moving an item with a deep, complex comment thread and watch it appear perfectly formatted in your archive list.

For flow templates, check the Power Automate Space on Collab365 Spaces.