SharePoint rich text in Power Automate: values, history and comments

You copy a SharePoint list item in Power Automate. The title arrives. The dates arrive. Then the Notes field is blank, the comment thread is missing, or the Assigned To field creates several archive items instead of one.

The tempting fix is to reach for Send an HTTP request to SharePoint and hope one endpoint returns everything.

It does not.

These are four different data shapes:

What you need	Where it lives	Start with
The current value of a rich-text column	The current list item	Get item or the trigger output
Every entry from an append-enabled column	Retained list-item versions	The Microsoft Graph list-item versions API
Modern list-item comments and replies	A separate comment thread	A carefully tested SharePoint comments request
Several people in one Person column	An array of user objects	Select, followed by one Create item action

That distinction is the fix.

The short answer

• Do not replace Get item just because a column uses rich text. First check whether you need its current value or its history.
• .../items(ID)?$select=Notes requests one item. It does not reconstruct every retained version of Notes.
• If Append changes to existing text is enabled and you need the complete chronology, enumerate item versions and read the fields for each version.
• Modern item comments are not a normal Comments column and are not included in the standard item payload.
• A multi-person column is an array. Reshape the array once, then pass the entire result to the destination field.

Microsoft describes Send an HTTP request to SharePoint as a developer-focused action for SharePoint REST calls that the standard connector does not cover. It also warns that the action can run any SharePoint REST API the connection account can access. Use it deliberately, not as a universal first step. Read Microsoft's guidance.

Before you change the flow

Build a small test case rather than debugging against a busy production list.

Create one item containing:

• an enhanced rich-text column with a heading, link and list;
• an append-enabled Notes column with at least three entries;
• two modern item comments, including one reply;
• a Person or Group column containing two people;
• a unique source key, such as SourceItemId.

You also need to know the column's internal name. Open List settings, select the column, and inspect the Field= value in the page URL. A display name such as Project Notes may have an internal name such as Project_x0020_Notes.

Finally, confirm what the flow's SharePoint connection can read and write. The connection identity needs access to the source item and the destination list. If you use Microsoft Graph for item versions, approve only the permissions required for that route; Microsoft's current Graph documentation lists Sites.Read.All as the least-privileged delegated or application permission for reading list-item versions. See the permissions table.

Case 1: you need the current rich-text value

Enhanced rich text is still a field on the current list item. It is normally returned as HTML.

Start with the standard SharePoint action:

1. Use When an item is created or modified, For a selected item, or another appropriate trigger.
2. Add Get item if the trigger does not expose the field you need.
3. Run the flow once and open the action's raw outputs.
4. Find the internal name of your rich-text field.

If the target is another rich-text SharePoint column, keep the HTML. Stripping it first will discard structure such as links, headings and lists.

If the target needs plain text, use the Microsoft Content Conversion – Html to text action. It is a preview connector, and Microsoft documents deliberate formatting changes: hyperlinks can be rewritten, headings are uppercased, tables are flattened, and lines can wrap after 80 characters. The documented limits are 5 MB of content and a DOM depth of 70. Check the current connector limitations.

Do not use the old html2text(...) expression from this article. That was presented as a native cloud-flow expression without reliable evidence. Html to text is an action in the Content Conversion connector.

Check your work

In the run history, confirm:

• the field output contains the expected HTML;
• a direct rich-text-to-rich-text copy still renders the link and list;
• the plain-text version has acceptable line breaks;
• the output does not contain sensitive markup or embedded data you did not intend to copy.

If Get item returns no usable value and the field has append enabled, stop. You are probably dealing with history rather than an ordinary current field.

Case 2: you need every appended entry

Append changes to existing text relies on item versioning. Microsoft says the option is available for lists when versioning is enabled. It also warns that turning append off later removes all but the most recent entry, so do not use that switch as a troubleshooting experiment on production data. Check Microsoft's column guidance.

A normal item request cannot give you a trustworthy, complete chronology by simply selecting the Notes field.

Microsoft Graph has a documented list-item versions API:

GET https://graph.microsoft.com/v1.0/sites/{site-id}/lists/{list-id}/items/{item-id}/versions

Microsoft notes that retained versions can be limited by administrative settings. Your flow can only retrieve the versions that still exist. Read the list-item versions documentation.

For each returned version, request its field values:

GET https://graph.microsoft.com/v1.0/sites/{site-id}/lists/{list-id}/items/{item-id}/versions/{version-id}?$expand=fields

The returned version resource can include its ID, modification time, modifier and a fields relationship containing the values for that version. See Microsoft's version-resource example.

Build the history flow

1. Obtain the SharePoint site ID and list ID once and store them in environment variables or configuration. Do not discover them on every item run unless the flow genuinely works across many sites.
2. Use an approved Microsoft Graph connection to list the item's versions.
3. Add Apply to each over the returned value array.
4. Inside the loop, get that version with $expand=fields.
5. Capture these values into an array:
   • version ID;
   • lastModifiedDateTime;
   • the display name from lastModifiedBy, when present;
   • fields.<your-internal-column-name>.
6. Remove empty Notes values for a readable history.
7. Sort the presentation copy into the order your archive needs. Do not assume the API response order without checking it.

The Send an HTTP request to SharePoint action is not the Graph action. Microsoft explicitly says it supports SharePoint REST APIs; calls to another Microsoft service require an appropriate Microsoft Entra ID HTTP connection. See the scope note.

Repeated values are not necessarily repeated notes

An item version can be created because another column changed. That version may contain the same Notes value as the previous version.

Choose one of two outputs:

• Audit copy: keep every retained version and its metadata.
• Readable chronology: remove consecutive exact repeats from the presentation copy while retaining the audit copy elsewhere.

Do not silently deduplicate records if the output is intended for legal, regulatory or evidential use. Agree the records requirement first.

Check your work

Compare the flow output with Version history in SharePoint for the same test item.

Verify that:

• the earliest retained version appears;
• the latest appended entry appears;
• the author and time are taken from the version, not the flow runner;
• unrelated field edits do not create misleading duplicate notes in the readable copy;
• the result is explicit when old versions have already been trimmed.

Case 3: you need modern list-item comments

Modern comments are separate from a multiple-lines-of-text column. Get item does not turn that thread into a field.

There is also an important support boundary: the Microsoft Graph list-item documentation currently covers fields and versions, but does not document a general list-item comments endpoint. The Microsoft 365 Patterns and Practices (PnP) libraries expose item comments through SharePoint APIs, but their documentation labels those APIs beta, subject to change, and potentially unavailable in some tenants. Read the PnP comments warning.

For a non-critical automation, you can test this SharePoint request in Send an HTTP request to SharePoint:

GET _api/web/lists/getbytitle('ToDo Plus')/items(42)/comments
Accept: application/json; odata=nometadata

Replace the list title and item ID. Give the action a clear name such as Get_item_comments.

Then:

1. Run it against the test item.
2. Inspect the raw body before adding Parse JSON.
3. Generate the schema from that tenant's successful sample.
4. Confirm whether the top-level collection is in value.
5. Confirm the actual keys for text, author, creation time and replies.
6. Build the loop from those observed keys.

Microsoft's SharePoint HTTP guidance explains that GET responses can be objects or arrays and shows body('Action')['value'] for an array response. That is a parsing pattern, not proof that every comments response has the same shape. See the parsing guidance.

What a copied comment log loses

Turning a comment thread into one text field creates a snapshot. It does not recreate:

• threaded replies unless you explicitly retrieve them;
• live @mentions and their notification behaviour;
• likes or reactions;
• moderation and edit behaviour;
• the original native comment experience.

If the source item is a record, preserving it is safer than assuming a text copy is equivalent. Treat the comments request as tenant-tested automation, not as a guaranteed records export API.

Check your work

Use an item with a parent comment and reply. Confirm the archive contains both—or explicitly states that replies were not captured.

Also test:

• an item with no comments;
• a deleted or unavailable author;
• an @mention;
• more comments than your first sample;
• a connection account with ordinary, not site-owner, permissions.

Case 4: you need to copy a multi-person field

A Person or Group column that permits several people is an array of user objects. If you insert one Create item inside an automatically generated Apply to each, you will create one destination item per person.

Instead, reshape the array before creating the destination item. Microsoft documents the Select data operation as the action for adding, removing or renaming properties in every object in an array without changing the number of objects. See the Select action.

Build the people array

1. Add Data Operation – Select before Create item.
2. Set From to the complete source multi-person array.
3. Map a property named Claims.
4. If the source objects contain a Claims value, use:

item()?['Claims']

5. If the source only exposes an email address, a common SharePoint Online claims shape is:

concat('i:0#.f|membership|', toLower(item()?['Email']))

6. Configure the destination Person column to allow multiple selections.
7. In Create item, switch that field to accept the complete array and pass:

body('Select_assignees')

The exact user object exposed by the SharePoint connector can vary with the action and column. Inspect the source array before choosing Claims, Email, or another property. Do not paste an expression whose property does not exist in your run.

Users must also be resolvable in the destination. A claims value from another tenant, a deleted account or a guest who is not recognised by the target site can fail even when the array is valid.

Check your work

The Select output should resemble:

[
  { "Claims": "i:0#.f|membership|alex@contoso.com" },
  { "Claims": "i:0#.f|membership|priya@contoso.com" }
]

Confirm that one source item creates one destination item and that the destination contains the same number of people.

A safer archive flow

Do not end the first successful test with Delete item.

Use this sequence:

1. Trigger when an item reaches the archive state.
2. Read the current item.
3. Check the destination for the unique source key.
4. If it already exists, update or stop instead of creating a duplicate.
5. Build the current rich-text value.
6. Build appended history only if the archive requires it.
7. Capture the comments snapshot only if its support boundary is acceptable.
8. Reshape the people array.
9. Create the destination item.
10. Read the destination item back and compare the required fields.
11. Mark the source as archived.
12. Delete the source only when the business has an approved recovery and retention policy.

This makes retries much safer. A failed run can restart without quietly producing another archive item.

Common mistakes

Symptom	Likely cause	What to check
Current Notes value is blank	The field is append-enabled, missing from the selected view, or addressed by the wrong name	Inspect raw output and confirm the internal name
Only one appended entry appears	You read the current item rather than its retained versions	Enumerate versions, then expand fields for each version
Notes repeat after unrelated edits	Several item versions contain the same Notes value	Keep an audit copy; remove consecutive repeats only from the readable copy
Comments action returns 404 or a different shape	The beta SharePoint surface differs in the tenant or URI is wrong	Re-test manually and regenerate the schema; do not claim universal support
Replies are missing	Only top-level comments were retrieved	Test reply expansion or preserve the source thread
One archive item is created per assignee	Create item sits inside a person loop	Use Select, then create one item with the complete array
SharePoint HTTP returns 403	The connection identity lacks access or the request exceeds its permissions	Confirm the action's connection and test the smallest read request

FAQs

Does Get item return all entries from an append-enabled text column?

Do not assume it does. Get item reads the current item. If you need a trustworthy chronology, enumerate the retained item versions and read the field values for each version.

Can Send an HTTP request to SharePoint call Microsoft Graph?

No. Microsoft says the action supports SharePoint REST APIs. Use an approved Microsoft Entra ID HTTP connection or another governed Graph integration for graph.microsoft.com.

Is the SharePoint list-item comments endpoint fully supported?

Treat it cautiously. PnP documents item-comment APIs but labels the comments surface beta, subject to change and potentially inconsistent across tenants. Test it in the target tenant and do not make it the only copy of a business record.

Is html2text() a Power Automate cloud-flow expression?

The evidence-safe option is Microsoft's Content Conversion – Html to text action. It is a preview connector with documented formatting changes and limits. The previous version of this article presented html2text() as a native expression without adequate proof.

How do I stop a multi-person field creating duplicate list items?

Keep Create item outside the person loop. Use Select to reshape the source people array, then pass the entire output to a destination Person column that permits multiple selections.

Keep the evidence boundary visible

The current-value, version-history and array-shaping routes above are grounded in Microsoft's connector, Graph and data-operation documentation.

The modern comments route is different: it is a useful SharePoint Online pattern exposed by PnP, but it carries a beta support boundary. Test it against your tenant, your permissions, real replies and your retention requirements before relying on it.

If Power Automate and SharePoint are part of your daily workload, join Power Automate Builders for practical, human-audited guidance on flows that need to survive real data.