Microsoft Teams Meeting Bot: A Complete Developer Guide to Recording and Transcribing Teams Calls

Why Teams matters for enterprise developers

If you're building for enterprise customers, Microsoft Teams is often the primary meeting platform. Office 365 adoption is ubiquitous in financial services, healthcare, legal, manufacturing, and government sectors. Your customer's IT department likely manages a Microsoft tenant, and your product will need to work where their meetings happen.

Recording and transcribing Teams meetings programmatically is significantly more complex than Google Meet — but it's doable, and the resulting integration is more stable once in place. This guide covers both the official approach (Microsoft's Bot Framework) and the pragmatic approach (a third-party API like Gregnote).

Two approaches to Teams meeting bots

Approach 1: Microsoft Bot Framework (official)

Microsoft has a first-class bot platform for Teams. A registered Bot Framework bot can join Teams meetings, receive real-time audio via media streams, and interact with the Teams API.

The advantages: official support, stable API, works within enterprise tenant security policies, can handle high volumes reliably.

The disadvantages: significant setup complexity (Azure Active Directory app registration, Bot Framework registration, manifest, permissions), approval by the enterprise IT administrator is often required, and the media streaming API requires your bot to run specific media processing libraries.

Setup involves: 1. Registering an application in Azure Active Directory 2. Creating a Bot Framework registration with Azure Bot Service 3. Configuring bot permissions (joining meetings, accessing media streams) 4. Building and hosting the bot backend (C# or Node.js) 5. Creating a Teams app manifest and distributing it to your tenant (or submitting to the Teams App Store for broader distribution)

For a mature engineering team building an enterprise product, this is the right path. The setup investment is paid back in stability and enterprise customer trust.

Approach 2: Third-party meeting bot API (pragmatic)

If you're prototyping, building for an early-stage product, or need to support both Teams and Google Meet without maintaining two separate codebases, a third-party API like Gregnote is the faster path.

Gregnote abstracts over the platform differences. The same API call works for both Teams and Meet:

POST https://api.gregnote.com/v1/bots
{
  "meeting_url": "https://teams.microsoft.com/l/meetup-join/...",
  "bot_name": "Meeting Recorder",
  "webhook_url": "https://yourapp.com/hooks/meeting-complete"
}

The webhook payload format is identical regardless of platform. You don't need an Azure account, a bot manifest, or tenant admin approval.

The trade-off: you're depending on a third-party service for the bot infrastructure. For most early-stage products, this is the right call — build the product logic first, add the infrastructure complexity later when you have the scale to justify it.

Getting a Teams meeting URL

Teams meeting URLs have a specific format. They look like:

https://teams.microsoft.com/l/meetup-join/19%3ameeting_...

You can get this URL: - From the meeting invite in the Teams client ("Copy join link") - From the Microsoft Graph API calendar events endpoint (/me/events) - From the Teams Meeting API if you're creating meetings programmatically

Creating a Teams meeting via Graph API

If you want your product to create Teams meetings (not just join existing ones), you need a Graph API integration:

// First: authenticate with Microsoft Graph
const token = await getGraphToken(userId); // OAuth 2.0

// Create an online meeting const meeting = await fetch("https://graph.microsoft.com/v1.0/me/onlineMeetings", { method: "POST", headers: { "Authorization": Bearer ${token}, "Content-Type": "application/json", }, body: JSON.stringify({ startDateTime: "2026-09-01T14:00:00Z", endDateTime: "2026-09-01T15:00:00Z", subject: "Discovery Call", }) });

const { joinWebUrl } = await meeting.json(); // joinWebUrl is the Teams meeting URL to pass to Gregnote ```

Sending the bot to a Teams meeting

Once you have the Teams meeting URL, the Gregnote integration is identical to Google Meet:

async function sendBotToTeamsMeeting(meetingUrl, userId, metadata = {}) {
  const response = await fetch("https://api.gregnote.com/v1/bots", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.GREGNOTE_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      meeting_url: meetingUrl,
      bot_name: "Meeting Recorder",
      webhook_url: `${process.env.BASE_URL}/hooks/meeting`,
      metadata: { user_id: userId, ...metadata }
    })
  });

if (!response.ok) { throw new Error(Bot dispatch failed: ${await response.text()}); }

return response.json(); } ```

The bot appears in the Teams meeting as a named participant. Teams shows bots with a robot icon, making them clearly distinct from human participants — which is good for transparency.

Admission in Teams vs Google Meet

Teams and Google Meet handle bot admission differently.

In Google Meet, the bot sends a join request and the host sees a notification. The host clicks "Admit." If the meeting allows all participants, admission is automatic.

In Microsoft Teams, bots registered via Bot Framework are admitted automatically once the tenant administrator has approved the bot application. For third-party API bots (like Gregnote), the bot joins as a meeting participant — the host may see a "someone is requesting to join" notification depending on the meeting's lobby settings.

For enterprise deployments, the safest approach is to configure Teams meetings to allow participants to bypass the lobby — this setting is controlled at the meeting level or by tenant policy.

The webhook: same format, regardless of platform

One of the advantages of using a platform-abstraction API is that the webhook payload format is the same for Teams and Meet:

{
  "event": "meeting.completed",
  "bot_id": "bot_01J9...",
  "platform": "microsoft_teams",
  "transcript": {
    "text": "Alice: Let's review the Q3 numbers...",
    "language": "en",
    "segments": [
      { "speaker": "Alice", "text": "Let's review the Q3 numbers.", "start": 0.0, "end": 3.2 },
      { "speaker": "Bob",   "text": "Happy to. Sales is up 12%.", "start": 3.5, "end": 6.1 }
    ]
  },
  "duration_seconds": 2340,
  "metadata": { "user_id": "user_123" }
}

Your webhook handler doesn't need to know whether the meeting was on Teams or Meet — the transcript format is identical. This is the key advantage of the abstraction layer.

Handling Teams-specific edge cases

Meeting lobby

Teams has a lobby system — participants can be held in a waiting area before being admitted to the meeting. If your bot gets stuck in the lobby, Gregnote will fire a bot.owner_no_show event after the configured timeout (default 10 minutes), treating it as an owner no-show.

To avoid this: configure your Teams meetings (or advise your users to configure them) to bypass the lobby for all participants, or for "people in my organisation and trusted organisations."

Teams Live Events

Teams has a separate "Live Events" mode for large broadcast-style meetings (up to 10,000 attendees). Live Events have a different URL format and different API semantics. Standard meeting bot APIs do not support Live Events — they're designed for regular meetings of up to several hundred participants.

Guest participants

Teams handles external (guest) participants differently from internal users. If your bot is the only external participant in a Teams meeting, it may be placed in the lobby regardless of the meeting's lobby settings. The workaround is to have the meeting host admit the bot explicitly.

From transcript to action

Once you have the Teams meeting transcript via webhook, the downstream processing is identical to any other meeting: pass to an LLM, generate a summary, push to your product's destination.

For the complete prompt engineering and delivery pipeline, see AI meeting summary API guide. For the webhook reliability patterns your handler needs, see webhook reliability patterns.

Comparison: Teams vs Meet for developers

For most early-stage products: start with Google Meet, add Teams support when enterprise customers require it. The Gregnote API supports both with the same integration — so adding Teams doesn't require a new codebase, just testing.