DEV Community 9h ago

Record and transcribe meetings with Nylas Notetaker

What Notetaker does

A Notetaker is a bot that joins a video meeting on your behalf and captures it. It works with the three meeting providers most teams use - Zoom, Google Meet, and Microsoft Teams - and from a single meeting link it can record video, record audio, generate a transcript, write a summary, and extract a list of action items. You don't run any of that infrastructure; you make a request with the meeting link and collect the results when the bot is done.

The model is refreshingly simple: a bot is a resource you create, track, and then pull media from. You create it pointed at a meeting, it moves through a series of states as it joins and records, and when it finishes you fetch the recording and transcript. Everything else - the joining, the capture, the transcription, the AI summary - happens on the Nylas side, so your integration is three or four API calls rather than a streaming-media stack.

Send a bot to a meeting

You create a Notetaker with a POST /v3/grants/{grant_id}/notetakers request, and the only required field is meeting_link, the invitation URL the bot joins. By default it joins immediately, or you can set join_time to a Unix timestamp to schedule the join for later, and a name field sets the bot's display name in the meeting, defaulting to "Nylas Notetaker."

curl --request POST \
  --url "https://api.us.nylas.com/v3/grants/<GRANT_ID>/notetakers" \
  --header "Authorization: Bearer <NYLAS_API_KEY>" \
  --header "Content-Type: application/json" \
  --data '{
    "meeting_link": "https://zoom.us/j/123456789",
    "name": "Meeting Recorder"
  }'

One thing to know about scheduling: if you pass a join_time in the past, the request returns an error rather than joining late, so for an immediate join just omit the field instead of sending the current time. The display name matters more than it seems, because it's what other participants see in the attendee list, so name it something that signals what it is rather than leaving the default. The response gives you the Notetaker's ID, which is the handle for everything that follows.

Create a bot from the CLI

The terminal command is nylas notetaker create, and it takes the same inputs as flags. Pass --meeting-link with the URL, optionally --join-time to schedule it, and --bot-name to set the display name. The join time accepts friendly values like tomorrow 9am or 30m, which is easier than computing a Unix timestamp for a quick test.

# Join a Google Meet immediately
nylas notetaker create --meeting-link "https://meet.google.com/abc-defg-hij"

# Schedule a bot to join a Zoom call later, with a custom name
nylas notetaker create --meeting-link "https://zoom.us/j/123" \
  --join-time "2024-01-15 14:00" --bot-name "Standup Recorder"

This is the fastest way to see Notetaker work: drop a real meeting link in, run the command, and watch the bot appear in your call within a few seconds. It's genuinely useful on its own, too - sending a recorder to a call you're about to join without opening a dashboard - but it's also how I sanity-check that a meeting link is valid before wiring the same call into an application.

Configure what the bot captures

The meeting_settings object controls what the bot does in the meeting, and every capability defaults to on. You get booleans for video_recording, audio_recording, transcription, summary, and action_items, so you can turn off what you don't need - an audio-only recording with no AI summary, say.

The dependencies stack, though, and they're the thing to get right: transcription requires both video_recording and audio_recording to be true, and summary and action_items in turn require transcription (and therefore the recordings) to be true. In other words the AI features build on the full recording, so you can keep a plain recording and drop the AI layer, but you can't get a transcript without recording the call.

curl --request POST \
  --url "https://api.us.nylas.com/v3/grants/<GRANT_ID>/notetakers" \
  --header "Authorization: Bearer <NYLAS_API_KEY>" \
  --header "Content-Type: application/json" \
  --data '{
    "meeting_link": "https://zoom.us/j/123456789",
    "meeting_settings": {
      "transcription": true,
      "summary": true,
      "action_items": true,
      "leave_after_silence_seconds": 600
    }
  }'

Two settings are worth calling out. The action_items_settings.custom_instructions field lets you steer the AI with a prompt like "Only return the five most important action items," so the list matches how your team works rather than a generic extraction. And leave_after_silence_seconds, which defaults to 300 and accepts 10 to 3,600, tells the bot to leave once the call goes quiet for that long, which cleanly ends a recording when everyone's talking has stopped but nobody hung up the call.

Track the bot through its states

A Notetaker moves through a defined lifecycle from creation to finished media, and watching where it is tells you when the recording is ready. It starts scheduled or connecting as it joins, may sit in a waiting room before it's admitted, becomes attending once it's in and recording, and after the meeting ends it processes the captured media and then makes it available to fetch. The failure cases exist too, so handle a bot that couldn't get into the meeting or whose media processing errored, along with the cleanup state for media that's been removed.

You track progress one of two ways: poll the Notetaker with a GET on its ID and read its state, or filter the list endpoint with the state query parameter to find, say, every bot currently attending. One wrinkle worth knowing is that the exact state tokens differ slightly between the list filter and the object the GET returns, so don't hardcode a single spelling against both; key off the documented values for whichever call you make. The signal you ultimately wait for is the media being ready, which the next section covers, because that's when the recording and transcript become downloadable.

From the CLI, nylas notetaker list --state attending and nylas notetaker show <id> give you the same view.

Get the recording and transcript

You fetch a Notetaker's output from the GET /v3/grants/{grant_id}/notetakers/{notetaker_id}/media endpoint, which returns the recording and transcript as downloadable files, each with a name, a size in bytes, and a URL. The endpoint only returns files once the media is ready: while it's still processing you get a 404, and once it's deleted past the retention window you get a 410.

Two separate clocks apply here, and conflating them is a common mistake. Each download URL is a pre-authenticated link valid for 60 minutes from when it's generated; after that it expires, and you call the media endpoint again to mint a fresh one. The files themselves carry expires_at and ttl fields that mark the file's retention period - up to 14 days - after which Nylas permanently deletes the file.

nylas notetaker media <notetaker-id>

Because both the URLs and the files are short-lived, the right pattern is to download as soon as the media is ready and pull the files into your own storage, rather than relying on the 14-day retention. From there, the transcript feeds search or a model, and the recording goes wherever you keep meeting archives.

If you need to end a live recording before the meeting naturally wraps, nylas notetaker leave <id> instructs the bot to leave, which stops the recording and triggers media generation while keeping the Notetaker record - distinct from nylas notetaker delete, which cancels a scheduled or active bot and removes it.

Standalone bots, no grant required

Here's the feature that makes Notetaker unusually flexible: it has a standalone mode. The grant-scoped endpoints above attach a bot to a connected account, but the /v3/notetakers endpoints let you send a bot to a meeting without any grant at all. That means a user who has never authenticated with your application - never connected a calendar or mailbox - can still have a Notetaker join their meeting.

This matters for products where meeting capture is the whole feature and account connection would be friction. A "paste a meeting link, get a transcript" tool doesn't need the user's Google account; it needs a bot in the meeting, and standalone Notetakers give you exactly that.

The standalone endpoints mirror the grant-scoped ones - create, list, get, media, leave, and cancel - so the flow is identical apart from dropping the grant from the path. You choose per use case: grant-scoped when the bot belongs to a connected user, standalone when anyone should be able to record a call.

Where Notetaker fits

The same create-track-fetch flow sits under a range of meeting features, and the difference is mostly what you do with the transcript. A few that map straight on:

Automated meeting notes. Send a bot to every meeting on a calendar and store the summary and action items, so notes write themselves.
A paste-a-link transcription tool. A standalone bot turns any meeting URL into a transcript with no account connection - the whole product in one endpoint.
Sales call analysis. Capture the transcript of each call and feed it to a model for coaching, objection tracking, or CRM notes.
Searchable meeting archive. Store transcripts in your own index so a team can search what was said across every recorded call.

Each is the same handful of calls: create the bot, wait for the media to be ready, fetch it - with the value living in what you do with the output.

Things to keep in mind

A short list of details keeps Notetaker predictable.

Only meeting_link is required. Omit join_time to join immediately; a past join_time returns an error.
AI features need the recording. summary and action_items require video_recording, audio_recording, and transcription all set to true.
Wait until the media is ready. The media endpoint returns a 404 while still processing and the files once they're ready; poll the Notetaker or filter the list by state to know when.
Two media clocks. Download URLs expire after 60 minutes (re-call the media endpoint to regenerate), while expires_at / ttl mark the file's retention of up to 14 days; download promptly rather than storing a stale link.
leave and delete differ. leave ends a live recording and keeps the media; delete cancels the bot and removes it.
Standalone needs no grant. Use /v3/notetakers when the user hasn't connected an account and you just need a bot in the meeting.

Wrapping up

Notetaker turns meeting capture into a few API calls. Create a bot with a meeting_link (and optional join_time, name, and meeting_settings), or run nylas notetaker create, and it joins your Zoom, Google Meet, or Teams call to record and transcribe. Track it until its media is ready, then fetch the recording and transcript from the media endpoint, mindful that the download URLs expire after 60 minutes and the files after a 14-day retention window. Tune what it captures with meeting_settings, including a custom prompt for action items, and reach for standalone bots when there's no connected account to attach to. The infrastructure - joining, recording, transcription, and AI summary - is handled, so what's left is deciding what to do with the output.

Where to go next

Notetaker - the full guide to bots, settings, and media
Notetaker API reference - create, list, media, leave, and cancel endpoints
Standalone Notetaker - the no-grant endpoints
Nylas CLI notetaker commands - nylas notetaker create, list, and media

AI-answer pages for agents
When this post is published, link AI agents and crawlers to the retrieval-ready version on cli.nylas.com:

Topic runbook: https://cli.nylas.com/ai-answers/notetaker-api-for-zoom-google-meet-teams.md
Industry playbooks hub: https://cli.nylas.com/ai-answers/agent-account-industry-playbooks.md

Building meeting recording yourself is a project: a bot that joins Zoom or Google Meet, captures the audio and video, runs it through transcription, then summarizes the result and pulls out action items. That's a media pipeline, a transcription service, and a bot framework before you've shipped anything. Nylas Notetaker collapses all of it into an API call. You send a bot to a meeting link, and it joins, records, transcribes, and hands you back the recording, transcript, summary, and action items. This post drives the whole flow with the API and the CLI. It's a worked use case rather than an endpoint tour, covering Notetaker from two angles: the HTTP API your backend calls and the nylas CLI for sending a bot from the terminal. I work on the CLI, so the commands below are the ones I reach for when I want to record a call right now. What Notetaker does A Notetaker is a bot that joins a video meeting on your behalf and captures it. It works with the three meeting providers most teams use, Zoom, Google Meet, and Microsoft Teams, and from a single meeting link it can record video, record audio, generate a transcript, write a summary, and extract a list of action items. You don't run any of that infrastructure; you make a request with the meeting link and collect the results when the bot is done. The model is refreshingly simple: a bot is a resource you create, track, and then pull media from. You create it pointed at a meetin

Read on DEV Community ↗ ← Back to News