- Products
- Solutions
- Developers
- Resources ConnectThe developers API guide
Everything you need to know about building, purchasing and integrating with APIs.
Email API
Calendar API
Scheduler
ExtractAI
Notetaker API
Google email & calendar integration
Outlook email & calendar integration
IMAP integration
Calendar management
Embedded contextual email
Scheduling automation
Automated outreach
Intelligent data extraction
Expense management
Customer relationship management
Applicant tracking system
Communications platform
Marketplaces
Document management
Docs
SDKs
Tutorials
API status
Changelog
Support
Blog
Events
Guides
Inspiration gallery
Partners
Build vs. buy
Customer stories
Security & Compliance
Why Nylas
Newsroom
Jump to section
Jump to section
Introduction
In today’s fast-paced work, capturing meeting notes is challenging. Nylas Notetaker is a real-time meeting bot that joins your online meetings to record and transcribe.
In this guide, we’ll walk through how to integrate Nylas Notetaker into your meetings. Nylas Notetaker transcribes audio and records video from meetings, helping teams focus on the meeting’s objectives. Let’s go over how to get up and running step by step.
Prerequisites
Before you begin integrating Nylas Notetaker, make sure you have the following in place:
- Nylas Developer Account: Sign up for a Nylas developer account for free if you haven’t already. You’ll need access to the Nylas Dashboard to retrieve API credentials.
- Nylas API Key: From your Nylas dashboard, grab your API key.
- Connected User Account (Grant ID): The grant ID represents the authorized account that Notetaker will use to join meetings. You can create a test grant from the Nylas developer dashboard.
- Meeting Platform & Link: Have an online meeting link ready (e.g., a Google Meet, Microsoft Teams, or Zoom). Notetaker joins as a guest user, so someone might need to admit the bot into the meeting.
- Necessary Permissions: Ensure your Nylas application has the right scopes/permissions. For example to get started with inviting Nylas Notetaker to a Google meet we just need the required Google scopes to authenticate a user to receive a user grant Id. For calendar integrations, we will need read access to calendars or events if you plan to fetch meeting details (like the join URL) via the Nylas API.
With these prerequisites met, you’re ready to start adding the Notetaker into your meetings.
Setting Up Nylas Notetaker
The first step in using Nylas Notetaker is authenticating with the Nylas API and preparing to invite the Notetaker bot. Here’s how to set everything up:
1. Configure API Authentication: In your development environment, set an environment variable for your Nylas API key (obtained from the dashboard) and note your grantId (the connected account’s grant ID).
# Set environment variables for reuse
export NYLAS_API_KEY="<YOUR_NYLAS_API_KEY>"When making API calls to Nylas, include the API key in the Authorization header. For example, a basic test to list all Notetaker bots scheduled for your account (if any) can be done with a GET notetakers request:
curl --request GET "https://api.nylas.com/v3/grants/<GRANT_ID>/notetakers" \
--header 'Authorization: Bearer <NYLAS_API_KEY>'The Nylas API will use the grantId in the URL (<GRANT_ID>) to return all notetakers for that user. If everything is set up correctly, this call returns data (likely empty) of any existing Notetaker. It confirms that your API key and grant are valid.
If you haven’t obtained a grant ID yet, you’ll need to authorize a user through Nylas. This typically involves directing the user to Nylas’ hosted authentication page and obtaining an authorization code which you exchange for a grantId. For the purposes of this post, consider using the Nylas dashboard to create a test grant:
Once you have the grantId for the user’s account, you can proceed to invite a Notetaker on their behalf. At this point, with your API key and a grant ID, we can now move on to inviting the Notetaker to meetings.
(Optional) Create an event using Nylas Events API
This section is optional, and requires adding the relevant event scopes before creating the user grant. Let’s start off by using the Nylas Events API to create an event which we can invite a Nylas Notetaker to:
curl --request POST \
--url https://api.us.nylas.com/v3/grants/<GRANT_ID>/events?calendar_id=<CALENDAR_ID> \
--header 'Accept: application/json, application/gzip' \
--header 'Authorization: Bearer <NYLAS_API_KEY>' \
--header 'Content-Type: application/json' \
--data '{
"title": "Nylas Integration",
"busy": true,
"participants": [
{
"name": "Nyla",
"email": "[email protected]"
},
{
"name": "Ram",
"email": "[email protected]"
}
],
"description": "Come ready to talk Nylas!",
"when": {
"start_time": 1674604800,
"end_time": 1722382420,
},
# add config to autocreate a Google Meet link
"conferencing": {
"provider": "Google Meet",
"autocreate": {}
}
}' Creating an event will return the following relevant details, note the <MEETING_URL> that we will use in upcoming sections:
{
"request_id": "1",
"data": {
...event details...
"conferencing": {
"details": {
"meeting_code": "<MEETING_CODE>",
"url": "<MEETING_URL>"
},
"provider": "Google Meet"
},
...more event details...
}
}Adding Notetaker to a Meeting
Now for the fun part: inviting the Notetaker to a meeting. Nylas Notetaker can join meetings in two ways:
- On-demand (immediate join): You invite the Notetaker to an ongoing meeting without specifying a start time. The Notetaker will attempt to join right away.
- Scheduled join: You schedule the Notetaker to join a future meeting at a specified time by providing the meeting start time. Providing a time to join is optional.
In both cases, you will use the Nylas API to invite the Notetaker by creating a Notetaker instance for a given meeting. This is done via a POST request to the Notetaker endpoint.
Invite the Notetaker via API: To invite the bot, make a POST request with the meeting information. You’ll need to provide the meeting’s meeting_link. Here’s an example:
curl --request POST "https://api.nylas.com/v3/grants/<GRANT_ID>/notetakers" \
--header "Authorization: Bearer <NYLAS_API_KEY>" \
--header "Content-Type: application/json" \
--data '{
"meeting_link": "<MEETING_URL>",
"join_time": "1732657774",
"notetaker_name": "Nylas Notetaker",
"meeting_settings": {
"video_recording": true,
"audo_recording": true,
"transcription": true,
}
}'In the above snippet:
meeting_linkis a valid link to your online meeting. This could be a Google Meet, Microsoft Teams link, Zoom meeting link, etc.join_timeis the scheduled start time of the meeting in seconds (unix time). If you leave outjoin_time, the bot will try to join as soon as the request is made.
A successful request will return a JSON response containing a unique notetakerId for the bot instance created:
{
"request_id":"<REQUEST_ID>",
"data":{"id":"<NOTETAKER_ID>",
"grant_id":"<GRANT_ID>",
"name":"Nylas Notetaker",
"state":"connecting",
"meeting_link":"<MEETING_LINK>",
"meeting_provider":"Google Meet",
"meeting_settings":{
"video_recording":true,
"audio_recording":true,
"transcription":true,
}
"join_time":1741210298
}Keep note of the notetakerId—it’s how you will reference this specific Notetaker session in subsequent API calls (like fetching transcripts or updating the notetaker).
What happens next? When the scheduled time arrives (or immediately, if no time was given), Nylas will have the Notetaker bot join the meeting. Nylas is working in the background to get your bot into the meeting. If the meeting hasn’t started or the join link isn’t active yet, the bot will keep trying until it can join or until it times out. If the meeting is restricted (organization-only, waiting room enabled, etc.), someone might need to admit the “guest” user (the Notetaker) into the call:
Syncing Notetaker with Calendar Events
One interesting scenario that we may come across is when a calendar event is updated that a Notetaker has been invited to. By default, the Notetaker will not know when a calendar event is updated, so it will not be able to join the updated meeting time. How we can work around this is by creating calendar events that include the notetaker configuration:
curl --request POST \
--url https://api.us.nylas.com/v3/grants/<GRANT_ID>/events?calendar_id=<CALENDAR_ID> \
--header 'Accept: application/json, application/gzip' \
--header 'Authorization: Bearer <NYLAS_API_KEY>' \
--header 'Content-Type: application/json' \
--data '{
"title": "Nylas Integration",
"busy": true,
"participants": [
{
"name": "Nyla",
"email": "[email protected]"
},
{
"name": "Ram",
"email": "[email protected]"
}
],
"description": "Come ready to talk Nylas!",
"when": {
"start_time": 1674604800,
"end_time": 1722382420,
},
# add config to autocreate a Google Meet link
"conferencing": {
"provider": "Google Meet",
"autocreate": {}
},
# add config to ensure Notetaker syncs with event updates
"notetaker": {
"name": "Nylas Notetaker",
"meeting_settings": {
"video_recording": true,
"audo_recording": true,
"transcription": true
}
}
}' Check out our developer documentation to learn more about calendar and event sync.
Now we’ve created a calendar event that includes the Notetaker, so anytime the event time is updated, the Notetaker will sync and join at the updated time.
Handling Notifications and Webhooks
To build a scalable integration, let’s go over how to handle real-time notifications for Notetaker activities. Nylas uses webhooks to inform your application of events such as the bot being created, joining a meeting, or the transcription being ready. Let’s go over how to set up webhooks.
Subscribe to Notetaker webhook events: In the Nylas dashboard or via API, you need to register a webhook URL (an endpoint on your server) and specify which events you want to receive. The Notetaker supports several event triggers.
You can choose which of these events to register as a webhook. At minimum, subscribing to notetaker.media is highly useful to know when to grab the transcript.
To create a webhook subscription via the API, you would send a POST request to the /v3/webhooks endpoint:
curl --request POST "https://api.us.nylas.com/v3/webhooks" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $NYLAS_API_KEY" \
-d '{
"trigger_types": ["notetaker.media", "notetaker.meeting_state"],
"description": "Notetaker updates webhook",
"webhook_url": "https://<YOUR_APP_URL>/webhook",
"notification_email_addresses": ["[email protected]"]
}'In the above JSON, we subscribe to two trigger events (notetaker.media and notetaker.meeting_state).
Security tip: Nylas webhooks can be secured by verifying signatures. Check out a recent blog post on creating and securing Nylas webhooks. This will ensure nobody can spoof events to your endpoint.
With webhooks in place, your integration becomes event-driven. You don’t have to continuously check if the meeting started or if the transcript is ready; Nylas will push that info to you in real time.
Retrieving Meeting Transcriptions
Once your meeting has concluded, the bot will leave and begin processing the recording to generate a transcription. As a developer, you have two ways to retrieve the meeting’s transcription and recording:
1. Via Webhook Notifications (Real-time): If you’ve subscribed to the notetaker.media webhook event, Nylas will send a notification to your webhook URL when the transcription and recording are ready. The webhook payload will include temporary URLs for the video recording and the transcription file.
2. Via API Request (On-demand): You can also fetch the recording and transcript by making a GET request to the Notetaker media endpoint. This request will return JSON containing URLs for the recording and transcript, similar to the webhook data.
Let’s look at option #2 with a quick API call to get the transcript after a meeting:
curl --request GET "https://api.nylas.com/v3/grants/<GRANT_ID>/notetakers/<NOTETAKER_ID>/media" \
--header "Authorization: Bearer <NYLAS_API_KEY>If the transcription is ready, the response will look like this:
{
"request_id":"<REQUEST_ID>",
"data":{
"recording":{"url":"<URL>","size":0, ...more details...},
"transcript":{"url":"<URL>","size":0, ...more details...}
}
}
The url fields are the direct download links for the video recording and the text transcript of the meeting.
By using either the webhook or manual fetch approach, you can retrieve the full meeting transcript and then integrate it into your application.
Build Time!
In this blog post, we went over the steps to integrate the Nylas Notetaker into your meetings to automatically record and transcribe audio from meetings.
You can sign up for Nylas for free and start building! Continue building with Nylas by exploring different quickstart guides or by visiting our developer documentation.
