Purview Auto-Labeling Finally Reads .DOC Files. I Tested It for a Week.

For years, every sensitivity label policy ignored legacy .doc and .xls files because the engine couldn't read them. That just changed, and your existing policies now apply to files they never touched before.

Purview Auto-Labeling Finally Reads .DOC Files. I Tested It for a Week.

There is a folder on every tenant I’ve ever audited. You know the one. Archive 2009 - DO NOT DELETE, forty thousand files, last modified by someone who left in 2014, and roughly a third of them are .doc and .xls. For years that folder sat outside every sensitivity label policy I wrote, because the auto-labeling engine politely pretended the files didn’t exist. Modern formats and PDFs got scanned. The legacy binary blobs got shrugged at.

That shrug just stopped. Here’s the timeline, and what each beat actually means once it hits your tenant.

For about eight years: if it wasn’t a DOCX, it was invisible

Server-side auto-labeling, the kind that runs inside SharePoint Online, OneDrive, and Exchange without a human opening anything, only understood the Open XML formats. .docx, .xlsx, .pptx, plus PDF. If a file was saved in the old Office 97–2003 binary format (.doc, .xls, .ppt), the engine walked past it.

This mattered more than vendors admitted, because of where those files live. Client-side labeling needs a user to open the document in a current Office app with the Information Protection client doing the work. Nobody opens a 2008 budget workbook. It just sits in a document library accumulating risk. Server-side scanning was the only mechanism that would ever look at it, and that was exactly the mechanism that couldn’t read the format. The files most likely to contain unlabeled sensitive data were the files structurally guaranteed to stay unlabeled.

This month: the engine learned to read the old formats

Microsoft updated Purview Information Protection’s server-side auto-labeling to parse the legacy binary formats, .doc, .xls, .ppt. It’s rolling out now. There’s no new checkbox labelled “legacy formats.” If you already run auto-labeling policies against SharePoint, OneDrive, or Exchange, the engine simply starts evaluating file types it used to skip. That’s the quiet part: your existing policy conditions now apply to a population of documents they never touched before.

Which is the good news and the 2 a.m. news at the same time. More on that below.

Where it lives, so you can go look

Go to the Purview portal at purview.microsoft.com → Information Protection → Auto-labeling policies. Your scope lives under the policy’s locations: SharePoint sites, OneDrive accounts, Exchange. The conditions, sensitive info types, trainable classifiers, keywords, are unchanged. You don’t re-author anything.

The one thing you should do before trusting it: run the policy in simulation mode first, then open Content Explorer (Data Classification → Content Explorer) and filter by file type. Simulation shows you what would get labelled without pulling the trigger. On a tenant with a big legacy backlog, that preview is the difference between a controlled rollout and a Monday morning full of “why is this 2007 spreadsheet suddenly marked Confidential” tickets.

Licensing, because someone always asks mid-project

Server-side auto-labeling for SharePoint, OneDrive, and Exchange is an E5-tier capability. That means Microsoft 365 E5, Office 365 E5, the Microsoft 365 E5 Compliance suite, or the standalone E5 Information Protection & Governance add-on. Client-side auto-labeling comes in at lower tiers, but the feature we’re talking about here, the one that scans files nobody opens, is firmly E5. No E5, no legacy-file scanning. The engine update doesn’t change that.

Day one of my trial: the backlog finally moved

I switched one policy from simulation to enforce against a single archive-heavy site collection, roughly 200,000 items, a big slug of them legacy Office. Over the week, the .doc and .xls files that matched our financial-data classifiers started picking up labels on their own. No user action, no client, no Office app. For content that had been dark for a decade, watching it classify itself was genuinely satisfying.

Day four: the skip list is real, and it’s longer than the marketing

Plenty of files didn’t get labelled, and not because the policy missed them. The engine still walks past:

  • Password-protected and encrypted files. If the service can’t open it, it can’t read it. No surprise, but worth telling your records team before they expect 100% coverage.
  • Files above the service size ceiling. There’s a maximum file size for scanning, confirm the current figure in Microsoft’s docs rather than guessing, because it’s bitten people who assumed “big archive” meant “every file.” Oversized items are skipped silently.
  • Corrupted or malformed binaries. Twenty-year-old files have twenty-year-old damage. A chunk of mine were unreadable, and that’s just physics.
  • Documents leaning on legacy-only features. Heavy macro payloads, embedded OLE objects, exotic old encodings, these are where parsing gets unreliable. Treat “unlabelled legacy file” as “needs a human look,” not “safe.”

None of this makes the feature less useful. It makes it honest. It closes the biggest part of the gap, not all of it.

Before you enforce anything: size the exposure

Don’t flip policies based on vibes. Count the legacy files first so you know what you’re pointing the engine at. This reads a reviewed CSV of target sites, never a live bulk query against every site you own, enumerates their drives, and tallies files by legacy extension. It’s read-only; it changes nothing.

audit.ps1PowerShell
# Requires: Microsoft.Graph module
# Read-only audit. Feed it a reviewed CSV: column "SiteId" (Graph site IDs you've vetted).
Connect-MgGraph -Scopes "Sites.Read.All","Files.Read.All" -NoWelcome
​
$targets = Import-Csv -Path ".\reviewed-sites.csv"
$legacyExt = @('.doc','.xls','.ppt')   # binary formats only, not the modern x variants
$results = [System.Collections.Generic.List[object]]::new()
​
function Get-LegacyFileCount {
    param($DriveId)
    $count = 0
    $stack = [System.Collections.Generic.Stack[string]]::new()
    $stack.Push("root")
    while ($stack.Count -gt 0) {
        $itemId = $stack.Pop()
        try {
            # -All handles @odata.nextLink pagination for you
            $children = Get-MgDriveItemChild -DriveId $DriveId -DriveItemId $itemId -All -ErrorAction Stop
        } catch {
            Write-Warning "Drive $DriveId / item $itemId : $($_.Exception.Message)"
            continue
        }
        foreach ($c in $children) {
            if ($c.Folder) { $stack.Push($c.Id); continue }
            $ext = [System.IO.Path]::GetExtension($c.Name).ToLower()
            if ($legacyExt -contains $ext) { $count++ }
        }
    }
    return $count
}
​
foreach ($t in $targets) {
    try {
        $drives = Get-MgSiteDrive -SiteId $t.SiteId -All -ErrorAction Stop
    } catch {
        Write-Warning "Site $($t.SiteId): $($_.Exception.Message)"
        continue
    }
    foreach ($d in $drives) {
        $n = Get-LegacyFileCount -DriveId $d.Id
        $results.Add([pscustomobject]@{
            SiteId      = $t.SiteId
            DriveName   = $d.Name
            LegacyFiles = $n
        })
    }
}
​
$results | Sort-Object LegacyFiles -Descending | Format-Table -AutoSize
$results | Export-Csv ".\legacy-file-audit.csv" -NoTypeInformation

One caveat the Graph API forces on you: drive items don’t cleanly expose current sensitivity-label state, so this counts the legacy-format population, your exposure surface, not the already-labelled subset. Cross-reference the output against Content Explorer to see what the engine has actually classified. The count is your denominator; Purview tells you the numerator.

Next on the calendar: your simulation window

The feature is live now, which means your real deadline isn’t Microsoft’s, it’s the day one of your existing policies, running in enforce mode, reaches across a legacy backlog you never pressure-tested. Put every auto-labeling policy that targets SharePoint or OneDrive back into simulation this week, watch what the old formats pull in, and tune the conditions before you let it write labels at scale. The engine finally reads the files. Whether it labels them the way you’d want is still your problem to verify, just now there’s actually something to verify.