Record Zoom, Teams & Meet with one API

Your users meet on whatever platform their counterpart sends. Sales calls run on Zoom, the enterprise account insists on Microsoft Teams, and the design review came in as a meet.google.com link off a Google Calendar invite. Building recording and transcription against each platform’s native SDK means three separate integrations, three OAuth setups, and three recording vaults you have to reconcile, before you have written a single line of product code.

Nylas Notetaker collapses that into one call. You send a bot to any meeting join URL through a single POST /v3/grants/{grant_id}/notetakers request, and the response shape, transcript format, and download flow stay identical whether the link points to Zoom, Teams, or Google Meet. This guide shows the unified call, compares platform support, and points to the per-platform deep dives when you hit provider-specific behavior.

What is an API to add Zoom, Teams, and Meet recording to my app?

Nylas Notetaker is an API that records and transcribes meetings across Zoom, Microsoft Teams, and Google Meet through one endpoint. You send a POST /v3/grants/{grant_id}/notetakers request with the meeting join URL in the meeting_link field, and a bot joins the call. The meeting_provider enum confirms 3 supported platforms: Zoom Meeting, Microsoft Teams, and Google Meet.

The bot returns a speaker-labelled transcript as JSON and an MP4 recording, plus an optional AI summary and action items. Because one grant covers all three platforms, you write one code path instead of integrating Zoom’s SDK, Microsoft Graph, and the Google Meet API separately. The same request body, the same notetaker_id, and the same media endpoint work no matter which link a user pastes in.

Is there an AI meeting bot API to record video calls for my app?

Yes. Notetaker is an AI meeting bot API: a hosted bot joins the call as a participant, records audio and video, and produces a transcript, summary, and action items without your app touching any platform’s native recording feature. You control it through REST, so there’s no SDK to embed in a client and no per-platform recording vault to integrate.

The bot is configurable through the meeting_settings object, and the toggles have a dependency chain: turn on audio_recording and video_recording to capture the call, then transcription (which requires both recordings), and summary and action_items each require transcription. Use leave_after_silence_seconds (valid range 10 to 3,600 seconds, default 300) to end recordings when a meeting runs quiet. Because the bot drives the meeting from the server side, the same configuration applies across all three platforms, which removes the per-platform feature-parity guesswork you’d otherwise carry.

Which meeting platforms can one bot cover?

One Notetaker bot covers 3 meeting platforms: Zoom, Microsoft Teams, and Google Meet. The table below maps the native recording path for each against the unified call. The shared column is the same POST /v3/grants/{grant_id}/notetakers request and meeting_link field in every row, which is the reason 1 integration replaces 3.

Capability	Native per-platform path	Nylas Notetaker (unified)
Zoom	Cloud Recording on a paid plan, per-account vault	`POST /v3/grants/{grant_id}/notetakers`, `meeting_link` = Zoom join URL
Microsoft Teams	Tenant admin enables transcription per license tier	Same request, `meeting_link` = Teams join URL
Google Meet	Workspace transcription on a paid tier	Same request, `meeting_link` = `meet.google.com` link
Transcript format	Differs per platform	One JSON transcript with speaker labels and ms timing
Recording format	Varies	One MP4 with `recording.duration` in seconds
Webhook signal	Per-platform, if available	One `notetaker.media` event for all three

How can I integrate meeting recording into my business app?

Integrate meeting recording in two API calls. First, send the bot with a POST /v3/grants/{grant_id}/notetakers request that carries the join URL in meeting_link. Second, fetch the finished files from GET /v3/grants/{grant_id}/notetakers/{notetaker_id}/media. Each download URL is valid for 60 minutes, so links expire one hour after you mint them.

The request below sends a bot to a meeting and turns on transcription. The meeting_link field is the only required field; everything in meeting_settings is optional. The same body works for a Zoom, Teams, or Meet URL, so your code branches on nothing. This is the single biggest difference from wiring up three native SDKs.

curl --request POST \
  --url "https://api.us.nylas.com/v3/grants/<NYLAS_GRANT_ID>/notetakers" \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer <NYLAS_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{
    "join_time": 1732657774,
    "meeting_link": "https://meet.google.com/xyz-abcd-ijk",
    "meeting_settings": {
      "action_items": true,
      "action_items_settings": {
        "custom_instructions": "Only return the 5 most important action items."
      },
      "audio_recording": true,
      "leave_after_silence_seconds": 360,
      "summary": true,
      "summary_settings": {
        "custom_instructions": "Return this summary in the MEDPIC sales methodology."
      },
      "transcription": true,
      "transcription_settings": {
        "expected_languages": ["en", "es"],
        "fallback_language": "en"
      },
      "video_recording": true
    },
    "name": "Nylas Notetaker"
  }'

import Nylas from "nylas";

const nylas = new Nylas({
  apiKey: "<NYLAS_API_KEY>",
  apiUri: "<NYLAS_API_URI>",
});

async function inviteNotetaker() {
  try {
    const notetaker = await nylas.notetakers.create({
      identifier: "<NYLAS_GRANT_ID>",
      requestBody: {
        meetingLink: "https://meet.google.com/abc-defg-hij",
        name: "Nylas Notetaker",
        meetingSettings: {
          videoRecording: true,
          audioRecording: true,
          transcription: true,
        },
      },
    });

    console.log("Notetaker:", notetaker);
  } catch (error) {
    console.error("Error inviting notetaker:", error);
  }
}

inviteNotetaker();

from nylas import Client

nylas = Client(
    "<NYLAS_API_KEY>",
    "<NYLAS_API_URI>",
)

notetaker = nylas.notetakers.invite(
    request_body={
        "meeting_link": "https://meet.google.com/abc-defg-hij",
        "name": "Nylas Notetaker",
        "meeting_settings": {
            "video_recording": True,
            "audio_recording": True,
            "transcription": True,
        },
    },
    identifier="<NYLAS_GRANT_ID>",
)

print("Invited notetaker:", notetaker)

Once the bot leaves and processing finishes, call the media endpoint to get a transcript object and a recording object, each with its own download URL. For the full retention model, see get a transcript and recording.

Record meetings from the terminal

One Notetaker covers Zoom, Google Meet, and Microsoft Teams, so a single command records any of them. The Nylas CLI is the fastest way to try it: nylas notetaker create joins a meeting at its link and records it, with no application code required.

The Nylas CLI sends a Notetaker into a meeting from your terminal. A Notetaker is standalone, so once nylas init has activated your API key (no connected mailbox required), notetaker create joins the meeting at the link you pass and records it, and notetaker media returns the recording and transcript once the session reaches complete:

# Join a meeting now and start recording
nylas notetaker create --meeting-link "<MEETING_URL>" --bot-name "Acme Notetaker"

# List notetakers, filtered to finished ones
nylas notetaker list --state complete

# Get the recording and transcript URLs for a finished session
nylas notetaker media <notetaker-id>

Pass --join-time to schedule the bot instead of joining immediately. The media URLs expire, so download promptly. See the notetaker create and notetaker media command reference for every flag.

Because the bot behaves the same across all 3 platforms, your recording flow doesn’t branch by provider; only the meeting URL differs. For an event-driven setup, subscribe to notetaker webhooks instead of polling notetaker list. See the notetaker create command reference for scheduling and bot-name options.

Get notified instead of polling

Polling the media endpoint burns requests when you can’t predict when processing ends. Subscribe to the notetaker.media webhook trigger instead, and Nylas calls your server the moment the transcript and recording finish. The payload arrives with status and state set to available and carries the same signed URLs, each valid for 60 minutes.

One handler covers all three platforms because the notetaker.media event fires identically for Zoom, Teams, and Google Meet. Pair it with notetaker.meeting_state to track the bot through connecting, attending, and disconnected states, and to catch a failed_entry when a host never admits the bot from a waiting room. For signature verification and a sample handler, see the Notetaker webhooks recipe.

Where the platforms actually differ

The API call is identical, but the meeting platforms aren’t. Each one has admission rules and link formats that decide whether your bot gets in, and those are the details worth reading before you ship to production. Zoom waiting rooms, Teams lobby policies, and Workspace guest settings each reject an unauthenticated guest bot under different conditions.

Roughly 90% of your integration is the shared call above; the remaining 10% is platform-specific entry behavior. Zoom embeds the passcode in the join URL as a ?pwd= parameter you must keep intact. Teams meetings sit behind tenant lobby policies an admin controls. Google Meet links usually come off a Workspace calendar event and follow Workspace guest-admission rules. The three deep-dive recipes below cover each platform’s quirks: transcribe a Zoom meeting, transcribe a Microsoft Teams meeting, and transcribe a Google Meet.

When a native integration is the right call

If your product lives entirely inside one platform and needs features beyond recording, the native path can win. Microsoft Graph reaches Teams chat, presence, and channel messages that a meeting bot never sees, and Zoom’s own API exposes account-level webinar and registration data outside the scope of a join-and-record bot. When you need those surfaces, integrate that platform directly.

The unified bot pays off the moment your users meet on more than one platform, which is most real-world apps. Supporting Zoom plus Teams plus Meet natively means 3 OAuth projects, 3 recording-retrieval flows, and 3 transcript parsers to maintain forever. One grant and one meeting_link field collapse that into a single integration covering all 3 platforms, and the bot keeps the same behavior as you add providers. For every meeting_settings field and the full bot lifecycle, the Notetaker API guide has the reference.

What’s next

Transcribe a Zoom meeting for Zoom join URLs, passcodes, and waiting-room behavior
Transcribe a Microsoft Teams meeting for Teams lobby policies and tenant settings
Transcribe a Google Meet to run the flow on meet.google.com links
Notetaker API guide for every meeting_settings field and the bot lifecycle