# Record Zoom, Teams & Meet with one API

Source: https://developer.nylas.com/docs/cookbook/notetaker/record-zoom-teams-meet/

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.

```bash
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"
  }'

```

```js [recordMeeting-Node.js SDK]

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();


```

```python [recordMeeting-Python SDK]

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](/docs/cookbook/notetaker/get-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](https://cli.nylas.com/docs/commands) 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`:

```bash
# 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`](https://cli.nylas.com/docs/commands/notetaker-create) and [`notetaker media`](https://cli.nylas.com/docs/commands/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`](https://cli.nylas.com/docs/commands/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](/docs/cookbook/notetaker/notetaker-webhooks/).

## 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](/docs/cookbook/notetaker/transcribe-zoom-meeting/), [transcribe a Microsoft Teams meeting](/docs/cookbook/notetaker/transcribe-teams-meeting/), and [transcribe a Google Meet](/docs/cookbook/notetaker/transcribe-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](/docs/cookbook/notetaker/notetaker-api-guide/) has the reference.


> **Info:** 
> **New to Nylas?** Start with the [quickstart guide](/docs/v3/getting-started/) to set up your app and connect a test account before continuing here.


## What's next

- [Transcribe a Zoom meeting](/docs/cookbook/notetaker/transcribe-zoom-meeting/) for Zoom join URLs, passcodes, and waiting-room behavior
- [Transcribe a Microsoft Teams meeting](/docs/cookbook/notetaker/transcribe-teams-meeting/) for Teams lobby policies and tenant settings
- [Transcribe a Google Meet](/docs/cookbook/notetaker/transcribe-google-meet/) to run the flow on `meet.google.com` links
- [Notetaker API guide](/docs/cookbook/notetaker/notetaker-api-guide/) for every `meeting_settings` field and the bot lifecycle