IntuneAtlas
Docs

Getting started

Install the CLI, register an Entra app for it to sign in with, and get a searchable, conflict-checked settings index for one tenant — on your own machine, or hosted on Azure for a team.

Install

Both installers download a standalone binary — no Node.js required.

Windows
$ irm https://intuneatlas.com/install.ps1 | iex
Linux
$ curl -fsSL https://intuneatlas.com/install.sh | bash

Either one puts intuneatlas on your PATH. See the CLI reference for every command it adds.

Register an Entra app

IntuneAtlas doesn't ship with a bundled app registration — every install signs in with an app you register yourself, in your own tenant. It only takes a few minutes, and you only do it once.

  1. Go to portal.azure.com → Microsoft Entra ID → App registrations → New registration. Give it any name (e.g. "IntuneAtlas"); the default "Accounts in this organizational directory only" is fine unless you specifically need multi-tenant.
  2. Once created, copy the Application (client) ID from the overview page — that's what goes in --client-id below.
  3. Authentication → Add a platform → Mobile and desktop applications.
  4. Add a Custom redirect URI (not one of the predefined options):
    http://localhost:7878/auth/callback
    Use localhost, not 127.0.0.1.
  5. Add a second Custom redirect URI, same platform, no port or path:
    http://localhost
    Used by intuneatlas login/scan. Skip it if you only use --device-code.
  6. API permissions → Add a permission → Microsoft Graph → Delegated permissions → add these two, both read-only: DeviceManagementConfiguration.Read.All and DeviceManagementServiceConfig.Read.All. User.Read, which a new registration already has, covers the rest. If you're a Global or Intune admin, click Grant admin consent now — otherwise the first sign-in will prompt for it instead.
    Optionally also add Group.ReadBasic.All. IntuneAtlas uses it only to read the names of the groups your policies are assigned to and which groups contain other groups, so it can show settings per group by name. Everything works without it: groups are then shown by their ID, and a policy assigned to a parent group isn't counted for the groups inside it.
    One more is optional: DeviceManagementScripts.Read.All, used only to show a custom compliance script by its name. Without it the script's rules still show.
    Only if you want to push changes to Intune from the app, also add DeviceManagementConfiguration.ReadWrite.All (delegated) and grant admin consent for it. It is the one permission that lets the app write. Sign-in never asks for it; it is used only at the moment an Admin pushes a reviewed change (see Pushing a change). Leave it out and the app cannot change anything in your tenant.
  7. App roles → Create app role, three times, one for each of: viewer (browse only), contributor (+ notes, staging and managing your own changes), and admin (+ triggering scans, managing and reviewing everyone's changes, their own included, adding and removing baselines, pushing changes to Intune). For each: Allowed member types → Users/Groups, Value exactly the lowercase name above.
  8. Microsoft Entra ID → Enterprise applications → your app → Users and groups → Add user/group, and assign yourself (and anyone else who'll use it) to one of the three roles. Required — skip it and you'll get a "no role assigned" screen with nothing to do.
  9. Same app → Properties → Assignment required? → Yes.

Sign in and run your first scan

  1. Run:
    $ intuneatlas ui --tenant contoso.onmicrosoft.com
    No client ID registered yet on this machine? You'll be prompted for the Application (client) ID from the app you just created — paste it in once and it's saved (~/.intuneatlas) for every future command, on any tenant. Prefer to skip the prompt entirely, or set it up non-interactively? Pass --client-id <application-id> instead — same effect, and it also works as the way to change the saved one later.
  2. A browser window opens to a normal Microsoft sign-in screen. Sign in with your own account — this is the same account and permissions used for every scan and change review from here on.
  3. The web UI opens at http://localhost:7878. The first time there is nothing to show yet: click Scan now (it needs the Admin role) and wait for the scan to finish. After that the UI opens on the last scan, and Sync now in the sidebar runs a new one. Reopening ui later reuses the cached sign-in on Windows and macOS; on Linux it prompts again each time.
Scripts and CI. The prompt only ever appears in a real interactive terminal — piped or non-interactive stdin skips it and fails fast instead of hanging. Always pass --client-id explicitly there, or set INTUNEATLAS_CLIENT_ID (a per-run override, not saved to disk).

What you get

The web UI turns the tenant's policies into one list of settings. A setting that several policies configure appears once, with every policy that sets it and each one's value.

  • Settings — everything Settings Catalog policies configure, on any platform, grouped by category. Each setting is in one of six states: Conflict, Below baseline, Missing, Not assigned, Meets baseline or Not checked. Rows of custom OMA-URI profiles are settings too, one per row, by their OMA-URI. Intune encrypts their text and certificate values, so those show by file name or as encrypted, and they can't be edited in the app.
  • Compliance — the same for compliance policies: Windows, iOS, macOS, Android and Linux, the actions for noncompliance, and the tenant-wide compliance settings. Compliance policies never conflict; where two ask for different values, the stricter one applies.
  • Enrollment — enrollment configurations by name, with whether each one is assigned.
  • Baselines — the baselines you've added, and which of them are active for you.
  • Change log — changes you've staged, each needing a reason and a reviewer, and from where an Admin can push them to Intune.

Open a setting to see each policy that sets it, who that policy is assigned to, and what the active baselines expect. A value can be edited there with the same options and ranges Intune offers, including lists and sub-settings, and staged for review — in the policy that holds it, or in a new policy you name. Notes and reminders can be attached to any setting: a reminder comes due on a date, once or every few months, such as renewing a code-signing certificate, and is shared with everyone using the app. The bell beside the sidebar's collapse button shows what's due. A setting's History lists what each scan has seen change: a policy starting or no longer setting it, a changed value, an assignment gained or lost — including changes made directly in the Intune portal.

The app follows your system's light or dark appearance; the account menu lets you choose one instead.

Everything up to here is read-only: scanning reads the tenant, and staging a change records it in the app, not in Intune. The one thing that writes is pushing a change, and only if you gave the app the permission for it.

Sharing it with a team

On your own machine IntuneAtlas is yours alone. Shared, everyone who connects signs in with their own Microsoft account, and what they can do follows the App Role you assigned them (above): Viewers can browse, Contributors can also add notes and manage their own staged changes, and only Admins can trigger a new scan, manage and review anyone's changes, add and remove baselines, or push a change to Intune. Reviews, notes and history are then the team's, not one person's.

There are two ways to share it. Hosting it on Azure is the simpler one.

Hosting it on Azure

The recommended way to run IntuneAtlas for a team: one template deploys it as an Azure Container App in your own subscription. It gets its own HTTPS address, so there is no server, reverse proxy or certificate to look after, and its data is kept on a file share.

  1. Register the Entra app as above. You need its Application (client) ID.
  2. Deploy to Azure opens the Azure portal with the template loaded. Pick a resource group and paste the client ID.
  3. When it finishes, open the deployment's Outputs, copy redirectUri, and add it to the app registration as another Custom redirect URI under Mobile and desktop applications.
  4. Open url from the same outputs, sign in, and click Scan now.

The template creates a container app limited to one instance, a storage account for the data, and a log workspace. What it costs, its parameters and how to update or remove it are in infra/azure. Which version an instance is running shows in the account menu at the bottom of the sidebar.

Hosting it on your own server

intuneatlas ui --host 0.0.0.0 turns the same server you run locally into a shared instance, on any machine your team can reach.

It needs a real HTTPS hostname reachable by your teammates' browsers — a plain LAN IP over HTTP won't work. A reverse proxy with a certificate (Caddy is the simplest option) or any host that terminates TLS both work. Then add https://<hostname>/auth/callback as another Custom redirect URI on your app's Authentication page, alongside the localhost one.

--persist registers that exact command to keep running across reboots — a Scheduled Task on Windows, a systemd service on Linux. See the CLI reference for the full flag list. The same app is also published as a container image, ghcr.io/jgeselle/intuneatlas, which keeps its data under /data.

Looking at one group

Under each page's title is a chooser that reads All policies. Pick a group there and every page shows only what reaches that group: policies assigned to it, to a group that contains it, or to everyone. Conflicts, baseline results and missing settings are worked out again for just that group, and the choice is remembered.

Two policies that set the same setting differently only conflict if they can reach the same group. Different values for different groups, such as update rings, are not a conflict.

This is what is aimed at a group, not what one device ends up with: a device can be in several groups. Group names and nesting need the optional Group.ReadBasic.All permission (above); without it groups are listed by ID.

Pushing a change

A staged change can be written to Intune from the Change log. It needs three things: the optional write permission on the app registration (above), a reason and an Admin's review on the change, and the Admin role.

  • A change to an existing policy gets a Push to tenant button once it is ready. The app asks once more, naming the value and the policy, then writes that one setting. Everything else in the policy, and who it is assigned to, stays as it is.
  • Taking a setting out of a policy is staged from the setting's panel with Remove from this policy on that policy's card, and pushed like any change. A policy is never left empty: its last setting can't be removed.
  • Settings staged into a new policy are created together, as that policy, with Create policy in tenant — once every one of them is ready. The new policy is not assigned to anyone; assigning it is done in Intune.

Just before writing, the app reads the current value from Intune. If it is no longer what it was when the change was staged, someone changed it in the meantime and the push is refused: sync, look again, and stage it again.

A pushed change is recorded in the setting's History with who pushed it, who staged and reviewed it, and the reason, and leaves the change log. The next scan confirms it.

What can be pushed. Settings Catalog policies, including those created from a template (endpoint security policies, security baselines), compliance policies (Linux included) with their actions for noncompliance and custom compliance rules, the tenant-wide compliance settings, and the few legacy Device Restrictions switches the app reads. A custom compliance rule can be changed or removed here; a new rule is added in Intune, where its messages for users are written.

Adding a baseline

Nothing is judged until you add a baseline. A baseline is a folder of policies exported from Intune as JSON, Settings Catalog policies and compliance policies alike — for example a release of the Open Intune Baseline, or policies you exported from a reference tenant.

  1. Download or export the baseline and unpack it to a folder.
  2. In the web UI, open Baselines and choose that folder. Files that aren't Settings Catalog or compliance policies are ignored.
  3. Give it a source (oib) and a name and version (windows-v4.0), then add it. Adding needs the Admin role.
  4. Sync the tenant once, so settings the baseline expects but your tenant lacks get their names.

Baselines live in ~/.intuneatlas/baselines/<source>/<name-and-version>/ and survive updates. You can also copy a folder there yourself. Each signed-in user chooses which baselines are active for them.

A baseline is a floor: a setting meets it when everything the baseline specifies is there, and anything your tenant configures beyond that is fine. A setting the baseline expects that no policy configures shows as Missing.

An optional baseline.yml in the baseline's folder adds what an export can't say, per setting: severity, rationale, a reference, a looser comparison, or leaving a setting out.

name: Contoso baseline – Windows 2026.1
settings:
  device_vendor_msft_policy_config_update_deferqualityupdatesperiodindays:
    compare: atMost        # exact (default), atMost, atLeast
    severity: high         # critical, high, medium, low
    rationale: Security patches should not wait longer than a week.
    reference: CIS Windows 11 Benchmark 5.0.0, 87.1
  device_vendor_msft_policy_config_experience_allowcortana:
    ignore: true

From the terminal

The web UI isn't the only way in. A scan is stored on the machine that ran it, and two commands work on it without opening a browser or asking anything more of the tenant:

  • intuneatlas search finds settings by name, path, policy or value, and shows who sets them, for whom, and to what.
  • intuneatlas check holds the scan — or one group in it — against a baseline and lists what needs attention. The baseline can be a folder or a URL, such as a folder of the Open Intune Baseline on GitHub.
$ intuneatlas scan --tenant contoso.onmicrosoft.com
$ intuneatlas search bitlocker
$ intuneatlas check --group "Pilot ring" --baseline https://github.com/SkipToTheEndpoint/OpenIntuneBaseline/tree/main/WINDOWS

check exits with 1 when something is below baseline, in conflict or missing, so it can gate a scheduled job; check --scan does the scan and the check in one command. See the CLI reference.

Keeping access to a minimum

IntuneAtlas is a way into Intune, and Intune can reach every managed device, including the ones your most privileged admins use. Treat it with the same care as Intune itself.

  • Everyone sees only what their Intune role shows them. On a shared instance, a scan is made with the rights of whoever ran it, but each person who signs in sees only the policies their own Intune role and scope tags let them see. IntuneAtlas asks Intune with their own sign-in, so scope tags, and Intune's newer scoped permissions, apply as they do in the Intune admin center. On your own machine there's only you, and nothing is narrowed.
  • A push is made with the pusher's own rights. Intune checks their role and scope tags on every write, whatever IntuneAtlas allows.
  • Give the Admin role only to Intune admins. It can push changes, so assign it through a group, ideally with Privileged Identity Management, and cover the app with a Conditional Access policy that asks for phishing-resistant MFA and a compliant device.
  • Automation gets its own app registration. --client-secret signs in as the app, not a person, and an app's permissions apply to the whole tenant: no Intune role or scope tag limits them. Give that registration read permissions only (DeviceManagementConfiguration.Read.All, DeviceManagementServiceConfig.Read.All, and optionally Group.ReadBasic.All and Organization.Read.All for the tenant's name), never the write permission, and keep its secret in a secret store.
  • The hosting is part of it. Whoever can change the Container App, its image or its settings can change what runs while Admins sign in, and the file share holds the scans, notes and reviews. Give access to that resource group to the same people as Intune administration, and pin the image to a version (for example ghcr.io/jgeselle/intuneatlas:0.0.54) rather than latest.

Next