Outlook Calendar Integration

Connect an Outlook calendar once and MeetStream schedules a bot for your upcoming Microsoft Teams, Zoom and Google Meet meetings, then keeps those bots in sync as events move or get cancelled.

Before you start

• A MeetStream API key that is active. Every calendar feature runs under your API key. Without one, the dashboard’s Calendar page shows “No active API key found. Create one on the API Keys page.” See Dashboard Setup.
• A Microsoft Entra account that can register applications (at least the Application Developer role, per Microsoft Learn).
• Pick how you will connect:
  • Dashboard (recommended). MeetStream runs the Microsoft sign-in and consent for you and stores the resulting refresh token. You only paste a Client ID and Client Secret.
  • API. You run the consent flow yourself, obtain a refresh token, and send it to POST /api/v1/calendar/create_outlook_calendar. See Connect with the API instead.

Step 1: Register the app in Microsoft Entra

Menu names below match Microsoft’s current documentation for the Microsoft Entra admin center.

Step 2: Connect Outlook Calendar in the dashboard

1

Open Calendar and start a connection

In the dashboard sidebar, under Configure, click Calendar (1), then + Connect calendar (2). If a calendar is already connected, use + Connect another account on the Calendars page instead.

2

Copy the redirect URI

Under Add this redirect URI first, click Copy and confirm the same value is registered as a Web redirect URI on your app. The page reminds you: “OAuth will fail if this URL isn’t registered exactly.”

3

Paste your Client ID and Client Secret

On the Outlook Calendar card (“Connect with Microsoft OAuth (BYOK).”), paste the Client ID (2), which is the Application (client) ID, and the Client Secret (3), which is the secret’s Value. Setup guide (1) links back to this page. Click Connect Outlook (4).

4

Sign in and consent

Microsoft asks you to sign in and approve the requested permissions. You then return to MeetStream, which shows “Connecting your Outlook Calendar…” and then Outlook Calendar connected with a View calendars button.

Step 3: Turn on auto-join

On the Calendars page, switch on Auto-schedule bots: “MeetStream automatically schedules a bot for new meetings that have a join link.” Auto-join covers every connected account, Outlook and Google.

• Default bot settings sets the bot name, image URL, join message, audio and video, and automatic leave timeouts for calendar bots. These defaults are saved in your browser and sent to MeetStream when you switch auto-join on, so switch it off and on again after changing them.
• Click a connected account to see its events, Sync events, or schedule individual events with Schedule bots.

With the API, use POST /api/v1/calendar/auto-schedule/enable with a default_bot_config (see the Google Calendar guide’s API reference; the calendar endpoints are shared by both providers).

How auto-join works

Which links count as meeting links

MeetStream reads the event’s online meeting join URL first (the Teams link Outlook adds to online meetings), then URLs in the location, then meeting-platform URLs in the body.

Before you rely on auto-join for Teams meetings, read the Microsoft Teams platform guide (lobby and admission rules) and, for meetings that only admit signed-in users, Microsoft Teams Signed-In Bots. Every status and error a bot can end with is listed in the status and error code reference.

Connect with the API instead

Use this path to run the Microsoft consent flow inside your own product, or to use a single-tenant app.

Get a refresh token with the local helper

This Node.js 18+ helper runs the Microsoft authorization code flow on your machine and prints the refresh token. Register http://localhost:3000/api/microsoft/oauth-callback as a Web redirect URI first.

1. Create a .env file (set MICROSOFT_TENANT_ID to your tenant ID for a single-tenant app, or leave it as common):

MICROSOFT_CLIENT_ID=<YOUR_APPLICATION_CLIENT_ID>
MICROSOFT_CLIENT_SECRET=<YOUR_CLIENT_SECRET_VALUE>
MICROSOFT_TENANT_ID=common

2. Install dependencies with npm install express dotenv and save this as server_microsoft.js:

const express = require('express');
require('dotenv').config();
const app = express();
const PORT = 3000;
const REDIRECT_URI = `http://localhost:${PORT}/api/microsoft/oauth-callback`;
const TENANT = process.env.MICROSOFT_TENANT_ID || 'common';
const SCOPES = 'offline_access openid profile email User.Read Calendars.Read';
app.get('/', (_req, res) => {
  const params = new URLSearchParams({
    client_id: process.env.MICROSOFT_CLIENT_ID,
    response_type: 'code',
    redirect_uri: REDIRECT_URI,
    response_mode: 'query',
    scope: SCOPES,
    prompt: 'consent',
  });
  res.redirect(`https://login.microsoftonline.com/${TENANT}/oauth2/v2.0/authorize?${params}`);
});
app.get('/api/microsoft/oauth-callback', async (req, res) => {
  const { code, error, error_description } = req.query;
  if (error) return res.status(400).send(`<h1>${error}</h1><p>${error_description || ''}</p>`);
  const tokenRes = await fetch(`https://login.microsoftonline.com/${TENANT}/oauth2/v2.0/token`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      client_id: process.env.MICROSOFT_CLIENT_ID,
      client_secret: process.env.MICROSOFT_CLIENT_SECRET,
      code,
      redirect_uri: REDIRECT_URI,
      grant_type: 'authorization_code',
    }),
  });
  const tokens = await tokenRes.json();
  if (!tokens.refresh_token) {
    return res.status(400).send(`<pre>${JSON.stringify(tokens, null, 2)}</pre>`);
  }
  console.log('Refresh token:', tokens.refresh_token);
  res.send(`<h1>Success</h1><pre style="word-break:break-all">${tokens.refresh_token}</pre>`);
});
app.listen(PORT, () => console.log(`Open http://localhost:${PORT} to start the OAuth flow`));

3. Run node server_microsoft.js, open http://localhost:3000, sign in with the account to connect, and approve access. Copy the refresh token.

If no refresh token comes back, confirm offline_access is in the requested scopes and that you accepted the consent screen.

Connect the account

curl -X POST "https://api.meetstream.ai/api/v1/calendar/create_outlook_calendar" \
  -H "Authorization: Token <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "microsoft_client_id": "<YOUR_APPLICATION_CLIENT_ID>",
    "microsoft_client_secret": "<YOUR_CLIENT_SECRET_VALUE>",
    "microsoft_refresh_token": "<YOUR_REFRESH_TOKEN>"
  }'

MeetStream validates the credentials with Microsoft, reads the account’s email through Microsoft Graph (this becomes account_id), fetches the account’s calendars, stores the credentials encrypted, and subscribes to change notifications for the account’s calendars. The response includes provider: "outlook", account_id, user_email, calendars, primary_calendar_id and a watch_setup summary.

Each call connects one account. To add another Microsoft account (for example a second tenant), run the helper signed in as that account and call the endpoint again. Reconnecting an account that is already connected without replace returns 409:

{ "error": "Outlook account 'jane@example.com' is already connected for this user. Pass {\"replace\": true} in the request body to reconnect." }

Working with several accounts

A MeetStream account can hold many calendar connections, from Outlook and Google. Each is identified by (provider, account_id), where provider is outlook (the alias microsoft is accepted) and account_id is the account’s email. There is no fixed limit on the number of connections.

GET /api/v1/calendar/calendars, GET /api/v1/calendar/events and GET /api/v1/calendar/get_events return data for every account by default. Add ?provider=outlook&account_id=jane%40example.com to scope a call to one account.

curl "https://api.meetstream.ai/api/v1/calendar/events?provider=outlook&account_id=jane%40example.com&limit=20" \
  -H "Authorization: Token <YOUR_API_KEY>"

Scheduling, unscheduling, managing scheduled bots and auto-join work the same way for both providers. See the Google Calendar guide’s API reference for POST /calendar/schedule/{event_id}, DELETE /calendar/schedule/{event_id}, the scheduled_bots endpoints and the auto-schedule endpoints.

FAQ

Do I need a Microsoft 365 (work or school) account?

No. Personal Microsoft accounts (Outlook.com, Hotmail, Live) and Microsoft 365 accounts both work when your app registration uses Any Entra ID Tenant + Personal Microsoft accounts. One MeetStream account can connect personal and work accounts at the same time.

Why did a bot join a meeting I declined?

Auto-join does not look at RSVP status today. Every event with a meeting link in the next 24 hours gets a bot. Use per-event scheduling if you need to skip declined or external meetings.

How early does the bot join?

The bot is dispatched about 2 minutes before the event’s start time.

What happens if I reschedule or cancel a meeting in Outlook?

Microsoft notifies MeetStream. A moved event moves its bot’s join time; a deleted or cancelled event cancels its bot (Cancelled).

My client secret expired. What do I do?

Create a new client secret under Certificates & secrets, then reconnect: in the dashboard, go to Calendar > + Connect another account and use Reconnect on the Outlook card with the new secret. With the API, get a fresh refresh token and call POST /api/v1/calendar/create_outlook_calendar with "replace": true.

How is my calendar data protected?

OAuth credentials are stored encrypted and are never returned by the API. MeetStream never sees or stores your Microsoft password. You can revoke access by disconnecting in MeetStream or by removing the app’s consent in your Microsoft account.

For webhook handling, see Webhooks and Events. For Google Calendar, see Google Calendar OAuth Setup.