Build for free

How to Record Meetings in Your App with an AI Meeting Bot

• 13 min read
Jump to section
Author: Winona Rajamohan
Winona Rajamohan
Tags:
Featured articles
Nylas Launches Notetaker API: Setting a New Standard for Embedded Meeting Intelligence
• 3 min read
Read more
Notetaker API
How to Record Meetings in Your App with an AI Meeting Bot
• 13 min read
Read more
Notetaker API
Integrating Nylas Notetaker into your meetings: a step-by-step guide for developers
• 8 min read
Read more
Jump to section

Key takeaways:

  • AI meeting bots capture recordings and transcripts from Zoom, Teams, and Meet, enabling searchable transcripts, summaries, or logs for SaaS tools in sales, healthcare, legal, or CRM/ATS.
  • Meeting bot APIs reduce engineering time for platform integrations, calendar syncing, and secure data infrastructure for compliance and permissions.
  • Building against meeting platforms is complex, requiring management of OAuth flows, inconsistent APIs, and custom bots for basic recording access.
  • Nylas Notetaker API simplifies meeting capture with calendar sync, webhook notifications, and SDK support, minimizing code and edge cases.

A survey of knowledge workers across North America, Europe, and Australia found that individual contributors are spending an average of 20% of their work week in meetings. This number rises to 35% for team leaders. 

The interactions captured during meetings are going to become non-negotiables. The same way that it’s almost unthinkable for a customer-driven organization to operate without a CRM, it’s becoming just as unrealistic to watch meeting data disappear into thin air after hitting the “Leave meeting” button.  

Building secure, reliable meeting data infrastructure is hard  — but that’s where an AI meeting bot API becomes a differentiator. AI meeting bots join virtual meetings automatically to record sessions and deliver accurate, diarized transcripts. But with an API, you get cross-platform compatibility and calendar integrations that help your meeting bots keep up with fluctuating schedules and recurring events. You can’t really ignore calendar invites if you’re thinking about scheduling a virtual meeting, right? 

In this guide, we’ll walk through the value of recording meetings in your app with an AI meeting bot API and step-by-step integration guide with real code examples to help you get started. 

Why use AI meeting bot APIs? 

Think about how many important things you can talk about in roughly 480 minutes a week. Here’s a question for product and engineering leaders: How much of that conversational value is currently being lost, and how much of that value can you reclaim to build software that meets the demand for more productive meetings? 

A single cross-platform AI meeting bot API helps you speed up development for features core to your product strategy: 

  1. Record meetings automatically: No need to build your own bot infrastructure or handle media streams. You can record meetings for your app by triggering a bot to join a meeting (ad hoc or scheduled) and get the recording file back. By syncing your meeting bot with calendar events if you need it (more on this in our step-by-step tutorial later).
  2. Get accurate transcripts: After a meeting, you’ll get a clean, speaker-labeled transcript you can use in post-meeting workflows. With an API for meeting transcriptions, you don’t have to manage your own speech-to-text engine or deal with platform-specific audio formats.
  3. Power AI-driven features: With structured, consistent data from every meeting, you can focus your team building proprietary AI models for features like contextual summaries, action items, and searchable conversation history.
  4. Scale with compliance built in: You don’t need to worry about platform permission models, user consent, or data retention policies. A good API partner handles that for you, so your team can stay focused on building.

What can you build with an AI meeting bot API? 

SaaS platforms today are under pressure to anticipate user needs, redesign user experiences, and adapt to new technologies fast. But building something truly different into your product takes more time, focus, and technical headroom than expected.

That’s why more builders are turning to APIs as accelerators. When you’re no longer weighed down by infrastructure, you have the bandwidth to challenge legacy software models and build something that moves the needle in our market. 

An AI meeting bot API like the Nylas Notetaker helps you embed conversational intelligence into the core of your product. Here’s what that looks like:

  • CRM platforms: Go beyond basic contact logs and static, transactional integrations across email, calendar, meeting platforms. Automatically attach video recordings, transcripts, and AI-powered insights to each account for more contextual customer history across all major touchpoints.
  • ATS platforms: Record and transcribe candidate interviews, extract key talking points, and surface hiring signals that can help move processes along faster.
  • Collaboration and productivity software: Capture every team conversation and generate summaries and action items that live where people already work.
  • Sales outreach and intelligence software: Analyze live customer calls to identify pain points, competitive mentions, and buying signals.
  • User research platforms: Automatically record research sessions and generate transcripts for proprietary intelligence models to find themes faster, share learnings, and increase user productivity.
  • Healthcare documentation tools: Solve the growing headache of medical documentation and electronic health record usability with features that compliantly record patient visits to auto-generate summaries, SOAP notes, and treatment plans.
  • Legal software: Record client calls, consultations, or virtual depositions in secure, standardized formats that ensure readability, traceability, and compliance. 

What are the developer advantages of using an AI meeting bot? 

A cross-platform AI meeting bot unlocks opportunities across the engineering org to become more efficient, build for impact, and ship developments faster. 

  • Scalability: Instead of maintaining separate SDKs for each platform, developers can use a single integration layer. The API handles core functionality — media ingestion, recording and transcription, speaker diarization, calendar sync, and webhook notifications — reducing backend complexity. This helps your infrastructure scale without repetitive engineering work or platform-specific logic.
  • Programmatic control: With full API access, your team controls when and how meeting bots are triggered. Whether it’s scheduled joins via calendar sync or ad-hoc sessions, you can define and automate meeting capture workflows without relying on end-user input or patchwork implementations. This creates reliable, reusable systems for capturing meeting data across your product.
  • Faster time-to-value for customers: Developers can spend less time building data infrastructure and more time delivering high-impact features — like searchable transcripts, meeting summaries, and in-app notes. Reducing build time accelerates your product roadmap and improves engineering ROI by focusing resources on the functionality users want and expect.

If you’re building a meeting software, there are three platforms that you can’t afford to ignore: Zoom, Microsoft Teams, and Google Meet. Supporting recording and transcription capabilities across these platforms keeps your product relevant and adaptable to meet users where they are. But integrating with each presents its unique set of challenges. 

Zoom

Zoom is the most widely used video conferencing platform, with over 300 million daily meeting participants. It offers APIs for meeting and recording management, but there are limitations:

  • Developers must manage OAuth token refresh cycles, build logic for recurring meetings, and handle meeting bot infrastructure themselves to access real-time media.
  • The API does not natively handle recording media ingestion, meaning developers need to deploy and maintain custom bots to capture recordings and transcripts.

Microsoft Teams

Teams is heavily used in enterprise environments where security and compliance are top priorities. Meeting recordings are subject to organizational policies and regulatory standards like HIPAA and GDPR. Developers working with the Microsoft Graph API face added challenges:

  • The Teams bot framework is primarily built for chat-based bots. This makes building a bot that can record meetings significantly more complex.
  • Some developers have reported unclear documentation, limited examples, and frequent permission and rate-limit errors.

Google Meet

Google Meet, part of the Google Workspace ecosystem, is used by over 300 million monthly users — and it’s tightly tied to Google Calendar, which has over 500 million users. It’s a major opportunity, but also difficult to work with:

  • The Meet API lacks native support for recording or retrieving media through a single integration.
  • There is no reliable mapping between Calendar events and Meet conference records. Developers often have to build fragile workarounds to correlate scheduled events with what actually happened, opening the door to a long list of things going wrong — like duplicate conference records, misaligned recurring events, and shared links that confuse record matching.

Step-by-Step: Integrating Notetaker for meeting recording

What does an AI meeting bot look like in action? Let’s use the Nylas Notetaker as an example. This API lets you build an AI meeting bot that joins meetings, records audio and video, while also providing accurate transcriptions. 

This tutorial will walk you through how to get started with integrating a meeting recorder in your application. Here’s what you’ll need: 

  • Nylas account & API credentials: If you don’t have one already, sign up for a Nylas developer account for free.
  • A meeting link: Have a Zoom, Google Meet, or other compatible meeting URL handy for testing.

Step 1: Set up your environment

1. In your development environment, set an environment variable for your Nylas API key — which you’ll obtain from the Nylas dashboard. 

Replace <YOUR_NYLAS_API_KEY> with the actual key from your Nylas dashboard. You’ll also reference your grantId (the connected account’s grant ID) in API calls. 

Set up your environment

# Set environment variables for reuse
export NYLAS_API_KEY="<YOUR_NYLAS_API_KEY>"

Step 2: Authenticate with the API

​​If you’re building an application where users connect their own accounts (e.g., Google, Microsoft), you’ll guide them through an OAuth 2.0 authentication flow. This process grants your application specific permissions and provides you with a grantId for that user. Follow the instructions in this guide to complete the authentication process or create a test grant in the Nylas dashboard.

You can also start an authorization request using the Nylas SDKs. 

Authenticate with the API

import "dotenv/config";
import express from "express";
import Nylas from "nylas";

const config = {
  clientId: process.env.NYLAS_CLIENT_ID,
  callbackUri: "http://localhost:3000/oauth/exchange",
  apiKey: process.env.NYLAS_API_KEY,
  apiUri: process.env.NYLAS_API_URI,
};

const nylas = new Nylas({
  apiKey: config.apiKey,
  apiUri: config.apiUri,
});

const app = express();
const port = 3000;

// Route to initialize authentication
app.get("/nylas/auth", (req, res) => {
  const authUrl = nylas.auth.urlForOAuth2({
    clientId: config.clientId,
    provider: "google",
    redirectUri: config.callbackUri,
    loginHint: "email_to_connect",
  });

  res.redirect(authUrl);
});

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Step 3: Create your first meeting bot!

With authentication sorted, you’re ready to create your AI meeting bot! You’ll send a POST request to the /v3/grants/<NYLAS_GRANT_ID>/notetakers endpoint. This tells Nylas to prepare a bot to join a specific meeting.

Create your first meeting bot

curl --request POST \
--url "https://api.us.nylas.com/v3/grants/<NYLAS_GRANT_ID>/notetakers" \
--header 'Accept: application/json, application/gzip' \
--header 'Authorization: Bearer <NYLAS_API_KEY>' \
--header 'Content-Type: application/json' \
--data '{
  "meeting_link": "<MEETING_URL>",
  "name": "Nylas Notetaker",
  "join_time": 1732657774,
  "meeting_settings": {
    "video_recording": true,
    "audio_recording": true, 
    "transcription": true
  }
}'

Step 4: Automate Recording

Creating bots manually is cool for testing, but the real power of an AI meeting bot comes from a smooth, automated process. Let’s explore two ways to have your bot automatically join future meetings:

a. Set up scheduled bots for specific meetings

If you know the details of a future meeting, you can schedule a Notetaker bot in advance. This is very similar to Step 3, but you’ll set the join_time to when that future meeting starts.

Make a POST request to /v3/grants/<NYLAS_GRANT_ID>/notetakers with the meeting details. The bot will then patiently wait and join at the specified join_time.

Set up scheduled bots for specific meetings

curl --request POST \
--url "https://api.us.nylas.com/v3/grants/<NYLAS_GRANT_ID>/notetakers" \
--header 'Accept: application/json, application/gzip' \
--header 'Authorization: Bearer <NYLAS_API_KEY>' \
--header 'Content-Type: application/json' \
--data '{
  "meeting_link": "<MEETING_URL>",
  "name": "Nylas Notetaker",
  "join_time": 1732657774,
  "meeting_settings": {
    "video_recording": true,
    "audio_recording": true,
    "transcription": true
  }
}'

b. By integrating your meeting bot with your calendar

For the best “set it and forget it” experience, you can configure Nylas to automatically send a Notetaker bot to meetings based on rules applied to a user’s calendar. This integration creates the most unified experience for end users. 

You’ll make a PUT request to update a specific calendar’s settings using the /v3/grants/<NYLAS_GRANT_ID>/calendars/<CALENDAR_ID> endpoint.

  • <CALENDAR_ID>: The ID of the calendar you want to apply these rules to. You can get calendar IDs using the Nylas Calendar API.

In the request body, you define the notetaker configuration, including rules like event_selection (e.g., “internal,” “external” meetings) and participant_filter (e.g., minimum/maximum number of attendees).

Integrating your meeting bot with your calendar

curl --request PUT \
--url 'https://api.us.nylas.com/v3/grants/<NYLAS_GRANT_ID>/calendars/<CALENDAR_ID>' \
--header 'Accept: application/json, application/gzip' \
--header 'Authorization: Bearer <NYLAS_API_KEY>' \
--header 'Content-Type: application/json' \
--data '{
  "notetaker": {
    "name": "My Notetaker",
    "meeting_settings": {
      "video_recording": true,
      "audio_recording": true,
      "transcription": true
    },
    "rules": {
      "event_selection": ["internal","external"],
      "participant_filter": {
        "participants_gte": 3,
        "participants_lte": 10
      }
    }
  }
}'

Step 5: Get meeting recordings and transcriptions

Once your bot has started capturing meeting recordings, it’s ready for you to take that conversational data and turn it into something better. You can make a make a GET request to fetch the media files directly on-demand:

Get meeting recordings and transcriptions

curl --request GET \
--url "https://api.us.nylas.com/v3/grants/<NYLAS_GRANT_ID>/notetakers/<NOTETAKER_ID>/media" \
--header 'Accept: application/json, application/gzip' \
--header 'Authorization: Bearer <NYLAS_API_KEY>'

Nylas responds with a link to the recording and a link to the transcript, if available. 

Important Note: These links are temporary and typically valid for up to an hour. If you need access later, you’ll have to make this API call again to get fresh links. For persistent storage, download the files.

You can also set up webhook notifications to automatically let you know when media files are ready! In your Nylas Dashboard, configure a webhook to listen for the notetaker.media event. Point it to an endpoint on your server that can receive POST requests.

When a recording and/or transcript is ready, Nylas will send a payload to your webhook URL similar to this:

Response

{
  "specversion": "1.0",
  "type": "notetaker.media",
  "source": "/nylas/notetaker",
  "id": "<WEBHOOK_ID>",
  "time": 1737500935555,
  "webhook_delivery_attempt": 0,
  "data": {
    "application_id": "<NYLAS_APPLICATION_ID>",
    "object": {
      "id": "<NOTETAKER_ID>",
      "object": "notetaker", 
      "state": "available",
      "media": {
        "recording": "<RECORDING_URL>",
        "transcript": "<TRANSCRIPT_URL>"
      }
    }
  }
}

5 best practices for integrating AI meeting bots

Let’s wrap up this guide with a few best to keep in mind as you build a product with an AI meeting bot. 

  1. Platform-specific permissions and user consent

Each platform handles permissions differently. For example, Zoom requires explicit consent from participants, requiring developers to build their own recording consent notification system for bots entering meetings. Managing platform-specific differences manually and incorrectly can quickly turn your product into a compliance risk. You need to always verify permissions before dispatching a bot and make it clear to users when and how recording is initiated. 

  1. Securely store recordings and manage access

Meeting recordings can contain sensitive or regulated information. Storing them improperly — or exposing them through public URLs — puts your product and users at risk. You’ll need to store recordings in secure storage (e.g., AWS S3) using signed URLs or access tokens and set clear expiration times and access controls to protect data integrity.

  1. Implement error handling and retry logic

Real-time systems like meeting bots can fail due to platform outages, invalid meeting links, or permissions issues. Without fallback logic, you risk losing valuable meeting data. It’s important to implement robust error handling with retry logic for bot joins, recording status, and transcription processing. Make sure to Log failures with enough context to troubleshoot quickly.

  1. Respect rate limits and test in staging environments

Most meeting APIs enforce rate limits, especially around meeting joins and media requests. Use sandbox environments and test accounts to simulate meeting joins and bot behavior. This will help you monitor rate limit headers and implement exponential backoff in high-volume applications.

  1. Automate with calendar syncs and webhook notifications

Meeting bots need to know when to join, and your app needs to know when a meeting is done, the transcript is ready, or the recording is available. Without real-time sync and notifications, your workflows break and your entire product experience becomes slow and tedious. By syncing meeting joins with calendar events and using webhooks, you can trigger downstream workflows as soon as recording or transcription is complete.

The Nylas Notetaker API helps you build with confidence

Building reliable, scalable meeting features shouldn’t mean managing platform quirks, compliance risks, or fragile infrastructure. The Nylas Notetaker API helps developers build and integrate AI meeting bots in the most productive and efficient way: 

✅ Platform-specific permissions: Built-in support for Zoom, Teams, and Google Meet permission models.

✅ Secure media delivery: Signed, time-limited URLs for recordings and transcripts keep sensitive data protected.

✅ Structured error handling: Clear API responses and webhooks make it easy to retry failed requests and handle edge cases.

✅ Calendar sync and real-time notifications: Bots auto-join at the right time, and your app gets updates when recordings and transcripts are ready.

Ready to get started?

Sign up for a free developer account and start building with Notetaker today
Start building

Related resources

Notetaker API
How to build an AI-powered meeting notes generator

Learn how to use AI to generate meeting notes with Nylas Notetaker APIs.

• 9 min read
Read more
Notetaker API
Integrating Nylas Notetaker into your meetings: a step-by-step guide for developers

Learn how to integrate Nylas Notetaker into your meetings in this step-by-step guide.

• 8 min read
Read more
Hero Banner - How to Integrate Gmail with Cursor
Email API
How to Integrate Gmail with Cursor

Learn how to build a gmail integration fast with Cursor Agent and Nylas APIs in this step-by-step guide—perfect for developers and small teams.

• 7 min read
Read more