# How to Integrate Replit with Google Meet

- Tool: Replit
- Difficulty: Intermediate
- Time required: 30 minutes
- Last updated: March 2026

## TL;DR

To integrate Replit with Google Meet, use the Google Calendar API with OAuth 2.0 to create Calendar events with Google Meet conference links attached. Google Meet does not have its own standalone REST API — meetings are created by adding a conferenceData request to a Google Calendar event. Store your OAuth credentials in Replit Secrets (lock icon 🔒) and use a server-side OAuth flow to generate access tokens. Deploy as Autoscale or Reserved VM for webhook-enabled applications.

## Create Google Meet Links Programmatically from Your Replit App

Google Meet is deeply integrated with Google Calendar — unlike Zoom or Webex, there is no standalone Google Meet REST API for creating meetings. Instead, you create a Google Calendar event and request a Meet conference link by setting conferenceData in the event payload. Google automatically generates a unique meet.google.com link, adds it to the calendar event, and shares it with all invited attendees. This architecture means that creating, updating, and deleting Meet meetings is really creating, updating, and deleting Calendar events.

The authentication model is OAuth 2.0, which is more complex than simple API key authentication. You must create a Google Cloud project, enable the Calendar API, configure OAuth consent screen settings, and generate OAuth 2.0 client credentials. Users (or service accounts for automated systems) must authorize your application to access their Google Calendar. The OAuth flow produces an access token (valid for one hour) and a refresh token (long-lived) that your Replit server stores in Replit Secrets and uses to obtain new access tokens without requiring re-authorization.

For automated meeting creation (scheduling without a user completing OAuth each time), use a Google service account instead of user OAuth. Service accounts can be granted domain-wide delegation in Google Workspace, allowing them to create calendar events on behalf of any user in the organization. This is the right approach for building scheduling automation tools, booking systems, or meeting creation triggered by webhooks from other services.

## Before you start

- A Replit account with a Node.js or Python Repl ready
- A Google account and access to Google Cloud Console (console.cloud.google.com)
- A Google Cloud project with the Google Calendar API enabled
- OAuth 2.0 client credentials (Client ID and Client Secret) downloaded from Google Cloud Console
- For service account use: a Google Workspace account with admin access to grant domain-wide delegation

## Step-by-step guide

### 1. Create a Google Cloud Project and Enable the Calendar API

Google Meet integration requires a Google Cloud project with the Calendar API enabled. Navigate to console.cloud.google.com and create a new project (or select an existing one). Click 'Enable APIs and Services', search for 'Google Calendar API', and enable it.

Next, configure the OAuth consent screen: in the left sidebar go to APIs & Services → OAuth consent screen. Select 'External' for user type (or 'Internal' for Google Workspace-only apps). Fill in the application name, support email, and developer contact email. Under Scopes, add the Google Calendar scope: https://www.googleapis.com/auth/calendar (full access) or https://www.googleapis.com/auth/calendar.events (events only). Add test users if your app is in development mode.

Create OAuth 2.0 credentials: go to APIs & Services → Credentials → Create Credentials → OAuth client ID. Select 'Web application' as the application type. Add your Replit development URL and deployed URL to the 'Authorized redirect URIs' (e.g., https://yourapp.replit.app/auth/callback). Download the JSON credentials file — you will extract the client_id and client_secret from it.

Store the credentials in Replit Secrets (lock icon 🔒):

GOOGLE_CLIENT_ID: the client_id from the downloaded JSON.

GOOGLE_CLIENT_SECRET: the client_secret from the JSON.

GOOGLE_REDIRECT_URI: your OAuth callback URL (https://yourapp.replit.app/auth/callback).

After the first OAuth flow completes, you will also store the refresh token as GOOGLE_REFRESH_TOKEN.

```
// check-google-secrets.js
const required = ['GOOGLE_CLIENT_ID', 'GOOGLE_CLIENT_SECRET', 'GOOGLE_REDIRECT_URI'];
for (const key of required) {
  if (!process.env[key]) {
    throw new Error(`Missing: ${key}. Add it in Replit Secrets (lock icon 🔒).`);
  }
}
console.log('Google OAuth secrets configured.');
console.log('Client ID:', process.env.GOOGLE_CLIENT_ID.slice(0, 20) + '...');
console.log('Redirect URI:', process.env.GOOGLE_REDIRECT_URI);
```

**Expected result:** The Google Cloud project has the Calendar API enabled, OAuth consent screen is configured, and OAuth credentials are stored in Replit Secrets. The verification script runs without errors.

### 2. Implement the OAuth 2.0 Authorization Flow with Node.js

The OAuth 2.0 flow for Google has three steps: redirect the user to Google's authorization URL to grant permissions, handle the callback where Google returns an authorization code, and exchange the code for access and refresh tokens. Store the refresh token permanently in Replit Secrets — it is a long-lived credential that lets you get new access tokens without requiring the user to re-authorize every hour.

Install the Google APIs Node.js library: npm install googleapis in the Shell. The googleapis library handles token exchange, automatic token refresh, and all API calls through a consistent interface.

The OAuth flow generates a one-time authorization code (in the redirect callback URL), which you exchange for an access_token (expires in 3600 seconds) and a refresh_token (does not expire unless revoked). The access token is used in API requests; the refresh token is used to generate new access tokens silently. After the initial OAuth flow, your app should only need the refresh token stored in Secrets — the library handles refreshing automatically.

IMPORTANT: The refresh token is only returned on the first authorization. If you lose it, you must revoke the authorization at myaccount.google.com/permissions and re-run the OAuth flow. Store it in GOOGLE_REFRESH_TOKEN in Replit Secrets immediately after the initial authorization.

```
// google-auth.js — OAuth 2.0 flow for Google Calendar API
const { google } = require('googleapis');
const express = require('express');
const app = express();

const oauth2Client = new google.auth.OAuth2(
  process.env.GOOGLE_CLIENT_ID,
  process.env.GOOGLE_CLIENT_SECRET,
  process.env.GOOGLE_REDIRECT_URI
);

// If we have a refresh token already, set it up
if (process.env.GOOGLE_REFRESH_TOKEN) {
  oauth2Client.setCredentials({
    refresh_token: process.env.GOOGLE_REFRESH_TOKEN
  });
  console.log('Google OAuth: using stored refresh token');
}

// Step 1: Redirect user to Google's authorization page
app.get('/auth/google', (req, res) => {
  const authUrl = oauth2Client.generateAuthUrl({
    access_type: 'offline',      // Request a refresh token
    prompt: 'consent',           // Force consent to get refresh token every time
    scope: [
      'https://www.googleapis.com/auth/calendar.events',
      'https://www.googleapis.com/auth/calendar.readonly'
    ]
  });
  res.redirect(authUrl);
});

// Step 2: Handle the OAuth callback — exchange code for tokens
app.get('/auth/callback', async (req, res) => {
  const { code, error } = req.query;
  if (error) return res.status(400).send(`Authorization denied: ${error}`);

  try {
    const { tokens } = await oauth2Client.getToken(code);
    oauth2Client.setCredentials(tokens);

    console.log('=== SAVE THESE TO REPLIT SECRETS ===');
    console.log('GOOGLE_REFRESH_TOKEN:', tokens.refresh_token);
    console.log('====================================');

    // In production: store tokens.refresh_token in your database
    // For setup: manually copy it to Replit Secrets as GOOGLE_REFRESH_TOKEN
    res.send('Authorization successful! Check the console for your refresh token. Add it to Replit Secrets as GOOGLE_REFRESH_TOKEN.');
  } catch (err) {
    console.error('Token exchange error:', err.message);
    res.status(500).send('Authorization failed. Check the console for details.');
  }
});

module.exports = { oauth2Client };

app.listen(3000, '0.0.0.0', () => {
  console.log('Auth server running. Visit /auth/google to authorize.');
});
```

**Expected result:** Visiting /auth/google in your browser redirects to Google's login. After logging in and granting permissions, Google redirects back to /auth/callback and the console shows your refresh token. Copy it to Replit Secrets as GOOGLE_REFRESH_TOKEN.

### 3. Create Google Meet Events via the Calendar API

With OAuth credentials in place, creating Google Meet links is straightforward — create a Calendar event with conferenceData set to request a Meet conference. The Calendar API returns the event with a generated meet.google.com join URL in the conferenceData.entryPoints array.

The conferenceDataVersion=1 query parameter is required — without it, the Calendar API ignores the conferenceData request and creates a plain calendar event without a Meet link.

Attendees are specified in the attendees array with their email addresses. Google Calendar automatically sends invitation emails to all attendees if sendUpdates is set to 'all'. The invitees receive an email with the calendar event and the Meet link.

For Python, the google-auth and google-api-python-client libraries provide the same functionality. Install with pip install google-auth google-auth-oauthlib google-api-python-client in the Shell.

```
// create-meet.js — Create Google Calendar event with Meet link
const { google } = require('googleapis');

const oauth2Client = new google.auth.OAuth2(
  process.env.GOOGLE_CLIENT_ID,
  process.env.GOOGLE_CLIENT_SECRET,
  process.env.GOOGLE_REDIRECT_URI
);

// Load stored refresh token
oauth2Client.setCredentials({
  refresh_token: process.env.GOOGLE_REFRESH_TOKEN
});

const calendar = google.calendar({ version: 'v3', auth: oauth2Client });

async function createMeetEvent({
  title,
  description = '',
  startDateTime,     // ISO 8601: '2026-04-01T14:00:00-05:00'
  endDateTime,       // ISO 8601: '2026-04-01T15:00:00-05:00'
  attendeeEmails = [],
  timeZone = 'America/New_York'
}) {
  const event = {
    summary: title,
    description,
    start: { dateTime: startDateTime, timeZone },
    end: { dateTime: endDateTime, timeZone },
    attendees: attendeeEmails.map(email => ({ email })),
    conferenceData: {
      createRequest: {
        requestId: `meet-${Date.now()}`, // Unique ID to prevent duplicate creation
        conferenceSolutionKey: { type: 'hangoutsMeet' }
      }
    }
  };

  const response = await calendar.events.insert({
    calendarId: 'primary',
    requestBody: event,
    conferenceDataVersion: 1,  // REQUIRED to generate Meet link
    sendUpdates: 'all'         // Send invitation emails to attendees
  });

  const createdEvent = response.data;
  const meetLink = createdEvent.conferenceData?.entryPoints
    ?.find(ep => ep.entryPointType === 'video')?.uri;

  console.log('Event created:', createdEvent.id);
  console.log('Meet link:', meetLink);
  console.log('Calendar link:', createdEvent.htmlLink);

  return {
    eventId: createdEvent.id,
    meetLink,
    calendarLink: createdEvent.htmlLink,
    startDateTime: createdEvent.start.dateTime
  };
}

// Example: create a meeting in 1 hour
(async () => {
  const start = new Date(Date.now() + 3600000).toISOString();
  const end = new Date(Date.now() + 7200000).toISOString();
  const meeting = await createMeetEvent({
    title: 'Product Demo',
    description: 'Demo of the new feature set',
    startDateTime: start,
    endDateTime: end,
    attendeeEmails: ['client@example.com'],
    timeZone: 'America/New_York'
  });
  console.log('Meeting details:', meeting);
})();

module.exports = { createMeetEvent };
```

**Expected result:** Running the script creates a Calendar event visible in Google Calendar. The console shows the Google Meet link (meet.google.com/xxx-xxxx-xxx), event ID, and calendar link. The attendee receives an invitation email with the Meet link.

### 4. Create Google Meet Events with Python

The Python implementation uses the google-auth and google-api-python-client libraries to authenticate and call the Calendar API. The pattern is identical to Node.js: initialize an OAuth2 credentials object with the stored refresh token, build the Calendar service client, and call events().insert() with conferenceDataVersion=1.

Install the required packages: pip install google-auth google-auth-oauthlib google-api-python-client in the Shell.

The Python API returns the created event as a dictionary. The Meet link is nested at response['conferenceData']['entryPoints'][0]['uri'] for video entry points. Always check that conferenceData exists in the response — if conferenceDataVersion was not set or there was an error generating the Meet link, the key may be absent.

For Flask applications, wrap the calendar functions as route handlers. For background jobs (sending meeting invites from a cron-like scheduled task), call the functions directly from the scheduled code.

```
# create_meet.py — Create Google Meet events with Python on Replit
import os
from google.oauth2.credentials import Credentials
from google.auth.transport.requests import Request
from googleapiclient.discovery import build
from datetime import datetime, timedelta, timezone

def get_calendar_service():
    """Initialize and return an authenticated Google Calendar service."""
    creds = Credentials(
        token=None,
        refresh_token=os.environ['GOOGLE_REFRESH_TOKEN'],
        token_uri='https://oauth2.googleapis.com/token',
        client_id=os.environ['GOOGLE_CLIENT_ID'],
        client_secret=os.environ['GOOGLE_CLIENT_SECRET'],
        scopes=['https://www.googleapis.com/auth/calendar.events']
    )
    # Auto-refresh the access token if expired
    if creds.expired or not creds.valid:
        creds.refresh(Request())

    return build('calendar', 'v3', credentials=creds)

def create_meet_event(
    title: str,
    start_dt: datetime,
    end_dt: datetime,
    attendee_emails: list = None,
    description: str = '',
    time_zone: str = 'America/New_York'
) -> dict:
    """Create a Google Calendar event with a Google Meet link."""
    service = get_calendar_service()

    event = {
        'summary': title,
        'description': description,
        'start': {
            'dateTime': start_dt.isoformat(),
            'timeZone': time_zone
        },
        'end': {
            'dateTime': end_dt.isoformat(),
            'timeZone': time_zone
        },
        'attendees': [{'email': e} for e in (attendee_emails or [])],
        'conferenceData': {
            'createRequest': {
                'requestId': f'meet-{int(start_dt.timestamp())}',
                'conferenceSolutionKey': {'type': 'hangoutsMeet'}
            }
        }
    }

    result = service.events().insert(
        calendarId='primary',
        body=event,
        conferenceDataVersion=1,  # Required to generate Meet link
        sendUpdates='all'
    ).execute()

    # Extract Meet link from entry points
    meet_link = None
    entry_points = result.get('conferenceData', {}).get('entryPoints', [])
    for ep in entry_points:
        if ep.get('entryPointType') == 'video':
            meet_link = ep.get('uri')
            break

    print(f'Event created: {result["id"]}')
    print(f'Meet link: {meet_link}')

    return {
        'event_id': result['id'],
        'meet_link': meet_link,
        'calendar_link': result.get('htmlLink'),
        'start': result['start']['dateTime']
    }

if __name__ == '__main__':
    # Create a meeting starting in 1 hour for 1 hour
    now = datetime.now(timezone.utc)
    start = now + timedelta(hours=1)
    end = now + timedelta(hours=2)
    meeting = create_meet_event(
        title='Demo Call',
        start_dt=start,
        end_dt=end,
        attendee_emails=['client@example.com']
    )
    print('Meeting created:', meeting)
```

**Expected result:** Running python create_meet.py creates a Google Calendar event and prints the Meet link. The event appears in Google Calendar with a Google Meet join button for all attendees.

### 5. Deploy and Build a Meeting Creation API

Wrap the calendar functions in an Express or Flask server to expose a meeting creation API that your frontend or other services can call. This server-side API handles the Google OAuth complexity transparently — callers simply POST meeting details and receive the Meet link in response.

For deployment, use Autoscale for a low-traffic meeting creation API (event-driven, scales to zero when idle). Use Reserved VM if you need guaranteed low latency for real-time booking flows where users expect immediate confirmation.

After deploying, update your Google Cloud Console: go to APIs & Services → Credentials → your OAuth client → add the deployed URL to Authorized redirect URIs. This is required if any OAuth flows will occur after deployment (relevant if you are implementing per-user OAuth rather than a single service account).

For high-volume meeting creation (e.g., scheduling thousands of meetings automatically), consider using a Google service account with domain-wide delegation instead of user OAuth. Service accounts do not require user interaction to authorize and can create events on behalf of any user in a Google Workspace organization.

```
// meet-server.js — Express API for creating Google Meet events
const express = require('express');
const { google } = require('googleapis');
const app = express();
app.use(express.json());

const oauth2Client = new google.auth.OAuth2(
  process.env.GOOGLE_CLIENT_ID,
  process.env.GOOGLE_CLIENT_SECRET,
  process.env.GOOGLE_REDIRECT_URI
);
oauth2Client.setCredentials({ refresh_token: process.env.GOOGLE_REFRESH_TOKEN });
const calendar = google.calendar({ version: 'v3', auth: oauth2Client });

// POST /meetings — create a meeting with Meet link
app.post('/meetings', async (req, res) => {
  try {
    const { title, startDateTime, endDateTime, attendees = [], description = '', timeZone = 'UTC' } = req.body;
    if (!title || !startDateTime || !endDateTime) {
      return res.status(400).json({ error: 'title, startDateTime, and endDateTime are required' });
    }

    const event = {
      summary: title,
      description,
      start: { dateTime: startDateTime, timeZone },
      end: { dateTime: endDateTime, timeZone },
      attendees: attendees.map(email => ({ email })),
      conferenceData: {
        createRequest: {
          requestId: `meet-${Date.now()}`,
          conferenceSolutionKey: { type: 'hangoutsMeet' }
        }
      }
    };

    const response = await calendar.events.insert({
      calendarId: 'primary',
      requestBody: event,
      conferenceDataVersion: 1,
      sendUpdates: 'all'
    });

    const meetLink = response.data.conferenceData?.entryPoints
      ?.find(ep => ep.entryPointType === 'video')?.uri;

    res.status(201).json({
      eventId: response.data.id,
      meetLink,
      calendarLink: response.data.htmlLink
    });
  } catch (err) {
    console.error('Calendar API error:', err.message);
    res.status(500).json({ error: err.message });
  }
});

// DELETE /meetings/:eventId — cancel a meeting
app.delete('/meetings/:eventId', async (req, res) => {
  try {
    await calendar.events.delete({
      calendarId: 'primary',
      eventId: req.params.eventId,
      sendUpdates: 'all'
    });
    res.json({ deleted: true, eventId: req.params.eventId });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

app.listen(3000, '0.0.0.0', () => console.log('Meet API server running on port 3000'));
```

**Expected result:** POST /meetings with title, startDateTime, endDateTime, and attendees returns a 201 response with eventId, meetLink, and calendarLink. The meeting appears in Google Calendar and invitees receive email invitations.

## Best practices

- Store GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, and GOOGLE_REFRESH_TOKEN in Replit Secrets (lock icon 🔒) — refresh tokens are long-lived credentials equivalent to a password for the user's Google account
- Always include conferenceDataVersion: 1 as a query parameter (not in the request body) when creating events — without it, Google Meet links are never generated
- Use unique requestId values in conferenceData.createRequest (e.g., combining timestamp and a UUID) to prevent duplicate Meet links if API calls are retried
- Store calendar event IDs in your database when creating meetings — you need them to update or cancel meetings, and the Calendar API does not easily reverse-lookup by title
- Send sendUpdates: 'all' when creating events with attendees so Google automatically emails invitations — do not build your own email system for this
- For automated meeting creation without user OAuth interaction, use a Google service account with domain-wide delegation instead of user OAuth tokens
- Handle token refresh errors gracefully — log them and trigger re-authorization rather than crashing, since refresh tokens can be revoked at any time by the user
- Deploy as Autoscale for meeting creation APIs — the workload is event-driven and Autoscale scales to zero when idle, keeping costs low

## Use cases

### Automated Meeting Scheduler

Build a booking system that creates Google Meet links automatically when users book appointments. When a booking is confirmed in your app, the Replit server calls the Calendar API to create an event with a Meet link, sends the link to both the host and the attendee, and stores the event ID for future updates or cancellations.

Prompt example:

```
Build an appointment booking API that creates a Google Calendar event with a Google Meet link when a booking is submitted, emails the Meet link to both the host and client, and returns the event ID for tracking cancellations.
```

### Team Standup and Meeting Bot

Automatically create recurring Google Meet meetings for team standups, sprints, or project kickoffs. The Replit server accepts a meeting request (title, attendee emails, recurrence rule) and creates a recurring calendar event with a Meet link that all attendees receive via Google Calendar invitation emails.

Prompt example:

```
Create an API endpoint that accepts meeting details (title, attendee list, start time, duration, recurrence) and creates a recurring Google Calendar event with a Meet link, returning the join URL for display in a team dashboard.
```

### CRM-Integrated Meeting Creation

Trigger Google Meet creation directly from your CRM when a deal reaches a key stage (demo request, proposal review, contract signing). The Replit middleware receives the CRM webhook, creates a Calendar event with Meet link for the sales rep and prospect, and posts the meeting details back into the CRM deal record.

Prompt example:

```
Build a webhook receiver that triggers when a CRM deal moves to 'Demo Scheduled' stage, creates a Google Calendar event with a Meet link for the sales rep and prospect, and updates the CRM deal with the meeting URL and event ID.
```

## Troubleshooting

### Google Calendar event is created but conferenceData is absent — no Meet link in the response

Cause: The conferenceDataVersion=1 parameter was not included in the insert request, or the Google account creating the event does not have Google Meet enabled (some free Google accounts have limitations).

Solution: Ensure conferenceDataVersion: 1 is passed as a query parameter in the events.insert() call (not in the request body). Verify the Google account has Google Meet available — Google Workspace accounts always have Meet, but some legacy free accounts may have restrictions. Check the Google Cloud Console to confirm the Calendar API is properly enabled.

```
// Correct: conferenceDataVersion as query param, not in body
const response = await calendar.events.insert({
  calendarId: 'primary',
  requestBody: event,          // conferenceData goes here
  conferenceDataVersion: 1    // THIS must be a query parameter
});
```

### OAuth error: 'invalid_grant' — refresh token is invalid or expired

Cause: The refresh token stored in GOOGLE_REFRESH_TOKEN has been revoked. This happens when the user revokes app access at myaccount.google.com/permissions, when there are more than 50 refresh tokens for the same app, or if the OAuth consent screen app is deleted and recreated.

Solution: Delete the GOOGLE_REFRESH_TOKEN secret from Replit, re-run the OAuth flow at /auth/google to generate a new authorization and capture the new refresh token, and update GOOGLE_REFRESH_TOKEN in Replit Secrets with the new value.

### Error 403: 'The caller does not have permission' when calling Calendar API

Cause: The OAuth scope granted does not include calendar event creation, or the calendar being accessed (calendarId) belongs to a different Google account than the authenticated user.

Solution: Verify the OAuth scope includes https://www.googleapis.com/auth/calendar.events or https://www.googleapis.com/auth/calendar. Re-run the OAuth flow with the correct scope. Use calendarId: 'primary' to always target the authenticated user's primary calendar.

```
// Ensure correct scope is requested in OAuth flow
const authUrl = oauth2Client.generateAuthUrl({
  access_type: 'offline',
  prompt: 'consent',
  scope: ['https://www.googleapis.com/auth/calendar.events'] // Must include this
});
```

### OAuth redirect fails: 'redirect_uri_mismatch' error from Google

Cause: The GOOGLE_REDIRECT_URI in Replit Secrets does not exactly match one of the Authorized redirect URIs configured in Google Cloud Console OAuth credentials. Even a trailing slash difference causes this error.

Solution: In Google Cloud Console → APIs & Services → Credentials → your OAuth client, verify the Authorized redirect URIs list includes your exact Replit URL (e.g., https://yourapp.replit.app/auth/callback). Add both your development and deployed URLs. The URI must match character for character including protocol, domain, and path.

## Frequently asked questions

### Does Google Meet have its own REST API?

No — Google Meet does not have a standalone REST API for creating or managing meetings. Google Meet links are created through the Google Calendar API by setting conferenceData with a conferenceSolutionKey of 'hangoutsMeet' in a Calendar event. The Google Meet REST API (beta as of early 2024) focuses on conference record retrieval (past meeting data) rather than meeting creation.

### How do I store Google OAuth credentials securely in Replit?

Click the lock icon (🔒) in the Replit sidebar and add GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, GOOGLE_REDIRECT_URI, and GOOGLE_REFRESH_TOKEN as separate secrets. The refresh token is the most sensitive — it grants long-term access to the Google Calendar. Never put it in code files or commit it to version control.

### Can I create Google Meet links without a Google Workspace account?

Yes, personal Google accounts (gmail.com) can create Google Meet links through the Calendar API, though some enterprise Meet features (like recording or noise cancellation) require Google Workspace. For automated service account use (creating meetings without user interaction), you need a Google Workspace account with admin access to configure domain-wide delegation.

### Why does my Google OAuth refresh token stop working?

Google revokes refresh tokens when: the user revokes your app's access in their Google Account settings, your app has more than 50 refresh tokens per user (Google automatically invalidates the oldest), or your OAuth app's credentials are deleted and recreated. If your refresh token stops working, re-run the OAuth authorization flow and update GOOGLE_REFRESH_TOKEN in Replit Secrets with the new token.

### What deployment type should I use for a Google Meet integration on Replit?

Autoscale works well for most Google Meet integration scenarios — meeting creation is event-driven (triggered by user actions or webhooks), and Autoscale scales to zero when idle. If your app handles real-time booking flows where users expect immediate Meet link generation (e.g., a live scheduling widget), the 1-3 second cold start on Autoscale is acceptable since Calendar API calls take that long anyway.

### How do I cancel or update a Google Meet meeting from Replit?

Use the Calendar API events.delete() method with the event ID to cancel a meeting (this also removes it from all attendees' calendars and sends cancellation notifications if sendUpdates is set to 'all'). For updates (changing time, adding attendees), use events.patch() with only the fields you want to change. Always store the event ID in your database when creating meetings, as you need it for subsequent operations.

---

Source: https://www.rapidevelopers.com/replit-integration/google-meet
© RapidDev — https://www.rapidevelopers.com/replit-integration/google-meet