# Microsoft 365 Roadmap Monitor - New & Changed Features (`snappytools/m365-roadmap-monitor`) Actor

Track what changed on the Microsoft 365 Roadmap since your last run: new features, status changes, moved release dates and removals. Filter by product, cloud and platform. Ready for Slack, Teams or email.

- **URL**: https://apify.com/snappytools/m365-roadmap-monitor.md
- **Developed by:** [Snappy](https://apify.com/snappytools) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 change delivereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Microsoft 365 Roadmap Monitor – New & Changed Features

Find out what changed on the Microsoft 365 Roadmap since you last looked. Each run compares Microsoft's public roadmap with the previous run and returns only the differences: new features, status changes (In development → Rolling out → Launched, or Cancelled), rollout dates that moved, edited descriptions, and items that disappeared. Every change comes with its before and after values.

Filter by product (Teams, SharePoint, Exchange, Intune, Copilot and so on), cloud (Worldwide, GCC, GCC High, DoD), platform and keyword. Put it on a weekly schedule and send the changes to Slack, Teams, email or a spreadsheet.

You can also pull the whole roadmap, filtered your way, as a clean table.

### Why use this instead of the roadmap website or RSS feed?

The roadmap has about 1,900 items, and Microsoft touches around 100 of them in a typical week. The website's "New or updated" filter and the RSS feed tell you *which* items were touched, but not *what* changed. Did the rollout date slip, did the status move, or did someone fix a typo? You have to remember the old version to know.

| What you need | Roadmap website / RSS | This tool |
| --- | --- | --- |
| What changed since last week | A list of new or updated items | Only real changes, each with a plain-English summary |
| Rollout date pushed back | Shows the new date only | "Rollout start: November 2026 → January 2027" |
| Status moved to Rolling out | Shows the new status only | "Status: In development → Rolling out" |
| Item cancelled | Easy to miss | "Status: In development → Cancelled" |
| Item removed from the roadmap | It just disappears | Reported as `removed` with its last known details |
| Only my products and cloud | Re-apply filters each visit | Saved in your input, applied every run |
| Get it into Slack, Teams or a sheet | Copy and paste | One ready-to-post line per change (`alertText`), plus a plain-text digest |

### What data you get

One row per change (or per item in "Everything" mode), plus one free status row per run. Use the **Changes**, **Full details**, **Alert text** and **Run status** tabs in the Output.

| Field | What it is | Example |
| --- | --- | --- |
| `changeType` | `new`, `changed` or `removed`. `updated` on a first run, `listed` in Everything mode | `changed` |
| `changeSummary` | Plain-English description of the change | `Status: In development → Rolling out. Release date: November 2026 → December 2026.` |
| `changedFields`, `previous` | Which fields changed and their old values | `["status"]`, `{"status": "In development"}` |
| `id`, `title`, `roadmapUrl` | Roadmap ID, title and a link that opens that item on Microsoft's site | `576198` |
| `status` | In development, Rolling out, Launched or Cancelled | `In development` |
| `generalAvailability`, `previewAvailability` | The month shown as "Rollout start" on Microsoft's site, and the preview month. Also as `2026-12` in the `...Date` fields | `December 2026` |
| `products`, `platforms`, `cloudInstances`, `releaseRings` | Microsoft's tags | `["Microsoft Teams"]`, `["GCC", "GCC High", "DoD"]` |
| `description` | Full description as plain text | |
| `moreInfoUrls`, `created`, `modified` | Links and Microsoft's timestamps | |
| `alertText` | One line, ready to post | `Changed: Microsoft Teams: ... Status: In development → Rolling out. https://...` |

The status row says what happened in plain English, for example "12 changes since your last run (2026-10-14 22:00 UTC): 3 new, 8 changed, 1 removed." A run summary is saved as `OUTPUT`, and a plain-text digest grouped by change type is saved as `DIGEST` in the key-value store. The digest is handy for email.

### Who uses it

| Who | What for |
| --- | --- |
| Microsoft 365 admins | A weekly list of what's coming to the services you run, without reading the whole roadmap |
| MSPs and consultants | One schedule per client profile (products and cloud), feeding a client newsletter or ticket queue |
| Change managers and trainers | Spot features moving to Rolling out, so you can prepare users before they see them |
| Government tenants | Filter to GCC, GCC High or DoD (about 550 items), where timing often differs from Worldwide |
| Mac and mobile admins | Filter to Mac (about 365 items), iOS or Android |

### How to use it

1. Click **Try for free**.
2. Leave **What to return** on "Changes since my last run".
3. Add your **Products** (one per line), for example `Teams`, `SharePoint`, `Intune`. Leave empty for everything.
4. Optionally pick a **Cloud**, **Platform** or **Status**, or add **Keywords**.
5. Click **Start**. The first run saves a snapshot and shows items added or updated in the last 7 days, so you have something to look at straight away.
6. Go to **Schedules** and run it weekly (or daily) with the same input. From then on, each run returns only what changed.

**When to schedule it:** Microsoft publishes roadmap updates once a day on weekdays, between 22:00 and 23:00 UTC. A schedule any time after 00:00 UTC catches the latest batch. Expect a bigger batch around the end of each month.

### Input example

```json
{
    "mode": "changes",
    "products": ["Teams", "SharePoint", "Exchange", "Intune"],
    "excludeProducts": ["Dynamics 365"],
    "clouds": ["Worldwide"],
    "reportChanges": ["new", "status", "dates", "removed"],
    "firstRunDays": 7
}
```

#### Useful inputs

- **Products** match whole words: "Teams" finds "Microsoft Teams", "Copilot" finds "Microsoft Copilot (Microsoft 365)", but "Team" finds nothing. Copilot alone is over a quarter of the roadmap, so filtering makes a big difference. The roadmap also includes Dynamics 365 and Power Platform items. Use **Leave out these products** if you don't want them.
- **Changes to report** lets you skip noise. For example, choose only "Status changes" and "Release or preview date moved" if you only care about timing.
- **Each set of filters has its own memory.** You can run several schedules (say, one per client) without them interfering. Changing the filters or the change types starts a fresh snapshot.
- **Max items** never loses changes. If a run hits the limit, the rest are held back and returned on the next run.
- **Everything mode** returns every matching item. Add "Only items updated in the last N days" to export recent activity without keeping a snapshot.

### Output example

A new item, from a real run:

```json
{
    "type": "feature",
    "changeType": "new",
    "id": "576198",
    "title": "Microsoft Teams: Near-real-time detection of malicious QR codes in messages",
    "status": "In development",
    "products": ["Microsoft Teams"],
    "generalAvailabilityDate": "2026-12",
    "generalAvailability": "December 2026",
    "previewAvailabilityDate": null,
    "releaseRings": ["General Availability"],
    "platforms": ["Desktop", "Mac", "Mobile", "Web"],
    "cloudInstances": ["DoD", "GCC", "GCC High"],
    "roadmapUrl": "https://www.microsoft.com/microsoft-365/roadmap?id=576198",
    "created": "2026-10-14T23:01:02.554Z",
    "alertText": "New: Microsoft Teams: Near-real-time detection of malicious QR codes in messages (In development, release December 2026) https://www.microsoft.com/microsoft-365/roadmap?id=576198"
}
```

The shape of a changed item (example values):

```json
{
    "type": "feature",
    "changeType": "changed",
    "id": "123456",
    "title": "Microsoft Teams: Example feature",
    "changeSummary": "Status: In development → Rolling out. Release date: October 2026 → November 2026.",
    "changedFields": ["status", "generalAvailabilityDate"],
    "previous": { "status": "In development", "generalAvailabilityDate": "2026-10" },
    "status": "Rolling out",
    "generalAvailability": "November 2026"
}
```

### Pricing

$0.003 per roadmap check, plus $2.00 per 1,000 rows returned ($0.002 per change), plus Apify's standard $0.00005 start fee. There's no separate platform usage charge, and status rows are free. If Microsoft's roadmap can't be downloaded, only the start fee applies.

Typical costs, based on real roadmap activity in October 2026:

| What you run | Rows | Cost |
| --- | --- | --- |
| Daily check, nothing changed | 0 | $0.003 |
| Weekly check, Teams + SharePoint + Exchange + Outlook | about 40 | $0.08 |
| Weekly check, all products | about 115 | $0.23 |
| Full roadmap export | about 1,900 | $3.85 |

A weekly watch on a few products costs about $0.35 a month, well within Apify's free monthly credit.

If you set a maximum cost per run, the tool stops at that limit and holds the remaining changes for your next run, so nothing is missed.

### Reliability, built in

- **Status row on every run.** It says what changed, what was held back and why.
- **No false alarms when Microsoft has a bad day.** If the roadmap feed comes back much smaller than last time, removals aren't reported and nothing is forgotten.
- **Two sources.** It reads Microsoft's current roadmap API and falls back to the older one if the current one fails.
- **Only real changes.** Microsoft often updates an item's timestamp without changing anything visible. Those are ignored, so you're not charged for them.
- **Nothing gets lost.** Changes over your item or cost limit carry over to the next run.
- **Fast.** A full check of the roadmap takes a few seconds.

### Integrations and scheduling

Schedule it in Apify (weekly is a good start). Apify connects directly to Slack and email. For Microsoft Teams, Google Sheets or anything else, use Apify's Power Automate, Zapier, Make or n8n integrations, or a webhook. Post the `alertText` field as a message, or email the `DIGEST` record. You can also call it from your own scripts through the Apify API, or let AI agents use it through the Apify MCP server.

### FAQ

**What's the difference between "Cancelled" and "removed"?**
Microsoft sometimes marks a dropped feature as Cancelled, which shows up as a status change. "Removed" means the item was on the roadmap last run and isn't now. That's usually an older launched or cancelled item being archived. The row includes the item's last known status so you can tell.

**Why did my first run return so few items?**
The first run has nothing to compare against. It saves a snapshot and returns items added or updated in the last 7 days (change this with "First run: include the last N days"). Real change tracking starts from the second run.

**Does it include Message Center posts?**
No. Message Center needs a sign-in to your tenant. This tool only reads the public Microsoft 365 Roadmap, which needs no account and no permissions.

**How many items are on the roadmap?**
About 1,900 (1,923 in October 2026). Microsoft's feed only includes current items, so older launched features drop off over time.

**I changed my filters and got a "first run" again. Why?**
Each set of filters keeps its own snapshot, so separate schedules don't interfere with each other. Changing the filters starts a new snapshot.

**How often does Microsoft update the roadmap?**
Once a day on weekdays, between 22:00 and 23:00 UTC, with a larger batch around the end of each month. A daily or weekly schedule is plenty.

**Is this legal?**
Yes. The Microsoft 365 Roadmap is public information Microsoft publishes for customers. This tool reads only that public feed, doesn't log in, and collects no personal data.

**Something isn't working?**
Open an issue on the Issues tab with your input and the run link. I usually reply within one business day.

### Related tools

- [Google Trends Scraper](https://apify.com/snappytools/google-trends-scraper): interest over time, regions and rising queries.
- [Google Ads Transparency Scraper](https://apify.com/snappytools/google-ads-transparency-scraper): every ad a company runs on Google.

This tool is independent and is not affiliated with, endorsed by or connected to Microsoft.

# Actor input Schema

## `mode` (type: `string`):

"Changes since my last run" is for schedules: the first run saves a snapshot, and later runs return only new, changed and removed items. "Everything" returns every roadmap item that matches your filters, every time.

## `products` (type: `array`):

Only items for these products. Matches whole words, so "Teams" finds "Microsoft Teams" and "Copilot" finds "Microsoft Copilot (Microsoft 365)". Leave empty for all products.

## `excludeProducts` (type: `array`):

Skip items that only belong to these products, for example "Dynamics 365" or "Power Apps". Items shared with a product you didn't exclude are kept.

## `keywords` (type: `array`):

Only items whose title or description contains one of these words or phrases (whole words, not case sensitive). For example "retention", "Mac" or "Conditional Access".

## `statuses` (type: `array`):

Only items with these statuses. Leave empty for all.

## `clouds` (type: `array`):

Only items for these Microsoft clouds. Most tenants are Worldwide. Leave empty for all.

## `platforms` (type: `array`):

Only items for these platforms. Leave empty for all.

## `reportChanges` (type: `array`):

Which kinds of change to return in "Changes since my last run" mode. Leave empty for all of them.

## `firstRunDays` (type: `integer`):

The first run has nothing to compare with, so it saves a snapshot and returns items added or updated in this many days. Set 0 to just save the snapshot.

## `modifiedWithinDays` (type: `integer`):

For "Everything" mode. 0 means no limit.

## `maxItems` (type: `integer`):

The most rows to return in one run. In changes mode, anything over the limit is kept for the next run, not lost.

## `watchName` (type: `string`):

Optional. Each combination of filters keeps its own memory automatically. Give a name only if you want two schedules with the same filters to track changes separately.

## Actor input object example

```json
{
  "mode": "changes",
  "products": [
    "Teams",
    "SharePoint",
    "Exchange",
    "Outlook"
  ],
  "excludeProducts": [],
  "keywords": [],
  "statuses": [],
  "clouds": [],
  "platforms": [],
  "reportChanges": [],
  "firstRunDays": 7,
  "modifiedWithinDays": 0,
  "maxItems": 1000
}
```

# Actor output Schema

## `changes` (type: `string`):

No description

## `details` (type: `string`):

No description

## `alerts` (type: `string`):

No description

## `status` (type: `string`):

No description

## `allResults` (type: `string`):

No description

## `digest` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "changes",
    "products": [
        "Teams",
        "SharePoint",
        "Exchange",
        "Outlook"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("snappytools/m365-roadmap-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "changes",
    "products": [
        "Teams",
        "SharePoint",
        "Exchange",
        "Outlook",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("snappytools/m365-roadmap-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "changes",
  "products": [
    "Teams",
    "SharePoint",
    "Exchange",
    "Outlook"
  ]
}' |
apify call snappytools/m365-roadmap-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,snappytools/m365-roadmap-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/lE4G6eku5r8vUYxMY/builds/AsFR4kk1fvYx78sOY/openapi.json