How to Integrate Google Meet with V0

Google Meet links are created through the Google Calendar API, so your first step is enabling that API and creating OAuth2 credentials in Google Cloud Console. Go to Google Cloud Console (console.cloud.google.com). Select or create a project. Go to APIs & Services → Library, search for 'Google Calendar API', and click Enable. Next, create OAuth2 credentials. Go to APIs & Services → Credentials → Create Credentials → OAuth client ID. Choose Web application as the application type. Add your redirect URIs: https://your-app.vercel.app/api/google/callback for production and http://localhost:3000/api/google/callback for local development. After creating the credentials, download the JSON file or copy the Client ID and Client Secret. You also need to configure the OAuth consent screen (APIs & Services → OAuth consent screen). For testing, choose External but add your own email as a test user — this lets you test the OAuth flow without going through Google's app verification process. For production apps used by external Google accounts, you will need to go through Google's verification process if your app requests sensitive scopes. The scope you need is https://www.googleapis.com/auth/calendar.events — this allows creating and reading calendar events. If you also need to read existing calendar data (for availability checking), add https://www.googleapis.com/auth/calendar.readonly. One important Google Meet-specific limitation: meeting recording links, attendance reports, and in-meeting chat transcripts are not accessible via API. The Calendar API only gives you the meeting link (join URL) and basic meeting metadata.

Google Calendar operations on behalf of users require OAuth2 authorization. Implement the authorization flow with two API routes: one to initiate authorization and one to handle the callback. Install the googleapis package: npm install googleapis. This is Google's official Node.js client library for all Google APIs. Create app/api/google/auth/route.ts. This route builds the Google authorization URL using the google.auth.OAuth2 client and redirects users to it. Set the scopes to include https://www.googleapis.com/auth/calendar.events and pass access_type=offline to receive a refresh token (so users do not need to re-authorize after their access token expires in one hour). Create app/api/google/callback/route.ts. This route receives the authorization code from Google, exchanges it for tokens using oauth2Client.getToken(code), stores the tokens, and redirects the user back to your app. The refresh_token in the response is particularly important — store it persistently (in a database or secure cookie) because Google only sends it on the first authorization unless the user explicitly re-grants access. For a simpler single-account setup (e.g., scheduling meetings in your own calendar on behalf of users), use a service account instead of OAuth2. This avoids the user-facing auth flow entirely but requires a Google Workspace account with domain-wide delegation enabled.

1// app/api/google/auth/route.ts
2import { google } from 'googleapis';
3import { NextResponse } from 'next/server';
4
5export async function GET() {
6  const 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  const authUrl = oauth2Client.generateAuthUrl({
13    access_type: 'offline',
14    prompt: 'consent',
15    scope: [
16      'https://www.googleapis.com/auth/calendar.events',
17    ],
18  });
19
20  return NextResponse.redirect(authUrl);
21}
22
23// app/api/google/callback/route.ts
24import { google } from 'googleapis';
25import { NextRequest, NextResponse } from 'next/server';
26import { cookies } from 'next/headers';
27
28export async function GET(request: NextRequest) {
29  const { searchParams } = new URL(request.url);
30  const code = searchParams.get('code');
31
32  if (!code) {
33    return NextResponse.json({ error: 'No code provided' }, { status: 400 });
34  }
35
36  const oauth2Client = new google.auth.OAuth2(
37    process.env.GOOGLE_CLIENT_ID,
38    process.env.GOOGLE_CLIENT_SECRET,
39    process.env.GOOGLE_REDIRECT_URI
40  );
41
42  const { tokens } = await oauth2Client.getToken(code);
43
44  const cookieStore = await cookies();
45  cookieStore.set('google_tokens', JSON.stringify(tokens), {
46    httpOnly: true,
47    secure: process.env.NODE_ENV === 'production',
48    maxAge: 30 * 24 * 60 * 60,
49    path: '/',
50  });
51
52  return NextResponse.redirect(new URL('/dashboard', request.url));
53}

With OAuth2 working, create the API route that generates Google Meet links. The route creates a Google Calendar event with conferenceDataVersion=1 and a conferenceData object containing a createRequest — this tells Google to provision a Meet conference and attach it to the event. Create app/api/meetings/create/route.ts. The route receives the meeting details in the request body (title, start time, end time, attendee emails), initializes the Google OAuth2 client with stored tokens, creates the calendar event with conferenceData, and returns the Meet link from the response. The conferenceData.entryPoints array in the response contains the join URLs. The entry point with entryPointType === 'video' is the main browser/app join URL. There may also be phone entry points for dial-in access. Adding attendees to the calendar event (attendees array with email fields) sends them Google Calendar invitations with the Meet link. Set sendNotifications: true on the event insert if you want Google to send invitation emails. Handle token expiration in the API route: if the googleapis client throws an error about an invalid grant or expired token, refresh the access token using the stored refresh token and retry the request. The googleapis library can handle this automatically if you call oauth2Client.setCredentials(tokens) with a valid refresh token — it will auto-refresh when needed.

1// app/api/meetings/create/route.ts
2import { google } from 'googleapis';
3import { NextRequest, NextResponse } from 'next/server';
4import { cookies } from 'next/headers';
5import { randomUUID } from 'crypto';
6
7export async function POST(request: NextRequest) {
8  const body = await request.json();
9  const { title, description, startTime, endTime, attendeeEmails = [] } = body;
10
11  if (!title || !startTime || !endTime) {
12    return NextResponse.json(
13      { error: 'title, startTime, and endTime are required' },
14      { status: 400 }
15    );
16  }
17
18  const cookieStore = await cookies();
19  const tokensRaw = cookieStore.get('google_tokens')?.value;
20
21  if (!tokensRaw) {
22    return NextResponse.json({ error: 'Not authenticated with Google' }, { status: 401 });
23  }
24
25  const tokens = JSON.parse(tokensRaw);
26
27  const oauth2Client = new google.auth.OAuth2(
28    process.env.GOOGLE_CLIENT_ID,
29    process.env.GOOGLE_CLIENT_SECRET,
30    process.env.GOOGLE_REDIRECT_URI
31  );
32
33  oauth2Client.setCredentials(tokens);
34
35  const calendar = google.calendar({ version: 'v3', auth: oauth2Client });
36
37  const attendees = attendeeEmails.map((email: string) => ({ email }));
38
39  const event = await calendar.events.insert({
40    calendarId: 'primary',
41    conferenceDataVersion: 1,
42    sendNotifications: true,
43    requestBody: {
44      summary: title,
45      description: description ?? '',
46      start: { dateTime: startTime, timeZone: 'UTC' },
47      end: { dateTime: endTime, timeZone: 'UTC' },
48      attendees,
49      conferenceData: {
50        createRequest: {
51          requestId: randomUUID(),
52          conferenceSolutionKey: { type: 'hangoutsMeet' },
53        },
54      },
55    },
56  });
57
58  const meetLink = event.data.conferenceData?.entryPoints?.find(
59    (ep) => ep.entryPointType === 'video'
60  )?.uri ?? null;
61
62  return NextResponse.json({
63    eventId: event.data.id,
64    meetLink,
65    htmlLink: event.data.htmlLink,
66  });
67}

Add your Google OAuth2 credentials to Vercel so they are available in your deployed API routes. In Vercel Dashboard → Settings → Environment Variables, add the following for Production, Preview, and Development scopes. GOOGLE_CLIENT_ID: the Client ID from your OAuth2 credentials in Google Cloud Console → APIs & Services → Credentials. This is used to identify your application to Google. GOOGLE_CLIENT_SECRET: the Client Secret. Never prefix with NEXT_PUBLIC_ — this must stay server-side. GOOGLE_REDIRECT_URI: the full callback URL. Use https://your-app.vercel.app/api/google/callback for Production and http://localhost:3000/api/google/callback for Development. This must match exactly what you registered in Google Cloud Console. For local development, add the same variables to .env.local. Ensure the development redirect URI (http://localhost:3000/api/google/callback) is also listed in your Google Cloud Console credentials. After adding variables, redeploy your app. Test the full flow: navigate to /api/google/auth, complete Google authorization, and then test /api/meetings/create with a sample POST body.

With the API routes working, use V0 to generate the meeting scheduling interface. Describe the exact booking flow to V0: a date and time picker, an attendee email input, and a success state that displays the Meet link. V0 generates excellent form components with Tailwind CSS and shadcn/ui. Ask it to create a scheduling form that validates inputs before submitting (required fields, valid email formats, start time before end time), calls your /api/meetings/create endpoint, and shows the Meet link in a copyable display after success. For date and time pickers, V0 typically uses the shadcn/ui Calendar and TimePicker components or the react-day-picker library. Specify which you prefer, or let V0 choose — both produce clean interfaces. Consider asking V0 to add a 'Copy Link' button with clipboard API support next to the Meet link display. This is one of the most important UX elements in a meeting scheduler — users need to copy the Meet link to share it or add it to their own calendar. For complex scheduling features like availability checking (preventing double-booking), time zone handling for distributed teams, or integration with external calendars, RapidDev's team can help architect a more complete scheduling solution built on top of this foundation.