Automating Google Meet Creation

Automating Google Meet Creation with Google Calendar API and Service Account

In this blog post, we will walk through the process of automatically creating a Google Meet link by creating a Google Calendar event using the Google Calendar API. We'll use a service account to authenticate, making it possible to create events on behalf of a user in your Google Workspace domain.

Prerequisites

Before we get started, make sure you have the following:

• A Google Cloud Project with the Google Calendar API enabled.
• A Service Account created and its JSON key file downloaded.
• Domain-Wide Delegation of Authority enabled for the Service Account.
• Access to your Google Admin Console to grant the necessary permissions.
• Basic knowledge of Node.js and API requests.

Steps to Create Google Meet Automatically

Step 1: Set Up Google Cloud Project

1. Go to the Google Cloud Console.
2. Create a new project or select an existing one.
3. Enable the Google Calendar API:
   • In the sidebar, search for Calendar API and enable it for your project.
4. Create a Service Account:
   • In the IAM & Admin section, create a new service account.
   • Download the JSON key for the service account.

Step 2: Enable Domain-Wide Delegation

1. Go to the Google Admin Console (admin.google.com).
2. Navigate to Security → API Controls → Manage Domain-Wide Delegation.
3. Add a new Client ID for the service account:
   • Find the Client ID in the Google Cloud Console under your service account.
   • Add the service account’s OAuth scopes, which are required for accessing Google Calendar:
     • https://www.googleapis.com/auth/calendar
4. Grant the service account permission to impersonate users in your domain.

Step 3: Install Required Packages

You need a few Node.js packages to interact with the Google API and handle JWT signing:

npm install google-auth-library jsonwebtoken node-fetch

Step 4: Generate JWT Token for Authentication

Next, we’ll write a Node.js script to generate a JWT (JSON Web Token) to authenticate the service account.

const fs = require('fs');
const jwt = require('jsonwebtoken');

// Path to your service account JSON file
const SERVICE_ACCOUNT_KEY_FILE = '/path/to/your/service-account-key.json';

// Scopes required for the API
const SCOPES = ['https://www.googleapis.com/auth/calendar']; // Full calendar access
const AUDIENCE = 'https://oauth2.googleapis.com/token';

async function generateJWT() {
    try {
        // Read and parse the service account credentials
        const serviceAccount = JSON.parse(fs.readFileSync(SERVICE_ACCOUNT_KEY_FILE, 'utf8'));

        // JWT payload
        const jwtPayload = {
            iss: serviceAccount.client_email,       // Issuer: service account email
            sub: '[e-mail]',                // Subject: email of the user whose calendar to access
            aud: AUDIENCE,                          // Audience: Google token URL
            scope: SCOPES.join(' '),                // Scopes: space-separated list of scopes
            iat: Math.floor(Date.now() / 1000),     // Issued at: current time in seconds
            exp: Math.floor(Date.now() / 1000) + 3600 // Expiration: 1 hour from now
        };

        // Sign the JWT using the service account's private key
        const signedJwt = jwt.sign(jwtPayload, serviceAccount.private_key, { algorithm: 'RS256' });

        console.log('Generated JWT:', signedJwt);
    } catch (error) {
        console.error('Error generating JWT:', error);
    }
}

generateJWT();

Step 5: Exchange JWT for OAuth 2.0 Token

Now, use the JWT to obtain an OAuth 2.0 token from Google’s OAuth 2.0 token endpoint:

const fetch = require('node-fetch');

async function getAccessToken(signedJwt) {
    const response = await fetch('https://oauth2.googleapis.com/token', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
        },
        body: new URLSearchParams({
            'grant_type': 'urn:ietf:params:oauth:grant-type:jwt-bearer',
            'assertion': signedJwt
        })
    });
    const data = await response.json();
    return data.access_token;
}

Step 6: Create a Google Calendar Event with Google Meet Link

Using the access token, we can now create a Google Calendar event with a Google Meet link.

async function createCalendarEvent(accessToken) {
    const eventData = {
        summary: "Meeting with Rajeen Test",
        description: "Discuss project updates",
        start: {
            dateTime: "2025-01-16T10:00:00+05:30", // Start time in IST
            timeZone: "Asia/Kolkata"               // Explicitly specify IST time zone
        },
        end: {
            dateTime: "2025-01-16T12:00:00+05:30", // End time in IST
            timeZone: "Asia/Kolkata"               // Explicitly specify IST time zone
        },
        attendees: [
            { email: "[e-mail]" },
            { email: "[e-mail]" }
        ],
        conferenceDataVersion: 1, // Add this to enable Meet links
        conferenceData: {
            createRequest: {
                conferenceSolutionKey: { type: "hangoutsMeet" },
                requestId: "unique-request-id"
            }
        }
    };


    const response = await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events?conferenceDataVersion=1&sendUpdates=all', {
        //&sendUpdates=all (this is to send maill notification)
        method: 'POST',
        headers: {
            'Authorization': `Bearer ${accessToken}`,
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(eventData)
    });

    const responseBody = await response.json();

    if (!response.ok) {
        console.error('Error creating event:', responseBody);
        throw new Error('Failed to create calendar event');
    }

    console.log('Event created successfully:', responseBody);
    console.log('Meet Link:', responseBody.hangoutLink); // Print the Google Meet link
}

Step 7: Run the Full Process

Combine all the parts and run the script to create the Google Meet event automatically.

(async () => {
    const signedJwt = await generateJWT();
    const accessToken = await getAccessToken(signedJwt);
    await createEvent(accessToken);
})();

Conclusion

With the above steps, you can create Google Calendar events with Google Meet links automatically, using a service account and Domain-Wide Delegation of Authority. This method is perfect for automating meetings in a Google Workspace domain.

By enabling Domain-Wide Delegation and configuring the service account to impersonate users, you can access and manage Google Calendar events programmatically, which is extremely useful for enterprise environments.

Happy coding! ✨