Content created with the assistance of AI.
Back in September I wrote about SharePoint news cross-posting to Viva Engage from a communicator's point of view. One of the things I liked most was that comments, replies, and reactions stay in sync between SharePoint and Engage. It looks seamless in the UI. But as someone who spends a lot of time extending SharePoint, I kept asking myself one question: what do the APIs actually return once a post is cross-posted?
So I took it for a spin on my demo tenant. Short answer: the SharePoint API and the page UI stop telling the same story the moment you cross-post. If you build web parts, dashboards, or reports that show likes and comments on news posts, this one is for you.
How did I test it?
I published a new news post in SharePoint and gave it a like and a comment. Then I cross-posted it to a Viva Engage community called AI. After that, I added likes and comments both in Engage and on the SharePoint page, through the synchronized engagement experience I described in my previous post, plus one extra comment through the SharePoint REST API. After each step, I compared what the UI showed with what the APIs returned.
What does the UI show after cross-posting?
The UI behaves exactly as Microsoft describes it. As soon as the post was cross-posted, the SharePoint comments section on the page was replaced by a Discussion in AI community module, which is the Engage conversation rendered inside SharePoint.
A few things I noticed:
- The existing like and comment were gone. Both the page and the Engage post said "Be the first to like this." This matches the Microsoft documentation: existing SharePoint comments and reactions don't transfer.
- The sync works both ways. My comment from the SharePoint page showed up in Engage, my comment from Engage showed up on the page, and the like I put on a comment appeared in both places.
- The new comment I added through the SharePoint REST API never appeared. Not on the page, not in Engage.
One thing to keep in mind: for users without Viva Engage access, the discussion module just says "This page isn't loading right now." There's no fallback to the classic SharePoint comments, so users without Engage can't see or join the conversation on the page at all.
What does the SharePoint REST API return?
This is the part where it gets interesting. The SharePoint REST API keeps reading from SharePoint's own social data, and that data is frozen at the moment of the cross-post. Nothing from the Engage conversation flows back into it.
These are the endpoints I checked:
GET /_api/web/lists('{sitePagesId}')/GetItemById(5)/likedByInformation?$expand=likedBy
GET /_api/web/lists('{sitePagesId}')/GetItemById(5)/Comments()
GET /_api/web/lists('{sitePagesId}')/GetItemById(5)/FieldValuesAsText?$select=_LikeCount,_CommentCount
POST /_api/web/lists('{sitePagesId}')/RenderListDataAsStream (ViewFields: _LikeCount, _CommentCount)
After the whole test, they all still returned 1 like (my like from before the cross-post) and 2 comments (the one from before the cross-post and the one I added through REST). My new reactions via the synchronized engagement experience were nowhere to be found.
The API still accepts writes
After the cross-post, a POST to Comments() still returned 201 Created, and _CommentCount went from 1 to 2. So you can keep writing likes and comments to a cross-posted page through the SharePoint API, and they get counted, but the page UI will never show them. I think we can call these orphaned comments.
Can I get the real numbers from Engage?
Yes. Microsoft Graph doesn't help here yet: the Viva Engage APIs in Graph cover communities and roles, not posts or reactions. But the good old, legacy Yammer REST API (https://api.yammer.com/api/v1) still works against Viva Engage, and it returns exactly what the UI shows.
I used a small PowerShell script with Invoke-RestMethod. These are the calls that matter:
GET https://api.yammer.com/api/v1/messages/{threadId}.json # the thread starter, incl. liked_by
GET https://api.yammer.com/api/v1/messages/in_thread/{threadId}.json # starter + all replies, each with liked_by
GET https://api.yammer.com/api/v1/threads/{threadId}.json # thread stats
For my test post, in_thread returned 1 like on the post and 2 comments ("Comment from the SharePoint page" with 1 like, and "Comment from Engage"). The threads endpoint reported updates: 3, which is the thread starter plus the two replies, so subtract one if you use it as a comment count.
One very important thing to know: SharePoint stores the link to the thread. The page's list item in Site Pages has a read-only ContentDistributionMetadata field. After a cross-post, it holds an engage object with rawThreadId (the number the Engage API needs), the Base64 threadId and threadStarterId, the community (destinationId), isPrivate, and distributedDate. A request to GetItemById(5)?$select=ContentDistributionMetadata returns it, so you can go from a news post to its real Engage numbers without opening Engage. It's a Note field, so you can't use it in $filter, and I couldn't find it documented anywhere, so treat its shape as something that may change.
Side by side: UI vs. API
Here's where things stood at the end of the test.
| Where you look | Likes | Comments | Whose interactions |
|---|---|---|---|
| SharePoint page UI (Engage module) | 1 | 2 | All made after the cross-post |
| Viva Engage post UI | 1 | 2 | All made after the cross-post |
Viva Engage REST API (messages/in_thread) |
1 | 2 | All made after the cross-post |
SharePoint REST (likedByInformation, Comments()) |
1 | 2 | Interactions made before the cross-post or written through REST |
Yes, the numbers match. That's a coincidence of my test, and it's exactly what makes this tricky: they count completely different people and interactions. On a real news post with dozens of reactions in Engage, the SharePoint API would happily keep reporting whatever was there before the cross-post, which might be nothing for a net-new post.
The interactions SharePoint kept from before the cross-post, and anything written through REST afterward, aren't visible to anyone. So in my view, the SharePoint API should return what the page actually shows. Existing solutions could keep calling the same endpoints and would simply get the right numbers.
What does this mean for developers?
If you extend SharePoint news, here's what I'd take away from this:
- Custom news rollups will show stale counts. Any web part, Adaptive Card Extension, or search-driven rollup that shows likes and comments from
_LikeCountand_CommentCountwill show pre-cross-post numbers for cross-posted posts, usually zero, and this will be misleading. - Reports and analytics jobs are affected too. If you export engagement for news posts through the SharePoint REST API, cross-posted posts will look like they get no engagement at all. Microsoft's built-in page analytics do include the Engage numbers, so use those for reporting where you can.
- Don't write comments through the SharePoint API to cross-posted pages. They will be stored and counted, but nobody will ever see them. If you have automations that post comments or add likes to news pages, check
ContentDistributionMetadatafirst to see whether the page is cross-posted. - The real numbers live in Engage. For a cross-posted post, the conversation is the Engage thread. Getting likes and comments from there means going through the old, legacy Yammer REST API 😐
Closing thoughts
From an end-user point of view, cross-posting does what it promises: one conversation, visible in both SharePoint and Engage. From a developer point of view, the page item knows which Engage thread holds the conversation, but its social data doesn't follow it. The SharePoint REST API keeps returning the old SharePoint social data and keeps accepting new data that no one will see.
I'd love to see Microsoft do two things on the page item: document ContentDistributionMetadata, so we can build on it with confidence, and make the like and comment counts reflect the synced conversation. Until then, if your solution shows or reports on news engagement, treat cross-posted posts as a special case that requires extra API calls to retrieve the social data.
On the Engage side, I hope Microsoft extends the Microsoft Graph APIs for Viva Engage to cover the everyday scenarios, like reading posts, comments, and reactions. Today, Microsoft Graph handles things like communities and roles, but for anything conversation-related we still have to fall back on the old, legacy Yammer REST API. Having it all in Microsoft Graph would make solutions like this much easier to build and maintain.
Thanks for reading,
Jarbas
