How to Integrate Bolt.new with GoToMeeting

GoToMeeting API access goes through the unified GoTo developer platform. Navigate to developer.goto.com and sign in with your GoToMeeting account. Click 'Add App' to create a new developer application. Name it something identifiable like 'Meeting Scheduler' and select 'GoToMeeting' from the product dropdown. Under 'OAuth Settings', set the authorization type to 'Authorization Code' and enter your redirect URI — this must be the URL of your deployed callback route (e.g., https://your-app.netlify.app/api/gotomeeting/callback). GoToMeeting strictly enforces exact URI matching, so there must be no trailing slashes or URL differences between what you register and what your app sends. After saving, you receive a Client ID and Client Secret. The Client ID is public and appears in your authorization URL. The Client Secret is sensitive — it's used to exchange authorization codes for access tokens and must never appear in client-side code. For the OAuth scope, request 'meeting:create meeting:read' to cover both creating and reading meeting data. Note that GoToMeeting and GoToWebinar share the same OAuth system — if you already have a GoTo developer app for GoToWebinar, you can add GoToMeeting scopes to the same app rather than creating a new one.

1# .env
2GOTOMEETING_CLIENT_ID=your_client_id_here
3GOTOMEETING_CLIENT_SECRET=your_client_secret_here
4GOTOMEETING_REDIRECT_URI=https://your-app.netlify.app/api/gotomeeting/callback

Create the two routes that handle the OAuth flow: the authorization redirect and the callback handler. The authorization route builds a URL to GoToMeeting's OAuth endpoint with your client ID, redirect URI, response type (code), and scopes. When a user visits this route, they're redirected to GoToMeeting's consent screen where they approve access. After approval, GoToMeeting redirects to your callback route with an authorization code as a query parameter. The callback route exchanges this code for access and refresh tokens by making a POST request to GoToMeeting's token endpoint using Basic Auth (Client ID and Secret base64-encoded). The token response includes the access token (valid 1 hour), refresh token (valid until revoked or unused for 90 days), and the organizer key that identifies which GoToMeeting account authorized your app. Store all three values in your database. Build a utility function that retrieves the current access token and refreshes it automatically if it's expired or about to expire. This refresh logic runs invisibly before every GoToMeeting API call, ensuring your app never fails with a 401 error due to token expiry. Remember: this entire OAuth flow must happen from your deployed site, not from Bolt's WebContainer preview.

1// app/api/gotomeeting/callback/route.ts
2import { NextResponse } from 'next/server';
3
4export async function GET(request: Request) {
5  const { searchParams } = new URL(request.url);
6  const code = searchParams.get('code');
7  const error = searchParams.get('error');
8
9  if (error || !code) {
10    return NextResponse.redirect(new URL('/admin/meetings?error=auth_failed', request.url));
11  }
12
13  const credentials = Buffer.from(
14    `${process.env.GOTOMEETING_CLIENT_ID}:${process.env.GOTOMEETING_CLIENT_SECRET}`
15  ).toString('base64');
16
17  try {
18    const tokenResponse = await fetch(
19      'https://authentication.logmeininc.com/oauth/token',
20      {
21        method: 'POST',
22        headers: {
23          Authorization: `Basic ${credentials}`,
24          'Content-Type': 'application/x-www-form-urlencoded',
25        },
26        body: new URLSearchParams({
27          grant_type: 'authorization_code',
28          code,
29          redirect_uri: process.env.GOTOMEETING_REDIRECT_URI!,
30        }),
31      }
32    );
33
34    const tokens = await tokenResponse.json();
35
36    // Store tokens in your database here:
37    console.log('Tokens received:', {
38      accessToken: tokens.access_token,
39      refreshToken: tokens.refresh_token,
40      organizerKey: tokens.organizer_key,
41      expiresAt: Date.now() + tokens.expires_in * 1000,
42    });
43
44    return NextResponse.redirect(new URL('/admin/meetings?auth=success', request.url));
45  } catch (err: unknown) {
46    const e = err as { message: string };
47    return NextResponse.redirect(
48      new URL(`/admin/meetings?error=${encodeURIComponent(e.message)}`, request.url)
49    );
50  }
51}

With valid OAuth tokens, you can create GoToMeeting sessions programmatically. GoToMeeting's API base URL for meeting operations is https://api.getgo.com/G2M/rest/v2/organizers/{organizerKey}/meetings. Creating a meeting requires a subject (meeting name), a start time and end time in ISO 8601 format, and a conferenceCallInfo object specifying how attendees can call in. GoToMeeting returns a meetingKey (unique meeting ID) and a joinURL that you display to the meeting host and share with attendees. For instant meetings (starting immediately), use the current time as the start time and set the end time 60 minutes later. For scheduled meetings, use whatever start and end times the user specifies. GoToMeeting supports both scheduled and instant meeting types. The API also supports recurring meetings through a recurrenceType field, though this requires additional parameters. Store the meetingKey in your database alongside the meeting details — you'll need it to fetch attendees, update the meeting, or retrieve recordings after the session ends. Unlike GoToWebinar, GoToMeeting doesn't have a registration system — join URLs are shared directly with attendees who can join without pre-registering.

1// app/api/gotomeeting/meetings/route.ts
2import { NextResponse } from 'next/server';
3
4const GTM_BASE = 'https://api.getgo.com/G2M/rest/v2';
5
6export async function POST(request: Request) {
7  // In production, fetch these from your database:
8  const accessToken = process.env.GOTOMEETING_ACCESS_TOKEN;
9  const organizerKey = process.env.GOTOMEETING_ORGANIZER_KEY;
10
11  const { subject, startTime, endTime } = await request.json();
12
13  if (!subject || !startTime || !endTime) {
14    return NextResponse.json(
15      { error: 'subject, startTime, and endTime are required' },
16      { status: 400 }
17    );
18  }
19
20  try {
21    const response = await fetch(
22      `${GTM_BASE}/organizers/${organizerKey}/meetings`,
23      {
24        method: 'POST',
25        headers: {
26          Authorization: `Bearer ${accessToken}`,
27          'Content-Type': 'application/json',
28          Accept: 'application/json',
29        },
30        body: JSON.stringify({
31          subject,
32          starttime: startTime,
33          endtime: endTime,
34          conferenceCallInfo: 'Hybrid',
35          passwordRequired: false,
36          meetingType: 'scheduled',
37        }),
38      }
39    );
40
41    const data = await response.json();
42
43    if (!response.ok) {
44      return NextResponse.json({ error: data }, { status: response.status });
45    }
46
47    return NextResponse.json({
48      meetingKey: data[0]?.meetingKey || data.meetingKey,
49      joinURL: data[0]?.joinURL || data.joinURL,
50      subject,
51      startTime,
52      endTime,
53    });
54  } catch (error: unknown) {
55    const e = error as { message: string };
56    return NextResponse.json({ error: e.message }, { status: 500 });
57  }
58}

The final step is building the user-facing UI that shows scheduled meetings and past recordings. GoToMeeting's GET meetings endpoint returns all meetings for an organizer within a date range, with each meeting containing its key, subject, times, and join URL. Past meetings automatically appear in the history endpoint after they end. For recordings, GoToMeeting stores recordings in the cloud (GoToMeeting Cloud Recording) for organizers with the feature enabled. You fetch recordings for a specific meeting by calling the recordings endpoint with the meeting's key. The recording response includes asset URLs for downloading the video, which are time-limited signed URLs. GoToMeeting recordings are stored for 1 year by default, after which they're deleted unless downloaded. A common pattern is to fetch recording URLs from GoToMeeting's API and either display them directly for immediate viewing or download and re-upload them to your own storage (like Supabase Storage or AWS S3) for long-term access. Build the meetings dashboard with two tabs: upcoming and past. Upcoming shows join links users can share; past shows recordings with a direct link to the GoToMeeting recording player or a download button. This gives users a complete meeting history without needing to log into GoToMeeting's interface.