Meeting apps APIs

The meeting extensibility provides APIs to enhance meeting experience. You can perform the following with help of the listed APIs:

• Build apps or integrate existing apps within meeting lifecycle.
• Use APIs to make your app aware of meeting.
• Select required APIs to improve the meeting experience.

The following table provides a list of APIs available across the Teams SDK and the TeamsJS library:

Get user context API

To identify and retrieve contextual information for your tab content, see get context for your Teams tab. meetingId is used by a tab running in the meeting context and is added for the response payload.

Examples

The following are the TeamsJS v2 responses for Get user context API based on meeting type, user type, and call type:

• Meeting type

  • Channel meeting
  • Scheduled meeting
  • Instant meeting

  The following is a JSON payload response for a channel meeting for in-tenant users:

  {
      "app": {
      "locale": "en-us",
      "sessionId": "ff47ec00-e6a7-4dc1-a6ae-f44110f50c94",
      "theme": "default",
      "iconPositionVertical": 0,
      "osLocaleInfo": {
        "platform": "windows",
        "regionalFormat": "en-in",
        "shortDate": "dd-MM-yyyy",
        "longDate": "dd MMMM yyyy",
        "shortTime": "HH:mm",
        "longTime": "HH:mm:ss"
      },
      "parentMessageId": "1678109354022",
      "userClickTime": 1678109521159,
      "userFileOpenPreference": "inline",
      "host": {
        "name": "Teams",
        "clientType": "desktop",
        "sessionId": "c3c3c0a0-f7a1-b070-6b89-c8cd1f380042",
        "ringId": "ring1"
      },
      "appLaunchId": "7346ae66-5cac-47f9-8a0d-1228dac474cb"
      },
      "page": {
      "id": "Test",
      "frameContext": "sidePanel",
      "subPageId": "",
          "isFullScreen": false,
          "isMultiWindow": true,
          "sourceOrigin": ""
         },
         "user": {
          "id": "57efa5f3-273c-47e2-a871-4879e5d849cf",
          "displayName": "",
          "isCallingAllowed": undefined,
          "isPSTNCallingAllowed": undefined,
          "licenseType": "Unknown",
          "loginHint": "user@microsoft.com",
          "userPrincipalName": "user@microsoft.com",
          "tenant": {
           "id": "72f988bf-86f1-41af-91ab-2d7cd011db47",
           "teamsSku": "enterprise"
          }
         },
         "channel": {
          "id": "19:49683807ffce4318ad6d6d7a24dbde45@thread.tacv2",
          "displayName": undefined,
          "relativeUrl": undefined,
          "membershipType": undefined,
          "defaultOneNoteSectionId": undefined,
          "ownerGroupId": undefined,
          "ownerTenantId": undefined
         },
         "chat": {
          "id": "19:49683807ffce4318ad6d6d7a24dbde45@thread.tacv2"
         },
         "meeting": {
          "id": "MCMxOTo0OTY4MzgwN2ZmY2U0MzE4YWQ2ZDZkN2EyNGRiZGU0NUB0aHJlYWQudGFjdjIjMTY3ODEwOTM1NDAyMg=="
         },
         "sharepoint": undefined,
         "team": {
          "internalId": "19:b34aeec3f8e54240a5c283e86bfc4878@thread.tacv2",
          "displayName": undefined,
          "type": undefined,
          "groupId": undefined,
          "templateId": undefined,
          "isArchived": undefined,
          "userRole": 1
         },
         "sharePointSite": {
          "teamSiteUrl": "",
          "teamSiteDomain": "microsoft.sharepoint.com",
          "teamSitePath": "",
          "teamSiteId": "",
          "mySitePath": undefined,
          "mySiteDomain": undefined
         }
        }
  

• User type

  • Guest user
  • Anonymous user
  • External user

  The following is a JSON payload response in a scheduled private meeting for a guest user:

    {
          "app": {
           "locale": "en-us",
           "sessionId": "268beeb4-a52d-4ba8-b1c8-8b9f0b9b3492",
           "theme": "default",
           "iconPositionVertical": 23,
           "osLocaleInfo": {
            "platform": "windows",
            "regionalFormat": "en-in",
            "longDate": "dd MMMM yyyy",
            "shortDate": "dd-MM-yyyy",
            "longTime": "HH:mm:ss",
            "shortTime": "HH:mm"
           },
           "parentMessageId": "",
           "userClickTime": 1678023265131,
           "userFileOpenPreference": "inline",
           "host": {
            "name": "Teams",
            "clientType": "desktop",
            "sessionId": "967c980b-1e41-a2cd-eac0-a4bff8f73ce7",
            "ringId": "ring1"
           },
           "appLaunchId": "c35c4496-f28c-4107-8e6c-2dba09fb881a"
          },
          "page": {
           "id": "Test",
           "frameContext": "content",
           "subPageId": "",
           "isFullScreen": false,
           "isMultiWindow": false,
           "sourceOrigin": NULL
          },
          "user": {
           "id": "57efa5f3-273c-47e2-a871-4879e5d849cf",
           "displayName": undefined,
           "isCallingAllowed": undefined,
           "isPSTNCallingAllowed": undefined,
           "licenseType": "Unknown",
           "loginHint": "user@microsoft.com",
           "userPrincipalName": "user@microsoft.com",
           "tenant": {
            "id": "72f988bf-86f1-41af-91ab-2d7cd011db47",
            "teamsSku": "enterprise"
           }
          },
          "channel": undefined,
          "chat": {
           "id": "19:meeting_YmU5NWM3NGEtZjMyMi00ZDg4LTk4OGUtMjUzMGJkZjRhMDhm@thread.v2"
          },
          "meeting": {
           "id": "MCMxOTptZWV0aW5nX1ltVTVOV00zTkdFdFpqTXlNaTAwWkRnNExUazRPR1V0TWpVek1HSmtaalJoTURobUB0aHJlYWQudjIjMA=="
          },
          "sharepoint": undefined,
          "team": undefined,
          "sharePointSite": {
           "teamSiteUrl": "",
           "teamSiteDomain": "microsoft.sharepoint.com",
           "teamSitePath": "",
           "teamSiteId": undefined,
           "mySitePath": "/personal/user_microsoft_com",
           "mySiteDomain": "microsoft-my.sharepoint.com"
          }
    }
  
  

• Call type

  • One-on-One call
  • Group call

  The following is a JSON payload response for a one-on-one call for an in-tenant user:

        {
         "app": {
          "locale": "en-us",
          "sessionId": "1b3dc47e-f6ae-4fe2-8ed6-844a505f3186",
          "theme": "dark",
          "iconPositionVertical": null,
          "osLocaleInfo": {
           "platform": "windows",
           "regionalFormat": "en-in",
           "shortDate": "dd-MM-yyyy",
           "longDate": "dd MMMM yyyy",
           "shortTime": "HH:mm",
           "longTime": "HH:mm:ss"
          },
          "parentMessageId": "",
          "userClickTime": 1678088052473,
          "userFileOpenPreference": undefined,
          "host": {
           "name": "Teams",
           "clientType": "desktop",
           "sessionId": "",
           "ringId": "general"
          },
          "appLaunchId": undefined
         },
         "page": {
          "id": "Test",
          "frameContext": "sidePanel",
          "subPageId": "",
          "isFullScreen": undefined,
          "isMultiWindow": true,
          "sourceOrigin": ""
         },
         "user": {
          "id": "e652dd92-dd63-4fcc-b5b2-2005681e8e9f",
          "displayName": undefined,
          "isCallingAllowed": undefined,
          "isPSTNCallingAllowed": undefined,
          "licenseType": "Unknown",
          "loginHint": "user@microsoft.com",
          "userPrincipalName": "user@microsoft.com",
          "tenant": {
           "id": "aa923623-ae61-49ee-b401-81f414b6ad5a",
           "teamsSku": "unknown"
          }
         },
         "channel": undefined,
         "chat": {
          "id": "19:a74d8489-4455-4670-9581-7b38a8017c58_e652dd92-dd63-4fcc-b5b2-2005681e8e9f@unq.gbl.spaces"
         },
         "meeting": {
          "id": "MCMxOTphNzRkODQ4OS00NDU1LTQ2NzAtOTU4MS03YjM4YTgwMTdjNThfZTY1MmRkOTItZGQ2My00ZmNjLWI1YjItMjAwNTY4MWU4ZTlmQHVucS5nYmwuc3BhY2VzIzA="
         },
         "sharepoint": undefined,
         "team": undefined,
         "sharePointSite": {
          "teamSiteUrl": undefined,
          "teamSiteDomain": "microsoft.sharepoint.com",
          "teamSitePath": undefined,
          "teamSiteId": undefined,
          "mySitePath": undefined,
          "mySiteDomain": undefined
         }
        }
  
  

Get participant API

The Get Participant API enables your app to fetch participant information by meeting ID and participant ID. The API is available through the Teams SDK.

Query parameters

The Meeting API must have meetingId, participantId, and tenantId as parameters. The parameters are available as part of the Teams SDK activity context and the TeamsJS library.

The following table includes the query parameters:

Example

app.OnMessage(async (context, cancellationToken) =>
{
    var meetingId = context.Activity.ChannelData?.Meeting?.Id;
    var tenantId = context.Activity.ChannelData?.Tenant?.Id;
    var userId = context.Activity.From?.AadObjectId;

    if (meetingId != null && tenantId != null && userId != null)
    {
        // Gets the details for the given meeting participant.
        var participant = await context.Api.Meetings.GetParticipantAsync(meetingId, userId, tenantId);

        // Sends a message activity to the sender of the incoming activity.
        await context.Send($"The participant role is: {participant.Meeting?.Role}", cancellationToken);
    }
});

app.on('message', async ({ activity, api, send }) => {
  const meetingId = activity.channelData?.meeting?.id;
  const tenantId = activity.channelData?.tenant?.id;
  const userId = activity.from?.aadObjectId;

  if (meetingId && tenantId && userId) {
    // Gets the details for the given meeting participant.
    const participant = await api.meetings.getParticipant(meetingId, userId, tenantId);

    // Sends a message activity to the sender of the incoming activity.
    await send(`The participant role is: '${participant.meeting?.role}'`);
  }
});

@app.on_message
async def handle_message(ctx: ActivityContext[MessageActivity]):
    meeting_id = ctx.activity.channel_data.meeting.id
    tenant_id = ctx.activity.channel_data.tenant.id
    user_id = ctx.activity.from_.aad_object_id

    if meeting_id and tenant_id and user_id:
        # Gets the details for the given meeting participant.
        participant = await ctx.api.meetings.get_participant(meeting_id, user_id, tenant_id)

        # Sends a message activity to the sender of the incoming activity.
        await ctx.send(f"The participant role is: {participant.meeting.role}")

GET /v1/meetings/{meetingId}/participants/{participantId}?tenantId={tenantId}

{
   "user":{
      "id":"29:1JKiJGPAX9TTxtGxhVo0wLx_zwzo-gG8Z-X03306vBwi9p-xMTEbDXsT6KH7-0kkTS8cD-2zkrsoV6f5WJ6_aYw",
      "aadObjectId":"e236c4bf-88b1-4f3a-b1d7-8891dfc332b5",
      "name":"Bob Young",
      "givenName":"Bob",
      "surname":"Young",
      "email":"Bob.young@microsoft.com",
      "userPrincipalName":"Bob.young@microsoft.com",
      "tenantId":"2fe477ab-0efc-4dfd-bde2-484374e2c373",
      "userRole":"user"
   },
   "meeting":{
      "role ":"Presenter",
      "inMeeting":true
   },
   "conversation":{
      "id":"<conversation id>",
      "conversationType": "groupChat", 
      "isGroup":true
   }
}

Response codes

The following table provides the response codes:

Send an in-meeting notification

All users in a meeting receive the notifications sent through in-meeting notification payload. In-meeting notification payload triggers an in-meeting notification and enables you to provide meeting signals that are delivered using the existing conversation notification API for user-bot chat. You can send an in-meeting notification based on user action. The payload is available through the Teams SDK.

You can also send targeted in-meeting notification to a specific participant in a meeting. For more information, see Targeted in-meeting notification.

Query parameter

The following table includes the query parameter:

Examples

Bot ID is declared in the manifest and the bot receives a result object.

app.OnMessage(async (context, cancellationToken) =>
{
    // Send an in-meeting notification with an external resource URL.
    await context.Send(new Activity
    {
        Type = "message",
        Text = "This is a meeting signal test",
        ChannelData = new
        {
            notification = new
            {
                alertInMeeting = true,
                externalResourceUrl = "https://teams.microsoft.com/l/bubble/APP_ID?url=<url>&height=<height>&width=<width>&title=<title>&completionBotId=BOT_APP_ID"
            }
        }
    }, cancellationToken);
});

app.on('message', async ({ send }) => {
  // Send an in-meeting notification with an external resource URL.
  await send({
    type: 'message',
    text: 'This is a meeting signal test',
    channelData: {
      notification: {
        alertInMeeting: true,
        externalResourceUrl: 'https://teams.microsoft.com/l/bubble/APP_ID?url=<url>&height=<height>&width=<width>&title=<title>&completionBotId=BOT_APP_ID'
      }
    }
  });
});

POST /v3/conversations/{conversationId}/activities

// In-meeting notification response
{
    "type": "message",
    "text": "John Phillips assigned you a weekly todo",
    "summary": "Don't forget to meet with Marketing next week",
    "channelData": {
        "notification": {
            "alertInMeeting": true,
            "externalResourceUrl": "https://teams.microsoft.com/l/bubble/APP_ID?url=<url>&height=<height>&width=<width>&title=<title>&<completionBotId>=<BOT_APP_ID>"
        }
    },
    "replyToId": "1493070356924"
}

Response codes

The following table includes the response codes:

Targeted meeting notification and app icon badging API

The targetedMeetingNotification API allows apps to send targeted in-meeting notifications and shows app icon badging to specific participants in a meeting. Apps send targeted in-meeting notifications and app icon badging based on user action. The API is available through bot API.

Prerequisite

You must configure your app manifest with RSC permissions under the webApplicationInfo property to send targeted in-meeting notifications and shows app icon badging to specific participants in a meeting. Use the following examples to configure your manifest:

"webApplicationInfo": {
    "id": "<<MICROSOFT-APP-ID>>",
    "resource": "https://RscBasedStoreApp"  },
  "authorization": {
    "permissions": {
      "resourceSpecific": [
            {
                "name": "OnlineMeetingNotification.Send.Chat",
                "type": "Application"
            }
        ]    
    }
}

"webApplicationInfo": {
    "id": "<<MICROSOFT-APP-ID>>",
    "resource": "https://RscBasedStoreApp",
    "applicationPermissions": [
      "OnlineMeetingNotification.Send.Chat"
    ]
}

Get supported user ID format for targeted in-meeting notification and app icon badging:

• Get participant API
• Get members API

Example

Following is an example of request payload for targeted in-meeting notification and app icon badging:

POST /v1/meetings/{meetingId}/notification

{

  "type": "targetedMeetingNotification",
  "value": {
    "recipients": [ 
"29:1I12M_iy2wTa97T6LbjTh4rJCWrtw2PZ3lxpD3yFv8j2YPnweY2lpCPPAn3RI0PP7rghfHauUz48I1t7ANhj4CA"
     ], 
    "surfaces": [ 
      { 
        "surface": "meetingStage", 
        "contentType": "task", 
        "content": { 
          "value": { 
            "height": "300", 
            "width": "400", 
            "title": "Targeted meeting Notification", 
            "url": "https://somevalidurl.com"           
}
        } 
      } 
    ] 
  },
  "channelData": { // optional if a developer doesn't want to support user attributes.
    "onBehalfOf": [ 
      { 
        "itemid": 0, 
        "mentionType": "person", 
        "mri": "29:1mDOCfGM9825lMHlwP8NjIVMJeQAbN-ojYBT5VzQfPpnst1IFQeYB1QXC8Zupn2RhgfLIW27HmynQk-4bdx_YhA", 
        "displayName": "yunny chung"      } 
    ] 
  }
}

Response code

The following table includes the response codes:

Get meeting details API

The meeting details API enables your app to get a meeting's static metadata. The metadata provides data points that don't change dynamically. The API is available through the Teams SDK. Both private scheduled or recurring meetings and channel scheduled or recurring meetings support API with different RSC permissions respectively.

The meeting details API must have a bot registration and bot ID. To use the meeting details API, you must obtain different RSC permission based on the scope of any meeting, such as private meeting or channel meeting.

Use getMeetingDetailsVerbose for one-to-one calling extensibility

The getMeetingDetailsVerbose function extends the functionality of the getMeetingDetails API to enable Public Switched Telephone Network (PSTN) and Teams-to-Teams calls for personal tab apps. It returns the IMeetingDetailsResponse interface with additional call details.

For more information, see build tabs for calling.

Prerequisites

• To use the meeting details API, you must obtain different RSC permission based on the scope of any meeting, such as private meeting or channel meeting.

• To enable calling, ensure that you've obtained the OnlineMeetingParticipant.Read.Chat RSC permission.

• Teams JS SDK required: TeamsJS SDK release latest release.

"webApplicationInfo": {
    "id": "<bot id>",
    "resource": "https://RscPermission",
},
"authorization": {
    "permissions": {
        "resourceSpecific": [
            {
                "name": "OnlineMeeting.ReadBasic.Chat",
                "type": "Application"
            }
        ]
    }
}

"webApplicationInfo": {
    "id": "<bot id>",
    "resource": "https://RscPermission",
},
"authorization": {
    "permissions": {
        "resourceSpecific": [
            {
                "name": "ChannelMeeting.ReadBasic.Group",
                "type": "Application"
            }
        ]
    }
}

"webApplicationInfo": {
    "id": "<bot id>",
    "resource": "https://RscPermission",
    "applicationPermissions": [
      "OnlineMeeting.ReadBasic.Chat"
    ]
}

"webApplicationInfo": {
    "id": "<bot id>",
    "resource": "https://RscPermission",
    "applicationPermissions": [
      "ChannelMeeting.ReadBasic.Group"
    ]
}

Query parameter

The following table lists the query parameter:

Example

app.OnMessage(async (context, cancellationToken) =>
{
    var meetingId = context.Activity.ChannelData?.Meeting?.Id;

    if (meetingId != null)
    {
        // Gets the information for the given meeting id.
        var meetingInfo = await context.Api.Meetings.GetByIdAsync(meetingId);

        // Sends a message activity to the sender of the incoming activity.
        await context.Send(JsonConvert.SerializeObject(meetingInfo), cancellationToken);
    }
});

app.on('message', async ({ activity, api, send }) => {
  const meetingId = activity.channelData?.meeting?.id;

  if (meetingId) {
    // Gets the information for the given meeting id.
    const details = await api.meetings.getById(meetingId);
    await send(JSON.stringify(details, null, 2));
  }
});

@app.on_message
async def handle_message(ctx: ActivityContext[MessageActivity]):
    meeting_id = ctx.activity.channel_data.meeting.id

    if meeting_id:
        # Gets the information for the given meeting id.
        meeting_info = await ctx.api.meetings.get_by_id(meeting_id)
        await ctx.send(str(meeting_info))

GET /v1/meetings/{meetingId}

In case of recurring meeting type:

startDate: Specifies the date to start applying the pattern. The value of startDate must correspond to the date value of the start property on the event resource. The first occurrence of the meeting might not occur on this date if it doesn't fit the pattern.

endDate: Specifies the date to stop applying the pattern. The last occurrence of the meeting might not occur on this date if it doesn't fit the pattern.

Send real-time captions API

The send real-time captions API exposes a POST endpoint for Teams communication access real-time translation (CART) captions, human-typed closed captions. Text content sent to this endpoint appears to end users in a Teams meeting when they have captions enabled.

CART URL

You can get the CART URL for the POST endpoint from the Meeting options page in a Teams meeting. For more information, see CART captions in a Microsoft Teams meeting. You don't need to modify the CART URL to use CART captions.

Query Parameter

The CART URL includes the following query parameters:

Example

https://api.captions.office.microsoft.com/cartcaption?meetingid=%7b%22tId%22%3a%2272f234bf-86f1-41af-91ab-2d7cd0321b47%22%2c%22oId%22%3a%22e071f268-4241-47f8-8cf3-fc6b84437f23%22%2c%22thId%22%3a%2219%3ameeting_NzJiMjNkMGQtYzk3NS00ZDI1LWJjN2QtMDgyODVhZmI3NzJj%40thread.v2%22%2c%22mId%22%3a%220%22%7d&token=gjs44ra

Method

Example

POST /cartcaption?meetingid=04751eac-30e6-47d9-9c3f-0b4ebe8e30d9&token=04751eac&lang=en-us HTTP/1.1
Host: api.captions.office.microsoft.com
Content-Type: text/plain
Content-Length: 22
Hello I'm Cortana, welcome to my meeting.

Error codes

The following table provides the error codes:

Receive real-time Teams meeting events

You can receive real-time meeting events such as meeting start and end or participant join and leave events.

Receive meeting start and end events

The user can receive real-time meeting events. As soon as any app is associated with a meeting, the actual meeting start and end time are shared with the bot. The actual start and end time of a meeting are different from scheduled start and end time. The meeting details API provides the scheduled start and end time. The event provides the actual start and end time.

If the ChannelMeeting.ReadBasic.Group and OnlineMeeting.ReadBasic.Chat permissions are added in the manifest, the bot automatically starts receiving the meeting start or end events for the scheduled and channel meeting types.

Prerequisite

Your app manifest must have the webApplicationInfo property to receive the meeting start and end events. Use the following examples to configure your manifest:

"webApplicationInfo": {
    "id": "<bot id>",
    "resource": "https://RscPermission",
    }
"authorization": {
    "permissions": {
        "resourceSpecific": [
            {
                "name": "OnlineMeeting.ReadBasic.Chat",
                "type": "Application"
            },
            {
                "name": "ChannelMeeting.ReadBasic.Group",
                "type": "Application"
            }
        ]    
    }
}

"webApplicationInfo": {
    "id": "<bot id>",
    "resource": "https://RscPermission",
    "applicationPermissions": [
      "OnlineMeeting.ReadBasic.Chat",
      "ChannelMeeting.ReadBasic.Group"
    ]
}

Example of getting meeting start or end events

The bot receives the meeting start and meeting end events through the OnTeamsMeetingStartAsync and OnTeamsMeetingEndAsync handlers. The information related to the meeting event is part of the MeetingStartEventDetails object, which includes the metadata fields such as, meetingType, title, id, joinUrl, startTime, and EndTime.

The following examples show how to capture the meeting start and end events:

Meeting Start Event

• SDK reference
• Sample code reference

// Register meeting start handler
teamsApp.OnMeetingStart(async (context, cancellationToken) =>
{
    var activity = context.Activity.Value;
    var card = new AdaptiveCard
    {
        Schema = "http://adaptivecards.io/schemas/adaptive-card.json",
        Body = new List<CardElement>
        {
            new TextBlock("The meeting has started.")
            {
                Wrap = true,
                Weight = TextWeight.Bolder,
                Size = TextSize.Large
            },
            new TextBlock($"**Title:** {activity.Title}")
            {
                Wrap = true
            },
            new TextBlock($"**Start Time:** {activity.StartTime}")
            {
                Wrap = true
            }
        },
        Actions = new List<Microsoft.Teams.Cards.Action>
        {
            new OpenUrlAction(activity.JoinUrl)
            {
                Title = "Join Meeting"
            }
        }
    };

    await context.Send(card, cancellationToken);
});

app.on('meetingStart', async ({ activity, send }) => {
  const value = activity.value;

  const card = new AdaptiveCard(
    new TextBlock('The meeting has started.', { weight: 'Bolder', size: 'Large', wrap: true }),
    new TextBlock(`**Title:** ${value.title || 'N/A'}`, { wrap: true }),
    new TextBlock(`**Start Time:** ${value.startTime || 'N/A'}`, { wrap: true })
  ).withActions(
    new OpenUrlAction(value.joinUrl, { title: 'Join Meeting' })
  );
  
  await send(card);
});

@app.on_meeting_start
async def handle_meeting_start(ctx: ActivityContext[MeetingStartEventActivity]) -> None:
    value = ctx.activity.value

    card = AdaptiveCard(
        body=[
            TextBlock(text="The meeting has started.", weight="Bolder", size="Large", wrap=True),
            TextBlock(text=f"**Title:** {value.title}", wrap=True),
            TextBlock(text=f"**Start Time:** {value.start_time}", wrap=True)
        ],
        actions=[OpenUrlAction(url=value.join_url, title="Join Meeting")],
    )
    await ctx.send(card)

// Register meeting end handler with transcript support
teamsApp.OnMeetingEnd(async context =>
{
    var activity = context.Activity.Value;
    var meetingId = context.Activity.ChannelData?.Meeting?.Id;
    
    // Get meeting info from API
    var meetingInfo = await context.Api.Meetings.GetByIdAsync(meetingId);

    // Retrieve the user ID of the organizer for the transcript API
    var userId = "";
    if (meetingInfo?.Organizer != null)
    {
        userId = meetingInfo.Organizer.AadObjectId ?? "";
    }

    // Get MS Graph Resource ID from meeting details
    var msGraphResourceId = meetingInfo?.Details?.MSGraphResourceId;

    // Wait 30 seconds for the transcript to become available
    await Task.Delay(30000);
    
    // Retrieve transcript
    var transcript = "";
    if (!string.IsNullOrEmpty(msGraphResourceId) && !string.IsNullOrEmpty(userId))
    {
        var vttTranscript = await GetMeetingTranscriptAsync(msGraphResourceId, userId);
        if (!string.IsNullOrEmpty(vttTranscript))
        {
            transcript = ParseVtt(vttTranscript);
        }
    }

    // Build card body with transcript
    var cardBody = new List<CardElement>
    {
        new TextBlock("The meeting has ended.")
        {
            Wrap = true,
            Weight = TextWeight.Bolder,
            Size = TextSize.Large
        },
        new TextBlock($"**End Time:** {activity.EndTime}")
        {
            Wrap = true
        },
        new TextBlock("**Transcript:**")
        {
            Wrap = true,
            Weight = TextWeight.Bolder
        }
    };

    // Add transcript lines or fallback message
    if (!string.IsNullOrEmpty(transcript))
    {
        var transcriptLines = transcript.Split('\n', StringSplitOptions.RemoveEmptyEntries);
        foreach (var line in transcriptLines)
        {
            if (!string.IsNullOrWhiteSpace(line))
            {
                cardBody.Add(new TextBlock(line) { Wrap = true });
            }
        }
    }
    else
    {
        cardBody.Add(new TextBlock("Transcript not available for this meeting.") { Wrap = true });
    }

    var card = new AdaptiveCard
    {
        Schema = "http://adaptivecards.io/schemas/adaptive-card.json",
        Body = cardBody
    };

    await context.Send(card);
});

app.on('meetingEnd', async ({ activity, api, send }) => {
  const value = activity.value;
  const meetingId = activity.channelData?.meeting?.id ?? '';
  if (!meetingId) {
    console.error('meetingEnd event received without a valid meeting id');
    return;
  }
  let msGraphResourceId = activity.channelData?.meeting?.details?.msGraphResourceId;
  const meetingInfo = await api.meetings.getById(meetingId);

  let userId = '';
  if (meetingInfo && meetingInfo.organizer) {
    userId = meetingInfo.organizer.aadObjectId || '';
  }

  if (!msGraphResourceId && meetingInfo && meetingInfo.details) {
    msGraphResourceId = meetingInfo.details.msGraphResourceId;
  }

  await new Promise(resolve => setTimeout(resolve, 30000));

  let transcript = '';
  if (msGraphResourceId) {
    for (let attempt = 1; attempt <= 3; attempt++) {
      const vttTranscript = await getMeetingTranscript(msGraphResourceId, userId);
      if (vttTranscript) {
        transcript = parseVtt(vttTranscript);
        break;
      }
      if (attempt < 3) {
        console.log(`Transcript not ready, retrying in 10s (attempt ${attempt}/3)...`);
        await new Promise(resolve => setTimeout(resolve, 10000));
      }
    }
  }

  const transcriptBlocks = transcript
    ? transcript.split('\n').filter(line => line).map(line => new TextBlock(line, { wrap: true }))
    : [new TextBlock('Transcript not available for this meeting.', { wrap: true })];

  const card = new AdaptiveCard(
    new TextBlock('The meeting has ended.', { weight: 'Bolder', size: 'Large', wrap: true }),
    new TextBlock(`**End Time:** ${value.endTime}`, { wrap: true }),
    new TextBlock('**Transcript:**', { weight: 'Bolder', wrap: true }),
    ...transcriptBlocks
  );

  await send(card);
});

@app.on_meeting_end
async def handle_meeting_end(ctx: ActivityContext[MeetingEndEventActivity]) -> None:
    value = ctx.activity.value
    meeting_id = ctx.activity.channel_data.meeting.id
    ms_graph_resource_id = getattr(ctx.activity.channel_data.meeting.details, 'ms_graph_resource_id', None)
    meeting_info = await ctx.api.meetings.get_by_id(meeting_id)

    # Retrieve the user ID of the organizer for the transcript API
    user_id = ""
    if meeting_info and meeting_info.organizer:
        user_id = getattr(meeting_info.organizer, 'aadObjectId', None) or ""

    if not ms_graph_resource_id and meeting_info and meeting_info.details:
        ms_graph_resource_id = meeting_info.details.ms_graph_resource_id

    transcript = ''
    if ms_graph_resource_id:
        vtt_transcript = await get_meeting_transcript(ms_graph_resource_id, user_id)
        if vtt_transcript:
            transcript = parse_vtt(vtt_transcript)

    transcript_blocks = (
        [TextBlock(text=line, wrap=True) for line in transcript.splitlines() if line]
        if transcript
        else [TextBlock(text="Transcript not available for this meeting.", wrap=True)]
    )
    card = AdaptiveCard(
        body=[
            TextBlock(text="The meeting has ended.", weight="Bolder", size="Large", wrap=True),
            TextBlock(text=f"**End Time:** {value.end_time}", wrap=True),
            TextBlock(text="**Transcript:**", weight="Bolder", wrap=True),
            *transcript_blocks,
        ],
    )
    await ctx.send(card)

{
  "name": " application/vnd.microsoft.meetingStart",
  "type": "event",
  "timestamp": "2023-02-23T19:34:07.478Z",
  "localTimestamp": "2023-02-23T11:34:07.478-8",
  "channelId": "msteams",
  "serviceUrl": "https://smba.trafficmanager.net/teams/",
  "from": {
    "id": "user_id"
  },
  "conversation": {
    "isGroup": true,
    "conversationType": "groupchat",
    "id": "conversation_id"
  },
  "recipient": {
    "id": "28:65f50003-e15d-434a-9e14-0fcfeb3d7817"
  },
  "value": {
    "id": "meeting_id",
    "joinUrl": "join_url",
    "title": "Example meeting",
    "meetingType": "Scheduled",
    "startTime": "2023-02-23T19:34:07.478Z"
  },
  "channelData": {
    "tenant": {
      "id": "tenant_id"
    }
  }
}

{
  "name": " application/vnd.microsoft.meetingEnd",
  "type": "event",
  "timestamp": "2023-02-23T19:34:07.478Z",
  "localTimestamp": "2023-02-23T11:34:07.478-8",
  "channelId": "msteams",
  "serviceUrl": "https://smba.trafficmanager.net/teams/",
  "from": {
    "id": "user_id"
  },
  "conversation": {
    "isGroup": true,
    "conversationType": "groupchat",
    "id": "conversation_id"
  },
  "recipient": {
    "id": "28:65f50003-e15d-434a-9e14-0fcfeb3d7817"
  },
  "value": {
    "id": "meeting_id",
    "joinUrl": "join_url",
    "title": "Example meeting",
    "meetingType": "Scheduled",
    "endTime": "2023-02-23T20:30:07.478Z"
  },
  "channelData": {
    "tenant": {
      "id": "tenant_id"
    }
  }
}

// Register meeting participant join handler
teamsApp.OnMeetingJoin(async context =>
{
    var activity = context.Activity.Value;
    if (string.IsNullOrEmpty(activity.Members[0].User?.AadObjectId)) return;

    var member = activity.Members[0].User.Name;
    var role = activity.Members[0].Meeting?.Role ?? "a participant";

    var card = new AdaptiveCard
    {
        Schema = "http://adaptivecards.io/schemas/adaptive-card.json",
        Body = new List<CardElement>
        {
            new TextBlock($"{member} has joined the meeting as {role}.")
            {
                Wrap = true,
                Weight = TextWeight.Bolder
            }
        }
    };

    await context.Send(card);
});

// Register meeting participant leave handler
teamsApp.OnMeetingLeave(async context =>
{
    var activity = context.Activity.Value;
    var member = activity.Members[0].User.Name;

    var card = new AdaptiveCard
    {
        Schema = "http://adaptivecards.io/schemas/adaptive-card.json",
        Body = new List<CardElement>
        {
            new TextBlock($"{member} has left the meeting.")
            {
                Wrap = true,
                Weight = TextWeight.Bolder
            }
        }
    };

    await context.Send(card);
});

app.on('meetingParticipantLeave', async ({ activity, send }) => {
  const meetingData = activity.value;
  const participant = meetingData.members[0];

  // Skip bot's own leave event (no aadObjectId)
  if (!participant.user?.aadObjectId) return;

  const member = participant.user.name || 'A participant';

  const card = new AdaptiveCard(
    new TextBlock(`${member} has left the meeting.`, {
      wrap: true,
      weight: 'Bolder'
    })
  );

  await send(card);
});

@app.on_meeting_participant_leave
async def handle_meeting_participant_leave(ctx: ActivityContext[MeetingParticipantLeaveEventActivity]):
    meeting_data = ctx.activity.value
    member = meeting_data.members[0].user.name

    card = AdaptiveCard(
        body=[
            TextBlock(
                text=f"{member} has left the meeting.",
                wrap=True,
                weight="Bolder",
            )
        ]
    )

    await ctx.send(card)

Following are the examples of the participant join and leave event payloads:

{ 

    "type": "event", 
    "name": "application/vnd.microsoft.meetingParticipantJoin",
    "timestamp": "2023-02-23T19:34:07.478Z", 
    "channelId": "msteams", 
    "serviceUrl": "https://smba.trafficmanager.net/amer/", 
    "from": { 
        "id": "29:id_xyz" 
    }, 
    "conversation": { 
        "isGroup": true, 
        "conversationType": "groupchat", 
        "id": "19:meeting_threadId@thread.v2" 
    }, 
    "recipient": { 
        "id": "28:botid" 
    },  
    "value": { 
       "members": [ 
       { 
        "user": { 
            "tenantId": "tenantid", 
            "objectId": "user_object_Id", 
            "id": "29:userId ", 
            "name": "Test User", 
            "aadObjectId": " user_object_Id " 
        },   
        "meeting": { 
            "inMeeting": true, 
            "role": "Organizer" //Attendee, Organizer, Presenter 
        },  
        }], 
    }, 
    "channelData": { 
        "tenant": { 
            "id": "tenantId" 
        }, 
        "meeting": { 
            "id": "encoded_meetingId" 
        } 
    } 
} 

{ 

    "type": "event", 
    "name": "application/vnd.microsoft.meetingParticipantLeave",
    "timestamp": "2023-02-23T19:34:07.478Z", 
    "channelId": "msteams", 
    "serviceUrl": "https://smba.trafficmanager.net/amer/", 
    "from": { 
        "id": "29:id_xyz" 
    }, 
    "conversation": { 
        "isGroup": true, 
        "conversationType": "groupchat", 
        "id": "19:meeting_threadId@thread.v2" 
    }, 
    "recipient": { 
        "id": "28:botid" 
    },  
    "value": { 
       "members": [ 
       { 
        "user": { 
            "tenantId": "tenantid", 
            "objectId": "user_object_Id", 
            "id": "29:userId ", 
            "name": "Test User", 
            "aadObjectId": " user_object_Id " 
        },   
        "meeting": { 
            "inMeeting": false
        },  
       }], 
    }, 
    "channelData": { 
        "tenant": { 
            "id": "tenantId" 
        }, 
        "meeting": { 
            "id": "encoded_meetingId" 
        } 
    } 
} 

Code sample

See also

• Teams SDK overview
• Teams SDK Meeting Events
• Teams SDK API Client
• Teams authentication flow for tabs
• Apps for Teams meetings
• Live Share SDK
• Teams cloud meeting recording
• Get the attendance report for an online meeting
• Build in-meeting notification for Teams meeting
• Get notifications for Teams meeting call updates
• Get participants presence API