How to Build a Microsoft Teams Meeting Bot [2025 Guide]

In the fast-paced world of remote collaboration, developers and SaaS builders are increasingly turning to AI-powered tools to automate meeting workflows. Microsoft Teams, with its robust enterprise features, is a staple for teams handling sales calls, project updates, and client demos. However, building a custom Microsoft Teams meeting bot—capable of joining calls, recording audio/video, and generating real-time transcriptions—can be a challenge using native Teams Graph API due to its complex permissions, WebRTC integrations, and OAuth flows. This is where a dedicated meeting bot API like Skribby shines, simplifying the process with a straightforward RESTful interface.

Skribby is the fastest meeting bot API for developers, designed to help you build AI notetakers and meeting bots across Microsoft Teams, Zoom, and Google Meet in minutes. In this 2025 guide, we'll walk through a step-by-step tutorial on integrating Skribby's developer API to create a Teams meeting bot. You'll learn how to authenticate, create bots, manage recordings and transcriptions, and handle real-time updates—all without getting bogged down in Teams-specific complexities. By the end, you'll have a working Teams bot ready for your SaaS product, emphasizing efficiency and scalability.

Prerequisites for Building Your Teams Meeting Bot

Before diving into the code, ensure you have the basics set up. Skribby's API requires a developer account, which you can create via GitHub or Google login. Once signed up, head to the Dashboard to generate an API key for bearer authentication. This key handles all secure requests to endpoints like creating or managing bots.

For Microsoft Teams integration, Skribby supports joining via the "teams" service. You'll need:

• A valid Teams meeting URL (e.g., from a scheduled event).
• Optional: An authenticated account ID for private or restricted meetings. Create this in the Settings under authenticated accounts, linking your Teams credentials to bypass guest join limitations.
• Familiarity with HTTP clients like curl, Postman, or your preferred language's library (e.g., Axios in Node.js).

Skribby's usage-based pricing is minute-focused: recordings and transcriptions bill per active minute, with routes tracking minutes.used and Stripe integration for billing. Check your Billing page for model-specific costs—transcription models like Whisper or Deepgram vary in price and features.

No deep Teams Graph API knowledge is needed; Skribby abstracts the heavy lifting, letting you focus on your app's logic.

Step 1: Creating a Microsoft Teams Meeting Bot with Skribby API

The core of your Teams bot starts with the POST /bot endpoint. This creates a new bot instance that joins the meeting, records audio (and optionally video), and transcribes using your chosen model. Skribby supports multiple transcription models, including "whisper", "deepgram", "assembly-ai", and real-time options like "deepgram-realtime".

Here's how to set it up:

1. Prepare Your Request Body: Include the required fields for Teams. The service must be "teams", and provide the meeting_url directly from your Teams invite.

   Example using curl (adapt for your language):

   curl -X POST https://api.skribby.io/v1/bot \
     -H "Authorization: Bearer YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
       "transcription_model": "whisper",
       "service": "teams",
       "meeting_url": "https://teams.microsoft.com/l/meetup-join/...",
       "bot_name": "My Teams AI Notetaker",
       "lang": "en",
       "video": false,
       "webhook_url": "https://yourapp.com/webhooks/skribby-updates",
       "profanity_filter": true,
       "authentication": {
         "account_id": "your-teams-account-id",
         "always_authenticate": false
       },
       "stop_options": {
         "time_limit": 60,
         "waiting_room_timeout": 5,
         "last_person_detection": 2,
         "silence_detection": 3
       },
       "custom_vocabulary": ["Skribby", "API", "Teams bot"]
     }'
   

   • transcription_model: Choose from enums like "whisper" (accurate, batch) or "deepgram-realtime" (for live transcription). Refer to billing for availability.
   • service: Set to "teams" for Microsoft Teams.
   • meeting_url: The direct Teams link; bots join as guests by default.
   • bot_name: Custom name visible in the meeting (e.g., "AI Assistant").
   • authentication: For private Teams meetings, use account_id from your dashboard. Set always_authenticate: true to force login.
   • stop_options: Control bot lifecycle—e.g., time_limit caps at 240 minutes; waiting_room_timeout beyond 10 minutes incurs extra charges.
   • custom_vocabulary: Boosts accuracy for domain-specific terms (model-dependent).

2. Handle the Response: On success (200), you'll get a JSON object with the bot's id, initial status (e.g., "booting" or "joining"), and details like websocket_url for real-time models.

   {
     "id": "3c09b2aa-6708-42c1-8145-aa55ee223613",
     "status": "joining",
     "service": "teams",
     "bot_name": "My Teams AI Notetaker",
     "meeting_url": "https://teams.microsoft.com/l/meetup-join/...",
     "webhook_url": "https://yourapp.com/webhooks/skribby-updates",
     "recording_url": null,
     "transcript": [],
     "participants": [],
     "created_at": "2025-01-15T10:00:00Z"
   }
   

   If the bot hits "not_admitted" or "auth_required", check authentication settings. Errors like 400 (invalid model) or 401 (unauthenticated) will include messages for debugging.

Your bot is now live in the Teams meeting, recording and transcribing in the background.

Step 2: Monitoring and Managing Your Teams Bot

Once created, use the GET /bot/{id} endpoint to retrieve real-time status, participants, and partial transcripts. This is crucial for building dashboards or notifications in your app.

Example curl:

curl -X GET "https://api.skribby.io/v1/bot/3c09b2aa-6708-42c1-8145-aa55ee223613?with-speaker-events=true" \
  -H "Authorization: Bearer YOUR_API_KEY"

Key response fields for Teams bots:

• status: Tracks lifecycle—"recording", "transcribing", "finished", or errors like "invalid_credentials".
• participants: Array of attendees with name, avatar, first_seen_at, and optional speaker events (e.g., "started-speaking" timestamps).
• transcript: Array of segments with start, end, speaker (ID), speaker_name (diarization-supported), confidence, and transcript text. For uncertain speakers, potential_speaker_names provides matches with confidence scores.
• events: Lifecycle logs, like status changes from "joining" to "recording".
• recording_url: Download link post-meeting (available until recording_available_until; default 1 week, extendable to 1 year via store_recording_for_1_year).
• websocket_url: For real-time transcription (e.g., with Deepgram-realtime), connect via WebSocket for live events. Use websocket_read_only_url for frontend-safe access.

Webhooks at your webhook_url will POST updates on status changes, participant joins, or transcription progress—ideal for integrating with your backend.

To end a session early, use POST /bot/{id}/stop:

curl -X POST https://api.skribby.io/v1/bot/3c09b2aa-6708-42c1-8145-aa55ee223613/stop \
  -H "Authorization: Bearer YOUR_API_KEY"

Response: {"message": "Meeting bot is shutting down."}. The bot leaves, processes the recording, and finalizes the transcript. Only works if status is "joining" or "recording"; otherwise, 403 error.

Step 3: Handling Transcriptions and Recordings in Your App

Post-meeting, poll the GET endpoint until status is "finished". Download the recording_url for audio/video (if video: true). Transcripts include timestamps, speaker diarization, and model-specific utterances.

For Teams-specific use cases, like sales coaching, parse transcripts to extract action items or integrate with CRM via speaker names. Skribby's profanity filter (if enabled) censors sensitive content, and detected language (detected_lang) auto-adjusts from conversation.

Monitor usage in the Billing section—minutes used include waiting room time beyond 10 minutes.

Why Skribby Simplifies Building Teams Meeting Bots for Developers

For developers and SaaS product builders, Skribby's API stands out by abstracting Teams' complexities like permission scopes and WebRTC. Unlike native Teams Graph API integrations, which require app registrations and ongoing token management, Skribby uses simple bearer auth and account IDs for seamless joins. This enables cross-platform bots (e.g., same code for Zoom or Meet), reducing development time from weeks to hours.

Key benefits:

• Efficiency: Create and manage bots with minimal endpoints; webhooks and WebSockets handle real-time without polling overload.
• Scalability: Organization and team management via dashboard; API keys per project.
• Cost-Effectiveness: Minute-based billing avoids flat fees—perfect for variable meeting loads.
• Reliability: Supports 15+ transcription models, with features like silence detection to avoid unnecessary charges.

In real-world scenarios, use this for AI notetakers: join a Teams sales call, transcribe, and summarize with external LLMs. It's developer-friendly, with API Documentation for full schemas.

Conclusion: Deploy Your Teams Bot Today

Building a Microsoft Teams meeting bot in 2025 doesn't have to involve wrestling with Graph API hurdles. With Skribby's meeting bot API, you can create, monitor, and manage bots for recordings, transcriptions, and real-time insights in just a few API calls. This tutorial equips you to integrate Teams support into your SaaS app, boosting productivity for users handling hybrid meetings.

Ready to try? Sign up for Skribby with GitHub or Google and deploy your first Teams bot in minutes. Check the Skribby dashboard to get started.

FAQ

What transcription models does Skribby support for Teams bots?

Skribby offers models like "whisper", "deepgram", "assembly-ai-realtime", and more. Availability and costs vary—check your billing page. Real-time models provide WebSocket access for live Teams transcription.

How does authentication work for private Teams meetings?

Use the authentication object with account_id (created in dashboard settings) and always_authenticate: true to force login. This handles Teams' private restrictions without manual OAuth.

Can I schedule a Teams bot to join at a specific time?

Yes, add scheduled_start_time as a Unix timestamp in the create request. The bot status will show "scheduled" until join time.

What happens if my Teams bot gets stuck in the waiting room?

Set stop_options.waiting_room_timeout (default 10 minutes free; extras charge per minute). If not admitted, status becomes "not_admitted"—retry with authentication or adjust timeout.