How to Integrate Replit with Google Meet

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

1// google-auth.js — OAuth 2.0 flow for Google Calendar API
2const { google } = require('googleapis');
3const express = require('express');
4const app = express();
5
6const oauth2Client = new google.auth.OAuth2(
7  process.env.GOOGLE_CLIENT_ID,
8  process.env.GOOGLE_CLIENT_SECRET,
9  process.env.GOOGLE_REDIRECT_URI
10);
11
12// If we have a refresh token already, set it up
13if (process.env.GOOGLE_REFRESH_TOKEN) {
14  oauth2Client.setCredentials({
15    refresh_token: process.env.GOOGLE_REFRESH_TOKEN
16  });
17  console.log('Google OAuth: using stored refresh token');
18}
19
20// Step 1: Redirect user to Google's authorization page
21app.get('/auth/google', (req, res) => {
22  const authUrl = oauth2Client.generateAuthUrl({
23    access_type: 'offline',      // Request a refresh token
24    prompt: 'consent',           // Force consent to get refresh token every time
25    scope: [
26      'https://www.googleapis.com/auth/calendar.events',
27      'https://www.googleapis.com/auth/calendar.readonly'
28    ]
29  });
30  res.redirect(authUrl);
31});
32
33// Step 2: Handle the OAuth callback — exchange code for tokens
34app.get('/auth/callback', async (req, res) => {
35  const { code, error } = req.query;
36  if (error) return res.status(400).send(`Authorization denied: ${error}`);
37
38  try {
39    const { tokens } = await oauth2Client.getToken(code);
40    oauth2Client.setCredentials(tokens);
41
42    console.log('=== SAVE THESE TO REPLIT SECRETS ===');
43    console.log('GOOGLE_REFRESH_TOKEN:', tokens.refresh_token);
44    console.log('====================================');
45
46    // In production: store tokens.refresh_token in your database
47    // For setup: manually copy it to Replit Secrets as GOOGLE_REFRESH_TOKEN
48    res.send('Authorization successful! Check the console for your refresh token. Add it to Replit Secrets as GOOGLE_REFRESH_TOKEN.');
49  } catch (err) {
50    console.error('Token exchange error:', err.message);
51    res.status(500).send('Authorization failed. Check the console for details.');
52  }
53});
54
55module.exports = { oauth2Client };
56
57app.listen(3000, '0.0.0.0', () => {
58  console.log('Auth server running. Visit /auth/google to authorize.');
59});

1// create-meet.js — Create Google Calendar event with Meet link
2const { google } = require('googleapis');
3
4const oauth2Client = new google.auth.OAuth2(
5  process.env.GOOGLE_CLIENT_ID,
6  process.env.GOOGLE_CLIENT_SECRET,
7  process.env.GOOGLE_REDIRECT_URI
8);
9
10// Load stored refresh token
11oauth2Client.setCredentials({
12  refresh_token: process.env.GOOGLE_REFRESH_TOKEN
13});
14
15const calendar = google.calendar({ version: 'v3', auth: oauth2Client });
16
17async function createMeetEvent({
18  title,
19  description = '',
20  startDateTime,     // ISO 8601: '2026-04-01T14:00:00-05:00'
21  endDateTime,       // ISO 8601: '2026-04-01T15:00:00-05:00'
22  attendeeEmails = [],
23  timeZone = 'America/New_York'
24}) {
25  const event = {
26    summary: title,
27    description,
28    start: { dateTime: startDateTime, timeZone },
29    end: { dateTime: endDateTime, timeZone },
30    attendees: attendeeEmails.map(email => ({ email })),
31    conferenceData: {
32      createRequest: {
33        requestId: `meet-${Date.now()}`, // Unique ID to prevent duplicate creation
34        conferenceSolutionKey: { type: 'hangoutsMeet' }
35      }
36    }
37  };
38
39  const response = await calendar.events.insert({
40    calendarId: 'primary',
41    requestBody: event,
42    conferenceDataVersion: 1,  // REQUIRED to generate Meet link
43    sendUpdates: 'all'         // Send invitation emails to attendees
44  });
45
46  const createdEvent = response.data;
47  const meetLink = createdEvent.conferenceData?.entryPoints
48    ?.find(ep => ep.entryPointType === 'video')?.uri;
49
50  console.log('Event created:', createdEvent.id);
51  console.log('Meet link:', meetLink);
52  console.log('Calendar link:', createdEvent.htmlLink);
53
54  return {
55    eventId: createdEvent.id,
56    meetLink,
57    calendarLink: createdEvent.htmlLink,
58    startDateTime: createdEvent.start.dateTime
59  };
60}
61
62// Example: create a meeting in 1 hour
63(async () => {
64  const start = new Date(Date.now() + 3600000).toISOString();
65  const end = new Date(Date.now() + 7200000).toISOString();
66  const meeting = await createMeetEvent({
67    title: 'Product Demo',
68    description: 'Demo of the new feature set',
69    startDateTime: start,
70    endDateTime: end,
71    attendeeEmails: ['client@example.com'],
72    timeZone: 'America/New_York'
73  });
74  console.log('Meeting details:', meeting);
75})();
76
77module.exports = { createMeetEvent };

1# create_meet.py — Create Google Meet events with Python on Replit
2import os
3from google.oauth2.credentials import Credentials
4from google.auth.transport.requests import Request
5from googleapiclient.discovery import build
6from datetime import datetime, timedelta, timezone
7
8def get_calendar_service():
9    """Initialize and return an authenticated Google Calendar service."""
10    creds = Credentials(
11        token=None,
12        refresh_token=os.environ['GOOGLE_REFRESH_TOKEN'],
13        token_uri='https://oauth2.googleapis.com/token',
14        client_id=os.environ['GOOGLE_CLIENT_ID'],
15        client_secret=os.environ['GOOGLE_CLIENT_SECRET'],
16        scopes=['https://www.googleapis.com/auth/calendar.events']
17    )
18    # Auto-refresh the access token if expired
19    if creds.expired or not creds.valid:
20        creds.refresh(Request())
21
22    return build('calendar', 'v3', credentials=creds)
23
24def create_meet_event(
25    title: str,
26    start_dt: datetime,
27    end_dt: datetime,
28    attendee_emails: list = None,
29    description: str = '',
30    time_zone: str = 'America/New_York'
31) -> dict:
32    """Create a Google Calendar event with a Google Meet link."""
33    service = get_calendar_service()
34
35    event = {
36        'summary': title,
37        'description': description,
38        'start': {
39            'dateTime': start_dt.isoformat(),
40            'timeZone': time_zone
41        },
42        'end': {
43            'dateTime': end_dt.isoformat(),
44            'timeZone': time_zone
45        },
46        'attendees': [{'email': e} for e in (attendee_emails or [])],
47        'conferenceData': {
48            'createRequest': {
49                'requestId': f'meet-{int(start_dt.timestamp())}',
50                'conferenceSolutionKey': {'type': 'hangoutsMeet'}
51            }
52        }
53    }
54
55    result = service.events().insert(
56        calendarId='primary',
57        body=event,
58        conferenceDataVersion=1,  # Required to generate Meet link
59        sendUpdates='all'
60    ).execute()
61
62    # Extract Meet link from entry points
63    meet_link = None
64    entry_points = result.get('conferenceData', {}).get('entryPoints', [])
65    for ep in entry_points:
66        if ep.get('entryPointType') == 'video':
67            meet_link = ep.get('uri')
68            break
69
70    print(f'Event created: {result["id"]}')
71    print(f'Meet link: {meet_link}')
72
73    return {
74        'event_id': result['id'],
75        'meet_link': meet_link,
76        'calendar_link': result.get('htmlLink'),
77        'start': result['start']['dateTime']
78    }
79
80if __name__ == '__main__':
81    # Create a meeting starting in 1 hour for 1 hour
82    now = datetime.now(timezone.utc)
83    start = now + timedelta(hours=1)
84    end = now + timedelta(hours=2)
85    meeting = create_meet_event(
86        title='Demo Call',
87        start_dt=start,
88        end_dt=end,
89        attendee_emails=['client@example.com']
90    )
91    print('Meeting created:', meeting)

1// meet-server.js — Express API for creating Google Meet events
2const express = require('express');
3const { google } = require('googleapis');
4const app = express();
5app.use(express.json());
6
7const oauth2Client = new google.auth.OAuth2(
8  process.env.GOOGLE_CLIENT_ID,
9  process.env.GOOGLE_CLIENT_SECRET,
10  process.env.GOOGLE_REDIRECT_URI
11);
12oauth2Client.setCredentials({ refresh_token: process.env.GOOGLE_REFRESH_TOKEN });
13const calendar = google.calendar({ version: 'v3', auth: oauth2Client });
14
15// POST /meetings — create a meeting with Meet link
16app.post('/meetings', async (req, res) => {
17  try {
18    const { title, startDateTime, endDateTime, attendees = [], description = '', timeZone = 'UTC' } = req.body;
19    if (!title || !startDateTime || !endDateTime) {
20      return res.status(400).json({ error: 'title, startDateTime, and endDateTime are required' });
21    }
22
23    const event = {
24      summary: title,
25      description,
26      start: { dateTime: startDateTime, timeZone },
27      end: { dateTime: endDateTime, timeZone },
28      attendees: attendees.map(email => ({ email })),
29      conferenceData: {
30        createRequest: {
31          requestId: `meet-${Date.now()}`,
32          conferenceSolutionKey: { type: 'hangoutsMeet' }
33        }
34      }
35    };
36
37    const response = await calendar.events.insert({
38      calendarId: 'primary',
39      requestBody: event,
40      conferenceDataVersion: 1,
41      sendUpdates: 'all'
42    });
43
44    const meetLink = response.data.conferenceData?.entryPoints
45      ?.find(ep => ep.entryPointType === 'video')?.uri;
46
47    res.status(201).json({
48      eventId: response.data.id,
49      meetLink,
50      calendarLink: response.data.htmlLink
51    });
52  } catch (err) {
53    console.error('Calendar API error:', err.message);
54    res.status(500).json({ error: err.message });
55  }
56});
57
58// DELETE /meetings/:eventId — cancel a meeting
59app.delete('/meetings/:eventId', async (req, res) => {
60  try {
61    await calendar.events.delete({
62      calendarId: 'primary',
63      eventId: req.params.eventId,
64      sendUpdates: 'all'
65    });
66    res.json({ deleted: true, eventId: req.params.eventId });
67  } catch (err) {
68    res.status(500).json({ error: err.message });
69  }
70});
71
72app.listen(3000, '0.0.0.0', () => console.log('Meet API server running on port 3000'));