Quickstart: Using Nylas Notetaker

This quickstart will walk you through setting up Nylas Notetaker to automatically join and record meetings on your calendar. You’ll learn how to send Notetaker to specific meetings and configure it to join all meetings on a calendar - all in just a few simple steps!

Prerequisites

Before you begin, make sure you have:

• Nylas Developer Account: Sign up here if you don’t have one
• Connected Grant: On the dashboard, click Grants → Add test grant

1. Send Notetaker to a specific meeting

To send Notetaker to join a specific meeting, make a POST request to create a new Notetaker:

RequestNode.js SDKPython SDKRuby SDKJava SDKKotlin SDK

curl --request POST \
  --url "https://api.us.nylas.com/v3/grants/<NYLAS_GRANT_ID>/notetakers" \
  --header "Authorization: Bearer <NYLAS_API_KEY>" \
  --header "Content-Type: application/json" \
  --data '{
    "meeting_link": "<MEETING_LINK>",
    "name": "My Notetaker"
  }'

const Nylas = require("nylas");
const nylas = new Nylas({
  apiKey: "{NYLAS_API_KEY}",
});

async function createNotetaker() {
  const response = await nylas.notetakers.create({
    identifier: "{EMAIL}",
    requestBody: {
      meetingLink: "{MEETING_LINK}",
      name: "My Notetaker",
    },
  });

  console.log("Notetaker created:", response);
}

createNotetaker();

from nylas import Client

nylas = Client(
    api_key="{NYLAS_API_KEY}",
)

response = nylas.notetakers.create(
    identifier="{EMAIL}",
    request_body={
        "meeting_link": "{MEETING_LINK}",
        "name": "My Notetaker"
    }
)

print(f"Notetaker created: {response}")

require 'nylas'

nylas = Nylas::Client.new(api_key: '{NYLAS_API_KEY}')

response = nylas.notetakers.create(
  identifier: '{EMAIL}',
  request_body: {
    meeting_link: '{MEETING_LINK}',
    name: 'My Notetaker'
  }
)

puts "Notetaker created: #{response.inspect}"

import com.nylas.NylasClient;
import com.nylas.models.*;

public class CreateNotetaker {
  public static void main(String[] args) throws NylasSdkTimeoutError, NylasApiError {
    NylasClient nylas = new NylasClient.Builder("{NYLAS_API_KEY}").build();

    CreateNotetakerRequest request = new CreateNotetakerRequest.Builder()
        .meetingLink("{MEETING_LINK}")
        .name("My Notetaker")
        .build();

    Response<Notetaker> response = nylas.notetakers().create("{EMAIL}", request);

    System.out.println("Notetaker created: " + response.getData());
  }
}

import com.nylas.NylasClient
import com.nylas.models.CreateNotetakerRequest

fun main() {
    val nylas = NylasClient(apiKey = "{NYLAS_API_KEY}")

    val request = CreateNotetakerRequest(
        meetingLink = "{MEETING_LINK}",
        name = "My Notetaker"
    )

    val response = nylas.notetakers().create("{EMAIL}", request)

    println("Notetaker created: ${response.data}")
}

Replace the following values:

• {EMAIL} with your user’s email
• {NYLAS_API_KEY} with your API key
• {MEETING_LINK} with a Zoom, MS Teams, or Google Meet join link (e.g. https://zoom.us/j/123456789?pwd=123456789)

2. Configure calendar sync for automatic meetings

To have Notetaker automatically join meetings on a calendar, update the calendar settings:

RequestNode.js SDKPython SDKRuby SDKJava SDKKotlin SDK

curl --request PUT \
  --url "https://api.us.nylas.com/v3/grants/<NYLAS_GRANT_ID>/calendars/primary" \
  --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,
        "leave_after_silence_seconds": 360
      },
      "rules": {
        "event_selection": ["all"],
        "participant_filter": {
          "participants_gte": 1,
          "participants_lte": 100
        }
      }
    }
  }'

const Nylas = require("nylas");
const nylas = new Nylas({
  apiKey: "{NYLAS_API_KEY}",
});

async function configureCalendarNotetaker() {
  const response = await nylas.calendars.update({
    identifier: "{EMAIL}",
    calendarId: "primary",
    requestBody: {
      notetaker: {
        name: "My Notetaker",
        meetingSettings: {
          videoRecording: true,
          audioRecording: true,
          transcription: true,
        },
        rules: {
          eventSelection: ["all"],
          participantFilter: {
            participantsGte: 1,
            participantsLte: 100,
          },
        },
      },
    },
  });

  console.log("Calendar updated with Notetaker:", response);
}

configureCalendarNotetaker();

from nylas import Client

nylas = Client(
    api_key="{NYLAS_API_KEY}",
)

response = nylas.calendars.update(
    identifier="{EMAIL}",
    calendar_id="primary",
    request_body={
        "notetaker": {
            "name": "My Notetaker",
            "meeting_settings": {
                "video_recording": True,
                "audio_recording": True,
                "transcription": True
            },
            "rules": {
                "event_selection": ["all"],
                "participant_filter": {
                    "participants_gte": 1,
                    "participants_lte": 100
                }
            }
        }
    }
)

print(f"Calendar updated with Notetaker: {response}")

require 'nylas'

nylas = Nylas::Client.new(api_key: '{NYLAS_API_KEY}')

response = nylas.calendars.update(
  identifier: '{EMAIL}',
  calendar_id: 'primary',
  request_body: {
    notetaker: {
      name: 'My Notetaker',
      meeting_settings: {
        video_recording: true,
        audio_recording: true,
        transcription: true
      },
      rules: {
        event_selection: ['all'],
        participant_filter: {
          participants_gte: 1,
          participants_lte: 100
        }
      }
    }
  }
)

puts "Calendar updated with Notetaker: #{response.inspect}"

import com.nylas.NylasClient;
import com.nylas.models.*;

public class ConfigureCalendarNotetaker {
  public static void main(String[] args) throws NylasSdkTimeoutError, NylasApiError {
    NylasClient nylas = new NylasClient.Builder("{NYLAS_API_KEY}").build();

    CalendarNotetaker.Rules rules = new CalendarNotetaker.Rules.Builder()
        .eventSelection(Collections.singletonList("all"))
        .participantFilter(
            new CalendarNotetaker.ParticipantFilter.Builder()
                .participantsGte(1)
                .participantsLte(100)
                .build()
        )
        .build();

    CalendarNotetaker.MeetingSettings meetingSettings = new CalendarNotetaker.MeetingSettings.Builder()
        .videoRecording(true)
        .audioRecording(true)
        .transcription(true)
        .build();

    CalendarNotetaker notetaker = new CalendarNotetaker.Builder()
        .name("My Notetaker")
        .meetingSettings(meetingSettings)
        .rules(rules)
        .build();

    UpdateCalendarRequest request = new UpdateCalendarRequest.Builder()
        .notetaker(notetaker)
        .build();

    Response<Calendar> response = nylas.calendars().update("{EMAIL}", "primary", request);

    System.out.println("Calendar updated with Notetaker: " + response.getData());
  }
}

import com.nylas.NylasClient
import com.nylas.models.*

fun main() {
    val nylas = NylasClient(apiKey = "{NYLAS_API_KEY}")

    val participantFilter = CalendarNotetaker.ParticipantFilter(
        participantsGte = 1,
        participantsLte = 100
    )

    val rules = CalendarNotetaker.Rules(
        eventSelection = listOf("all"),
        participantFilter = participantFilter
    )

    val meetingSettings = CalendarNotetaker.MeetingSettings(
        videoRecording = true,
        audioRecording = true,
        transcription = true
    )

    val notetaker = CalendarNotetaker(
        name = "My Notetaker",
        meetingSettings = meetingSettings,
        rules = rules
    )

    val request = UpdateCalendarRequest(notetaker = notetaker)

    val response = nylas.calendars().update("{EMAIL}", "primary", request)

    println("Calendar updated with Notetaker: ${response.data}")
}

To attach Notetaker to a specific calendar, replace primary with your target calendar ID.

Silence Detection: By default, Notetaker leaves a meeting after 5 minutes (300 seconds) of continuous silence. Customize this using leave_after_silence_seconds in meeting_settings. Set a lower value for shorter meetings, or increase it up to 1 hour (3600 seconds) for meetings with expected long pauses. Silence detection only triggers after at least one participant has spoken, so the bot won’t leave immediately on join if no one has spoken yet.

3. Check Notetaker status

To check the status of all your Notetakers:

RequestNode.js SDKPython SDKRuby SDKJava SDKKotlin SDK

curl --request GET \
  --url "https://api.us.nylas.com/v3/grants/<NYLAS_GRANT_ID>/notetakers" \
  --header "Authorization: Bearer <NYLAS_API_KEY>"

const Nylas = require("nylas");
const nylas = new Nylas({
  apiKey: "{NYLAS_API_KEY}",
});

async function listNotetakers() {
  const response = await nylas.notetakers.list({
    identifier: "{EMAIL}",
  });

  console.log("Notetakers:", response.data);
}

listNotetakers();

from nylas import Client

nylas = Client(
    api_key="{NYLAS_API_KEY}",
)

response = nylas.notetakers.list(
    identifier="{EMAIL}"
)

print(f"Notetakers: {response.data}")

require 'nylas'

nylas = Nylas::Client.new(api_key: '{NYLAS_API_KEY}')

response = nylas.notetakers.list(
  identifier: '{EMAIL}'
)

puts "Notetakers:"
response.data.each do |notetaker|
  puts "- #{notetaker[:id]}: #{notetaker[:name]} (Status: #{notetaker[:status]})"
end

import com.nylas.NylasClient;
import com.nylas.models.*;

public class ListNotetakers {
  public static void main(String[] args) throws NylasSdkTimeoutError, NylasApiError {
    NylasClient nylas = new NylasClient.Builder("{NYLAS_API_KEY}").build();

    ListResponse<Notetaker> response = nylas.notetakers().list("{EMAIL}");

    System.out.println("Notetakers:");
    for (Notetaker notetaker : response.getData()) {
      System.out.println("- " + notetaker.getId() + ": " + notetaker.getName() +
                         " (Status: " + notetaker.getStatus() + ")");
    }
  }
}

import com.nylas.NylasClient

fun main() {
    val nylas = NylasClient(apiKey = "{NYLAS_API_KEY}")

    val response = nylas.notetakers().list("{EMAIL}")

    println("Notetakers:")
    response.data.forEach { notetaker ->
        println("- ${notetaker.id}: ${notetaker.name} (Status: ${notetaker.status})")
    }
}

4. Retrieve meeting recordings and transcripts

Once a Notetaker has completed recording a meeting, retrieve links to the media files:

RequestResponse (JSON)Node.js SDKPython SDKRuby SDKJava SDKKotlin SDK

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

{
  "request_id": "5fa64c92-e840-4357-86b9-2aa364d35b88",
  "data": {
    "action_items": {
      "created_at": 1703088000,
      "expires_at": 1704297600,
      "name": "meeting_action_items.json",
      "size": 289,
      "ttl": 3600,
      "type": "application/json",
      "url": "https://storage.googleapis.com/nylas-notetaker-uc1-prod-notetaker/..."
    },
    "recording": {
      "created_at": 1703088000,
      "duration": 1800,
      "expires_at": 1704297600,
      "name": "meeting_recording.mp4",
      "size": 52428800,
      "ttl": 3600,
      "type": "video/mp4",
      "url": "https://storage.googleapis.com/nylas-notetaker-uc1-prod-notetaker/..."
    },
    "summary": {
      "created_at": 1703088000,
      "expires_at": 1704297600,
      "name": "meeting_summary.json",
      "size": 437,
      "ttl": 3600,
      "type": "application/json",
      "url": "https://storage.googleapis.com/nylas-notetaker-uc1-prod-notetaker/..."
    },
    "thumbnail": {
      "created_at": 1703088000,
      "expires_at": 1704297600,
      "name": "thumbnail.png",
      "size": 437,
      "ttl": 3600,
      "type": "image/png",
      "url": "https://storage.googleapis.com/nylas-notetaker-uc1-prod-notetaker/..."
    },
    "transcript": {
      "created_at": 1703088000,
      "expires_at": 1704297600,
      "name": "transcript.json",
      "size": 10240,
      "ttl": 3600,
      "type": "application/json",
      "url": "https://storage.googleapis.com/nylas-notetaker-uc1-prod-notetaker/..."
    }
  }
}

const Nylas = require("nylas");
const nylas = new Nylas({
  apiKey: "{NYLAS_API_KEY}",
});

async function getNotetakerMedia() {
  const response = await nylas.notetakers.media({
    identifier: "{EMAIL}",
    notetakerId: "{notetaker_id}",
  });

  console.log("Notetaker media files:", response.data);
}

getNotetakerMedia();

from nylas import Client

nylas = Client(
    api_key="{NYLAS_API_KEY}",
)

response = nylas.notetakers.media(
    identifier="{EMAIL}",
    notetaker_id="{notetaker_id}"
)

print(f"Media files: {response.data}")

require 'nylas'

nylas = Nylas::Client.new(api_key: '{NYLAS_API_KEY}')

response = nylas.notetakers.media(
  identifier: '{EMAIL}',
  notetaker_id: '{notetaker_id}'
)

puts "Media files:"
response.data.each do |media|
  puts "- #{media[:type]}: #{media[:url]}"
end

import com.nylas.NylasClient;
import com.nylas.models.*;

public class GetNotetakerMedia {
  public static void main(String[] args) throws NylasSdkTimeoutError, NylasApiError {
    NylasClient nylas = new NylasClient.Builder("{NYLAS_API_KEY}").build();

    Response<List<NotetakerMedia>> response = nylas.notetakers().media("{EMAIL}", "{notetaker_id}");

    System.out.println("Media files:");
    for (NotetakerMedia media : response.getData()) {
      System.out.println("- " + media.getType() + ": " + media.getUrl());
    }
  }
}

import com.nylas.NylasClient

fun main() {
    val nylas = NylasClient(apiKey = "{NYLAS_API_KEY}")

    val response = nylas.notetakers().media("{EMAIL}", "{notetaker_id}")

    println("Media files:")
    response.data.forEach { media ->
        println("- ${media.type}: ${media.url}")
    }
}

Replace {notetaker_id} with your Notetaker’s ID from the previous step.