Build for free

How to integrate Google Meet into your SaaS app

• 10 min read
Jump to section
Author: Winona Rajamohan
Winona Rajamohan
Tags:
Featured articles
Notetaker API
How to add AI meeting note takers to these 4 apps (before your competitors do)
• 8 min read
Read more
Notetaker API
How to record Zoom meetings:  Local, APIs, or bots?
• 8 min read
Read more
Notetaker API
How to record meetings in your app with an AI meeting bot
• 13 min read
Read more
Jump to section

Quick summary:

Compares the Google Meet REST API and the Nylas Notetaker API for integrating Google meeting recording and transcription into SaaS applications.

What you’ll learn:

  • How Google Meet’s REST API introduces limitations with programmatic recordings, user permissions, and mapping to Google Calendar.
  • Why SaaS applications use Nylas to handle cross-platform meeting bots, transcription, and calendar sync with a single integration.

Who it’s for: Platform builders who want to to ship production-ready meeting intelligence features in weeks instead of 6+ months.

There’s growing demand for SaaS applications that integrate with meeting platforms like Google Meet. 

When we surveyed 1000 SaaS users, 85% said they wanted meeting recording and transcription features to be built into their favorite work tools. 

But if you’re a product builder trying to meet this demand, you likely want to spend your engineers’ time building something other than just the plumbing to get audio and video files from meetings. 

Unfortunately, integrating with Google Meet doesn’t give you the same options as building custom meeting bot infrastructure with Zoom SDK (which is a pretty complex process anyway). It’s also a lot of work trying to get your recordings automatically synced up with Google Calendar, which is how a lot of Google Meet links are generated. 

We’re going to cover the basics of what you can do with Google Meet APIs, how you would use the REST API for post-meeting files, and an easier way to go about it. 

What Google Meet APIs can you use? 

There are three native Google options for developers to build apps around Google Meet:

The integrationData accessImplementationUse cases
REST APIPost-meeting recordings/transcriptsHigh, 2-3 weeks for only a Google Meet integration (not including ongoing maintenance) Meeting archives, automated training sessions, meeting summaries and action items
Media APIReal-time audio/videoVery high, 1-2 monthsLive transcription, real-time meeting analysis and assistants
Add-ons SDKIn-meeting UI extensionsMedium, 1-2 weeksDocument collaboration, polling/engagement features

If you’re trying to build a SaaS app or workflow (like a CRM or ATS that pulls data from Google Meet conferences), you could do that with the REST API. 

Here’s a quick walkthrough of what that would look like. 

How to integrate meeting data with the REST API  

The REST API will help you: 

  • Automatically create meetings and manage meeting links
  • Add a clickable call-to-action to join meetings 
  • Pull participant lists and metadata like when participants join and leave meetings
  • Get recordings and transcripts after meetings are complete 

Before integrating, you’ll need:

  • A Google Cloud project with the Google Meet API enabled
  •  OAuth 2.0 credentials or Service Account keys from Google Cloud Console
  • A Google Workspace account with appropriate meeting permissions

Authentication setup 

Choose your authentication method based on your use case:

  • OAuth 2.0: For user-facing applications where individuals control their meetings
  • Service Accounts: For automated systems that need organization-wide access

Setting up authentication

# Google Meet API scopes (same for both authentication methods)
scopes = [
    'https://www.googleapis.com/auth/meetings.space.readonly',
    'https://www.googleapis.com/auth/meetings.space.created', 
    'https://www.googleapis.com/auth/meetings.space.settings',  # Auto-recording
    'https://www.googleapis.com/auth/drive.readonly'           # Recordings access
]

# OAuth 2.0 - User authentication (user clicks "Allow")
from google_auth_oauthlib.flow import InstalledAppFlow
flow = InstalledAppFlow.from_client_secrets_file('credentials.json', scopes)
user_creds = flow.run_local_server(port=0)

# Service Account - Server authentication (no user interaction)
from google.oauth2 import service_account
service_creds = service_account.Credentials.from_service_account_file(
    'service-account-key.json', scopes=scopes
)

Getting data from your meetings

The Google Meet REST API provides several endpoints for managing meetings and accessing data. Here are a few you’ll likely need: 

REST API endpoints

url = 'https://meet.googleapis.com/v2/spaces'
data = {
    "config": {
        "autoRecording": True,        # Automatically start recording
        "autoTranscription": True     # Generate transcripts
    }
}
response = requests.post(url, headers=headers, json=data)
meeting_url = response.json().get('meetingUri')

Limitations with the Google Meet REST API

You’ll quickly realize that there are issues that keep developers from using the REST API to build production apps that process high volumes of meeting data. 

  • Processing delays: Recordings can take anywhere between five to 45+ minutes to become available for your app to process. 
  • Inconsistent recording availability: Even with auto-recording configured, there’s no API to programmatically ensure recordings happen or verify recording status during calls. 
  • Storage bottlenecks: Recording fails silently if the organizer’s Google Drive is full
  • Complex calendar integration: Mapping Google Calendar events to Meet conferences is unreliable  — single calendar events can generate multiple conference records when people leave and rejoin, and retroactive schedule changes can shift meeting times by entire days, breaking event-to-conference correlations 
  • Limited transcript quality: Transcript quality heavily depends on audio input. Developers would have to integrate with a transcription API like AssemblyAI or Deepgram for the most accurate transcriptions. 
  • Google-only ecosystem: No support for Zoom, Teams, or other meeting platforms that users use heavily. 

A unified API helps you integrate Google Meet data at scale

When building production SaaS applications, the Google Meet REST API’s limitations create significant engineering overhead. Developers spend months building workarounds for calendar mapping, handling inconsistent recording availability, and managing Google Drive storage failures. This engineering time could be better spent on core product features.

But a unified meeting API like Nylas gives developers a single integration that works across Google Meet, Zoom, and Microsoft Teams — even emails and calendars. This means: 

  • Reliable processing: Meeting files are processed right after meetings are done and are delivered in minutes. Files are not subjected to Google’s inconsistent processing times. 
  • No friction for users across Workspace plans: Bots join meetings regardless of host’s Google Workspace tier or recording permissions
  • Guaranteed recording: Programmatic bot deployment removes dependency on manual activation within the Google Meet UI or admin pre-configuration. 
  • No Google Drive dependency: Recordings stored via signed URLs
  • Simplified calendar mapping: Native calendar sync handles event-to-meeting correlation automatically without custom correlation logic
  • Production-grade transcripts: Nylas’ built-in AssemblyAI integration delivers a lower word error rate with speaker diarization and no additional partnership management required
  • Cross-platform compatibility: Same API works for Google Meet, Zoom, and Teams meetings

How to use Nylas to integrate Google Meet into a SaaS app

In this quick example, let’s walk through using Nylas to integrate with add AI-powered sales call transcription to a CRM. We’ll use the Notetaker API to capture meeting recordings and transcripts from Google Meet calls to feed into your app. 

That’s reliable, secure data to power your AI models and bring meeting intelligence to users. 

Step 1: Set up authentication

Make sure you have this on hand:  

  • Nylas account & API credentials: If you don’t have one already, sign up for a Nylas developer account for free.
  • A meeting link: Have a Zoom, Google Meet, or other compatible meeting URL handy for testing.

First, set up your development environment with your Nylas API credentials

Set up your development environment

# Set environment variables for reuse
export NYLAS_API_KEY="<YOUR_NYLAS_API_KEY>"

Then authenticate users to connect their Google accounts for meeting access through an OAuth2.0 authentication flow. This will grant your app specific permissions and give you a Grant ID for that user. You can read more on our authentication process in our docs. 

Authenticate users

import "dotenv/config";
import express from "express";
import Nylas from "nylas";

const config = {
  clientId: process.env.NYLAS_CLIENT_ID,
  callbackUri: "http://localhost:3000/oauth/exchange",
  apiKey: process.env.NYLAS_API_KEY,
  apiUri: process.env.NYLAS_API_URI,
};

const nylas = new Nylas({
  apiKey: config.apiKey,
  apiUri: config.apiUri,
});

const app = express();
const port = 3000;

// Route to initialize authentication
app.get("/nylas/auth", (req, res) => {
  const authUrl = nylas.auth.urlForOAuth2({
    clientId: config.clientId,
    provider: "google",
    redirectUri: config.callbackUri,
    loginHint: "email_to_connect",
  });

  res.redirect(authUrl);
});

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Step 2: Create meeting bots for sales calls

Deploy a bot to join and record specific Google Meet sessions.

Deploy a bot

curl --request POST \
  --url "https://api.us.nylas.com/v3/grants/<NYLAS_GRANT_ID>/notetakers" \
  --header 'Accept: application/json, application/gzip' \
  --header 'Authorization: Bearer <NYLAS_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{
    "meeting_link": "https://meet.google.com/abc-defg-hij",
    "name": "Sales Call Recorder"
  }'

For automated deployment, integrate with your calendar to send bots to scheduled sales meetings.

Map bots to Google Calendar events

curl --request PUT \
  --url 'https://api.us.nylas.com/v3/grants/<NYLAS_GRANT_ID>/calendars/<CALENDAR_ID>' \
  --header 'Accept: application/json, application/gzip' \
  --header 'Authorization: Bearer <NYLAS_API_KEY>' \
  --header 'Content-Type: application/json' \
  --data '{
    "notetaker": {
      "name": "Sales Call Recorder",
      "rules": {
        "event_selection": ["external"],
        "participant_filter": {
          "participants_gte": 2
        }
      }
    }
  }'

Step 3: Get meeting recordings and transcripts

Unlike the REST API, you can get production-ready Google Meet recordings for ad-hoc and scheduled meetings through a single Nylas endpoint. You can also get transcripts from Meet meetings complete with speaker diarization. 

Retrieve recordings and transcripts after meetings complete

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

The response includes both recording and transcript URLs with no dependency on host permissions, headless browser bot architecture, or additional transcription APIs. 

You can also set up webhook notifications to get real-time updates on bot status and media availability. 

Nylas sends multiple webhook events throughout the meeting lifecycle: 

  • notetaker.created: When bots are created
  • notetaker.updated: When bot statuses changes (scheduled → connecting → in_call → completed)
  • notetaker.meeting_state: For real-time meeting events (joined, left, failed_entry)
  • notetaker.media: When media files are processed and ready
  • notetaker.deleted: When a bot is cancelled or deleted

Set up webhook notifications

app.post('/webhooks/nylas', (req, res) => {
  const { type, data } = req.body;
  
  if (type === 'notetaker.media' && data.object.state === 'available') {
    const videoUrl = data.object.media.recording;      // Video file
    const transcriptUrl = data.object.media.transcript; // Transcript
    
    // Process both video and transcript for CRM integration
    processMediaForCRM(videoUrl, transcriptUrl, data.object.id);
  }
  
  res.status(200).send('OK');
});

Step 4: Process transcripts into AI summaries and action items

Use the transcript and video recordings as data sources for your AI products and agents.

Extract sales insights from transcript data.

# Download transcript using the signed URL from webhook
curl --request GET \
  --url "<TRANSCRIPT_URL_FROM_WEBHOOK>" \
  --output "meeting_transcript.json"

In September 2025, Nylas will be launching built-in summaries and action items that will be made available in the /media endpoint. All you’ll need to do is turn on this feature with a simple API call to start automatically generating summaries and action items for all meetings the Notetaker meeting bot joins!

The challenge of using Google Meet APIs vs the Nylas Notetaker API

In summary, the Notetaker API beats the REST API for SaaS app integrations on a few key fronts: 

  • Programmatic recordings 
  • Easy authentication 
  • Webhook updates 
  • Production-ready, diarized transcripts
  • Built-in summaries and action items as a data source (Coming real soon 👀)

And of course, with Nylas, you have a partner who specializes in building and maintaining integrations across meeting providers. We’ve experimented, failed, and learned a lot about Google Meet integrations in the process of shipping the Notetaker API. Our team of experts are ready to help so you don’t have to worry about integrations as you build your AI products and meeting features. 

FactorGoogle Meet REST APINylas Notetaker API
Programmatic recordingsPre-configured meeting spaces that start recording when a user with the right permission joinsReliable bots capture every meeting for users
Easy authenticationComplex OAuth setup, multiple scopesSimple OAuth, one flow across platforms
Webhook updatesBasic participant events onlyFull lifecycle bot updates + media-ready webhooks
TranscriptsInconsistent processing, audio-dependent qualityBuilt-in, diarized, production-ready
Summaries and action itemsNot available via API as a data source(Coming soon) Auto-generated for all meetings and available via an API call
Cross-platform supportGoogle Meet onlyGoogle Meet, Zoom, Teams
Calendar mappingError-prone, manual fixes needed if changes are made to calendar eventsAutomatic, calendar sync with the Nylas Calendar API
Storage managementDependent on Drive, failures possibleSigned URLs, no Drive dependency
TakeawayHeavy lift for reliable programmatic data retrieval, single-platform, unreliable at scaleReliable and production-ready across the biggest meeting platforms (Meet, Teams, Zoom)

FAQs about building with the Google Meet API

How do I create a Google Meet link programmatically?
Use the REST API’s /v2/spaces endpoint with your auth headers. You can set options like auto-recording or transcription when creating the meeting so that meetings are recorded when a user with the right permission joins. 

Can I embed Google Meet directly into my app or website?
Not in the same way as Zoom or Teams. You can generate and share meeting links through the REST API, or build a Meet add-on for in-meeting extensions.

What OAuth scopes do I need?
 At minimum, you’ll need meetings.space for creating and managing meetings. If you want recordings or transcripts, add drive.readonly for access to stored files.

How does authentication work on mobile?
Follow the same OAuth 2.0 flow, but store tokens securely using Keychain on iOS or EncryptedSharedPreferences on Android.

Can I customize the Google Meet interface?
Customization is limited. You can configure meeting settings (like auto-recording or participant permissions), but the Meet UI itself can’t be redesigned.

What are the main limitations of the Google Meet REST API?
Recordings can take 5–45 minutes to process, and may fail if the organizer’s Google Drive is full. There’s no way to guarantee programmatic recording, calendar mapping can break with event changes, and transcripts are often low quality without a separate transcription API.

Related resources

Notetaker API
How to integrate Microsoft Teams meetings into your app 

Quick summary: Compares three approaches for integrating Microsoft Teams meeting recording and transcription into SaaS…

• 7 min read
Read more
Notetaker API
How to get transcription data from Microsoft Teams meetings

Quick summary: This guide compares approaches developers can take to retrieve transcripts from Microsoft Teams…

• 10 min read
Read more
Notetaker API
5 ways to programmatically get Google Meet transcriptions

Quick summary: This guide compares programmatic approaches to capturing Google Meet transcripts, from Google APIs…

• 12 min read
Read more