Microsoft Relaunches memberOf for Entra Dynamic Groups, With New License Requirements

Microsoft killed the memberOf operator for dynamic groups in August 2026. Three months later it's back in preview, with different licensing requirements.

Microsoft Relaunches memberOf for Entra Dynamic Groups — With New License Requirements

Imagine you own a building. “Everyone on the third floor gets a parking pass” is a rule you’d love to automate, but only if the system knows who’s on the third floor. In Entra ID, the memberOf operator was that knowledge: it let the membership of one group automatically drive the membership of another. Put someone in All-Engineering, and they’d fall into Engineering-Software-Access without anyone touching the second group.

In August 2026, Microsoft switched that off. In November 2026, they switched a new version back on, in preview, with licensing expectations that appear to have moved. If you run dynamic groups at any scale, this is a dated sequence worth walking through carefully, because the beat you’re on right now determines whether you should celebrate or wait.

Roughly 2022: the operator that quietly did a lot of work

The original memberOf operator arrived in preview and stayed there for about four years. Preview or not, people built real things on it, because it solved a genuinely annoying problem: dynamic membership rules normally key off attributes on the user, department, country, job title, extension attributes. That’s fine until the thing you actually care about is “is this person in that group,” which isn’t a user attribute at all.

A rule looked like this:

notes.txtText
user.memberOf -any (group.objectId -in ['11111111-1111-1111-1111-111111111111', '22222222-2222-2222-2222-222222222222'])

Read it out loud: a user belongs to this dynamic group if they’re a member of any of the listed groups. Group A’s membership drives group B’s membership. That’s the whole trick, and it let admins build tidy layered access models, a handful of source groups fed by HR attributes, and then access groups stacked on top of them via memberOf. One source of truth, cascading downward. Elegant when it works.

It was never general-availability, and it carried limits the docs were honest about: rules couldn’t nest memberOf against other memberOf-built groups arbitrarily, evaluation wasn’t instant, and it only ever applied to security groups and Microsoft 365 groups. People used it anyway. Four years is long enough that “preview” stops being a warning anyone reads.

August 2026: the floor disappears

Microsoft retired the original operator. Not deprecated-with-a-glide-path, retired. Rules that depended on it stopped evaluating the way they used to, and groups that silently did their job for years started drifting. The failure mode here is the nasty kind: nothing throws a red banner. A dynamic group just quietly stops gaining the right members, and the first you hear of it is a helpdesk ticket from someone who lost access to a SharePoint site, or, worse, someone who kept access they should have lost.

This is the part worth sitting with. Dynamic groups fail silently by design. There’s no “this rule is broken” email. If you built anything on memberOf and didn’t notice in August, go check now, because the gap between “it broke” and “it’s back in preview” is three months where your access model may have been wrong.

Here’s a read-only audit to find rules that reference the operator. It touches nothing, it just lists what you’ve got so you can review it before deciding anything:

audit.ps1PowerShell
# Requires: Microsoft.Graph (Groups + Directory read scopes)
# Read-only. Produces a review list; changes nothing.
Connect-MgGraph -Scopes 'Group.Read.All' -NoWelcome
​
try {
    # Server-side filter for dynamic groups, then page through all results
    $dynamicGroups = Get-MgGroup -All -Filter "groupTypes/any(g:g eq 'DynamicMembership')" `
        -Property 'id,displayName,membershipRule,membershipRuleProcessingState' -ErrorAction Stop
​
    $hits = $dynamicGroups | Where-Object { $_.MembershipRule -match '(?i)memberOf' }
​
    if (-not $hits) {
        Write-Host 'No dynamic rules reference memberOf.' -ForegroundColor Green
    }
    else {
        $hits | Select-Object DisplayName, Id, MembershipRuleProcessingState, MembershipRule |
            Format-List
        Write-Warning ("{0} group(s) reference memberOf. Review each before acting." -f $hits.Count)
    }
}
catch {
    Write-Error "Failed to enumerate dynamic groups: $($_.Exception.Message)"
}
finally {
    Disconnect-MgGraph | Out-Null
}

Export that list, read it, and keep it. It’s your rollback map and your “what was supposed to happen here” reference for everything that follows.

The gap: what people built while the floor was gone

Admins are resourceful, which is a polite way of saying they duct-tape things. The common workarounds for the August outage fell into three buckets:

  • Scheduled PowerShell, a nightly job that reads the source group’s membership and reconciles the target group by hand. Reliable, auditable, and a pain to own.
  • Logic Apps / Power Automate flows, triggered on group membership changes, pushing adds and removes to the target. Lower-code, but now you’ve got business-critical access logic living in a flow nobody documented.
  • Flattening the model entirely, giving up on cascading groups and writing fatter attribute-based rules that don’t need memberOf at all.

If that’s you, the honest advice for November is: don’t rip any of it out yet. A preview operator is not a thing you bet production access on. Run the new operator alongside your workaround, compare the resulting memberships for a few weeks, and only retire the scaffolding once GA lands and the two agree. Your scheduled script is ugly, but it’s a known quantity. Previews change.

November 2026: the operator comes back, with a license footnote

The new memberOf operator is in preview as of November 2026, reported first by Office365ITPros. The headline change isn’t the syntax, it’s the money. The reporting indicates the licensing requirements have shifted from what the original preview expected, and that’s the detail you cannot afford to wave past.

Here’s what’s safe to state plainly. Dynamic membership groups have always required Entra ID P1 per member benefiting from the rule, that’s the baseline floor, and it hasn’t gone anywhere. What’s reported to have changed is the requirement specific to the memberOf operator in this new preview. I’m not going to invent an exact SKU name for you, because the one thing worse than an unverified license requirement is a made-up one. Verify it against the live preview documentation and your own tenant before you plan around it.

How to check what your tenant can actually do, rather than what a blog post says it should:

  1. Go to the Microsoft Entra admin center → Groups → All groups → New group.
  2. Set Membership type to Dynamic User, then open Add dynamic query.
  3. In the rule builder, switch to Edit and try a memberOf rule. If your licensing or preview enrolment doesn’t cover it, the validation step is where you’ll find out, the rule won’t save, and the error tells you why.

The validate-before-save step is your friend here. Use it. A rule that won’t validate is a rule that was never going to work, and it’s far cheaper to learn that in the builder than from an access-review ticket in March.

On syntax: the sensible assumption is that the preview rule format may differ from the four-year-old one above. Don’t copy old memberOf rules out of a runbook and assume they’ll validate unchanged. Build one fresh in the admin center, confirm it evaluates correctly against a test source group, and only then templatise it. The elegant layered model is still available to you, just rebuild it on the new foundation rather than trusting the old blueprints.

The next beat on the calendar

Preview means no committed GA date and no committed GA licensing. Both can move. The thing to watch isn’t a feature announcement, it’s the licensing line on the eventual GA notice, because that’s the number that decides whether your tidy cascading-group design is affordable or whether you’re back to maintaining that scheduled script indefinitely.

So: audit your memberOf rules today, confirm what broke in August, stand the new preview up next to your workaround, and leave the duct tape in place until Microsoft puts a date and a price on it. The floor is back. Just don’t put all your weight on it yet.