# How to Integrate Retool with GoToMeeting

- Tool: Retool
- Difficulty: Intermediate
- Time required: 20 minutes
- Last updated: April 2026

## TL;DR

Connect Retool to GoToMeeting using a REST API Resource authenticated with GoTo's OAuth 2.0. Once configured, query GoTo's REST API to list scheduled meetings, create new sessions, view attendee records, and build a meeting management dashboard with one-click booking capabilities. GoTo's unified OAuth works across GoToMeeting, GoToWebinar, and GoToConnect from a single resource configuration.

## Why connect Retool to GoToMeeting?

GoToMeeting's native web interface is designed for individual meeting management — scheduling sessions, joining calls, reviewing recordings. It does not provide organizational-level views: who has the most meetings this week, which meeting rooms are double-booked, how many external client calls happened last month. Retool fills this gap by surfacing GoToMeeting data in customizable internal dashboards where ops teams and managers can see meeting patterns, schedule on behalf of others, and combine meeting data with CRM or project management data.

The most common Retool-GoToMeeting integrations are scheduling tools and meeting analytics. An internal meeting scheduler lets support, sales, or HR staff book client-facing sessions from within Retool — selecting an organizer from a dropdown, setting the time and topic, and having the GoTo API create the meeting and return the join link. Meeting analytics dashboards pull historical meeting data to show busy periods, average attendance, and session duration trends — data that is difficult to extract from GoToMeeting's native reporting.

GoTo's API is straightforward: authentication is standard OAuth 2.0, endpoints follow RESTful conventions, and the meeting object structure is consistent and well-documented. The same access token can be used across GoTo products (GoToMeeting, GoToWebinar, GoToConnect) making it efficient to build a single Retool app that manages multiple GoTo communications services together.

## Before you start

- A GoToMeeting account (organizer or admin level) with an active subscription
- A registered GoTo developer app with OAuth 2.0 Client ID and Client Secret (create at developer.goto.com)
- The GoTo OAuth scopes configured for your app: collab:meetings:read and collab:meetings:write for meeting management
- A Retool account with Resource creation permissions
- Basic familiarity with OAuth 2.0 authorization flows

## Step-by-step guide

### 1. Register a GoTo developer app and obtain OAuth credentials

Navigate to GoTo Developer Center at developer.goto.com and sign in with your GoToMeeting account credentials. Click My Apps in the top navigation and then Create an App. Give the app a name like Retool Meeting Manager and select OAuth as the authentication type. Choose the appropriate product scope — select GoToMeeting for meeting access. In the Redirect URIs section, add Retool's OAuth callback URL: https://oauth.retool.com/oauth/user/oauthcallback for Retool Cloud, or your self-hosted Retool instance's equivalent callback URL. Select the required OAuth scopes for your integration: collab:meetings:read to list and view meetings, collab:meetings:write to create and modify meetings. If you also plan to access GoToWebinar from the same app, add the webinar scopes as well. Save the app. GoTo generates a Client ID and Client Secret — copy both values securely. Note your account's organizer key, which is available in your GoToMeeting account settings and is required as a URL parameter in most GoToMeeting API endpoints (the organizer key identifies which GoToMeeting account's data to retrieve). The Client ID and Client Secret will be entered into Retool's Resource configuration in the next step.

**Expected result:** A GoTo developer app is created at developer.goto.com with the Retool OAuth callback URL configured, and you have the Client ID, Client Secret, and your GoToMeeting organizer key ready.

### 2. Create the GoToMeeting REST API Resource in Retool

Navigate to the Resources tab in Retool and click Add Resource → REST API. Name the resource GoToMeeting API. Set the Base URL to https://api.getgo.com. In the Authentication section, select OAuth 2.0. Fill in the OAuth fields: Authorization URL as https://authentication.logmeininc.com/oauth/authorize, Token URL as https://authentication.logmeininc.com/oauth/token, your Client ID and Client Secret from the developer portal, and Scope as collab:meetings:read collab:meetings:write (space-separated). The GoTo OAuth endpoints use LogMeIn's authentication infrastructure even for GoToMeeting — this is expected. Click Save and then click the Connect button to trigger the OAuth authorization flow. A GoTo sign-in popup appears where you log in with your GoToMeeting organizer account and authorize the app. After authorization, the resource shows as Connected. To configure the organizer key for queries, navigate to Settings → Configuration Variables and add a variable named GOTO_ORGANIZER_KEY containing your GoToMeeting organizer key (found in your GoToMeeting account at app.goto.com → Profile → My Account). This key will be referenced in API endpoint paths as a URL segment.

**Expected result:** The GoToMeeting REST API Resource is Connected in Retool with the base URL set to https://api.getgo.com and the organizer key stored in a configuration variable.

### 3. Query upcoming meetings and display them in a Table

Create a new query named getUpcomingMeetings in the Code panel. Select the GoToMeeting API resource. Set the HTTP method to GET and the path to /G2M/rest/v2/organizers/{{ retoolContext.configVars.GOTO_ORGANIZER_KEY }}/upcomingMeetings. Add the query parameter fromDate set to {{ new Date().toISOString().split('T')[0] }} to get meetings starting from today, and toDate set to {{ new Date(Date.now() + 30*24*60*60*1000).toISOString().split('T')[0] }} for the next 30 days. Click Run. GoTo returns a meetings array with objects containing: meetingId, subject, startTime, endTime, status, maxParticipants, and hostExitUrl. Create a JavaScript transformer to reshape the data: calculate duration in minutes from startTime and endTime, format the dates for display, and extract the join URL from the meeting object. Drag a Table component onto the canvas and bind it to {{ getUpcomingMeetings.data }}. Configure columns: subject, date (formatted), start_time, duration_min (labeled Duration (min)), and a Link component using the joinUrl field for one-click meeting access. Add a Refresh button with onClick event triggering getUpcomingMeetings. Set the query to auto-run on page load.

```
// Transformer: format GoToMeeting upcoming meetings for Table display
const meetings = data.meetings || data || [];
const meetingsArray = Array.isArray(meetings) ? meetings : [meetings];

return meetingsArray.map(m => {
  const start = new Date(m.startTime);
  const end = new Date(m.endTime);
  const durationMin = Math.round((end - start) / 60000);
  
  return {
    meeting_id: m.meetingId,
    subject: m.subject || '(No subject)',
    date: start.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' }),
    start_time: start.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }),
    end_time: end.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }),
    duration_min: durationMin,
    status: m.status || 'scheduled',
    max_participants: m.maxParticipants || 'N/A',
    join_url: m.joinURL || m.joinUrl || ''
  };
}).sort((a, b) => new Date(a.start_time) - new Date(b.start_time));
```

**Expected result:** A Table on the canvas displays upcoming GoToMeeting sessions for the next 30 days with subject, date, start time, duration, and a clickable join URL for each meeting.

### 4. Create a meeting scheduling form in Retool

Drag a Form component onto the canvas for meeting creation. Add the following form fields: a Text Input for Meeting Subject, a DateTimePicker for Start Time, a Select component for Duration (with options 30, 45, 60, 90, 120 minutes labeled in minutes), and an optional Text Input for Meeting Password. Create a new query named createMeeting. Set the HTTP method to POST and the path to /G2M/rest/v2/organizers/{{ retoolContext.configVars.GOTO_ORGANIZER_KEY }}/meetings. Set the body type to JSON. Construct the request body from the form fields: subject from the text input, starttime formatted as an ISO 8601 string from the datetime picker value, endtime calculated by adding the selected duration in milliseconds to the start time, and optionally conferenceCallInfo and meetingSettings if you want to configure specific options. Click the Form's Submit button event handler and configure it to trigger createMeeting. On the createMeeting query's On Success event, trigger getUpcomingMeetings to refresh the meetings table, and use a Show notification action to display the new meeting's join URL in a success toast. Handle the On Failure event with an error notification displaying the API error message. Add a confirmation modal before triggering createMeeting if your team accidentally submits meetings — wrap the trigger in an event that first shows a Confirm dialog.

```
// POST body for creating a GoToMeeting session
// Use this as the JSON body in the createMeeting query
{
  "subject": "{{ meetingSubjectInput.value }}",
  "starttime": "{{ new Date(startTimePicker.value).toISOString() }}",
  "endtime": "{{ new Date(new Date(startTimePicker.value).getTime() + parseInt(durationSelect.value) * 60000).toISOString() }}",
  "conferenceCallInfo": "PSTN",
  "meetingSettings": {
    "waitingRoom": true,
    "attendeeAudioAccess": "Muted"
  }
}
```

**Expected result:** A form on the canvas lets users fill in meeting details and click Create Meeting. Submitting the form creates a new GoToMeeting session via the API and refreshes the upcoming meetings table with the new entry visible.

### 5. Add meeting history and build the full dashboard

Create a third query named getHistoricalMeetings for the analytics view. Set the HTTP method to GET and path to /G2M/rest/v2/organizers/{{ retoolContext.configVars.GOTO_ORGANIZER_KEY }}/historicalMeetings. Add query parameters fromDate and toDate referencing a DateRangePicker component. The historicalMeetings endpoint returns past meeting records including actual start and end times, number of attendees, and session key for retrieving attendee details. Write a transformer to aggregate total meetings per week using a reduce function on the startTime field. Drag a Chart component and bind it to the weekly aggregated data, setting it to a Bar Chart with week as X axis and meeting count as Y axis. Add Stat components showing total meetings in period, total meeting hours, and average attendees. Organize the full dashboard with a top section containing the date picker and stat components, a middle section with the Chart, and tabs below for Upcoming Meetings (with the creation form) and Meeting History (with the historical table). For comprehensive meeting management across multiple organizers, this kind of multi-organizer view often requires connecting to multiple GoToMeeting accounts — consider using Retool's configuration variables to store multiple organizer keys and a Select component to switch between them.

```
// Transformer: aggregate historical meetings by week
const meetings = data.meetings || [];

const weeklyAgg = {};

meetings.forEach(m => {
  const date = new Date(m.startTime);
  // Get the Monday of the week
  const dayOfWeek = date.getDay();
  const monday = new Date(date);
  monday.setDate(date.getDate() - (dayOfWeek === 0 ? 6 : dayOfWeek - 1));
  const weekKey = monday.toISOString().split('T')[0];
  
  if (!weeklyAgg[weekKey]) {
    weeklyAgg[weekKey] = {
      week_start: weekKey,
      meeting_count: 0,
      total_minutes: 0,
      total_attendees: 0
    };
  }
  const start = new Date(m.startTime);
  const end = new Date(m.endTime);
  weeklyAgg[weekKey].meeting_count += 1;
  weeklyAgg[weekKey].total_minutes += Math.round((end - start) / 60000);
  weeklyAgg[weekKey].total_attendees += m.numAttendees || 0;
});

return Object.values(weeklyAgg)
  .sort((a, b) => new Date(a.week_start) - new Date(b.week_start))
  .map(w => ({
    ...w,
    total_hours: (w.total_minutes / 60).toFixed(1),
    avg_attendees: w.meeting_count > 0
      ? (w.total_attendees / w.meeting_count).toFixed(1)
      : 0
  }));
```

**Expected result:** A complete GoToMeeting dashboard shows stat components with meeting totals, a bar chart of meetings per week, an upcoming meetings table with scheduling form, and a historical meetings view with date range filtering.

## Best practices

- Store the GoToMeeting organizer key in a Retool configuration variable (marked as secret) rather than hardcoding it in query paths — this enables secure key management and easy rotation.
- Enable Share OAuth 2.0 credentials between users in the Resource settings when the Retool app is used by multiple team members to book meetings under a shared organizer account.
- Add input validation to the meeting creation form before the API call: ensure start time is at least 10 minutes in the future and duration is one of GoToMeeting's supported values to prevent preventable API errors.
- Use the historicalMeetings endpoint with pagination support for analytics over long date ranges — GoTo limits responses to 200 meetings per page, so multi-month reports require looping through nextUrl pagination links.
- Combine GoToMeeting meeting data with your CRM in a JavaScript query to show which client meetings are linked to active deals or support tickets — this cross-source view is where Retool adds the most value over GoToMeeting's native interface.
- Cache the upcoming meetings query for 5 minutes since GoToMeeting data does not change second-to-second — this improves performance on shared dashboards used by multiple team members.
- Set up a Retool Workflow on a daily schedule to export GoToMeeting historical data to a connected database — this builds a historical archive that persists even if GoToMeeting's API limits how far back you can query.

## Use cases

### Internal meeting scheduler for support and sales teams

Build a Retool form where support and sales staff can schedule GoToMeeting sessions with clients without needing personal GoToMeeting accounts. The form collects meeting subject, start time, duration, and client name. On submission, Retool calls the GoTo API to create the meeting under a shared organizer account and displays the resulting join URL and access code. The meeting details are automatically logged to the CRM by triggering a subsequent Salesforce or HubSpot query on success.

Prompt example:

```
Build a Retool form with fields for meeting subject, date/time picker, duration select (30/60/90 minutes), and client name text input. On submit, call the GoToMeeting API to create a scheduled meeting under a configured organizer account. Display the meeting join URL and access code in a success panel and trigger a follow-up query to save the meeting link to the CRM record.
```

### Meeting history and analytics dashboard

Create a Retool analytics panel that shows historical GoToMeeting usage by organizer, time period, and meeting type. Query past meetings via the historicalMeetings endpoint, calculate average duration and attendee counts per meeting, and display trends in Chart components. A Table shows all meetings with sortable columns for date, duration, attendees, and whether a recording is available. Managers can use this to understand meeting volume and identify high-frequency meeting organizers.

Prompt example:

```
Build a Retool dashboard that queries GoToMeeting for all past meetings in a selected date range, displays total meeting count, total meeting hours, and average attendees in Stat components, shows a Bar Chart of meetings per week, and a Table listing all meetings with date, subject, duration, attendees, and recording availability.
```

### Cross-platform GoTo communications hub

Build a unified GoTo platform dashboard that combines GoToMeeting and GoToWebinar data in a single Retool app using the same OAuth token. The Meetings tab shows scheduled and past meetings with join links; the Webinars tab shows upcoming webinars with registrant counts. An organizer selector at the top filters all data by the selected account, allowing admins to manage the full GoTo communication calendar for their organization from one screen.

Prompt example:

```
Build a Retool app with tabs for Meetings and Webinars, both using the same GoTo API resource. The Meetings tab shows upcoming sessions with join URLs; the Webinars tab lists upcoming webinars with registrant counts. Add an organizer email selector that filters both tabs. Use a shared DateRangePicker to control the time range shown in both tabs.
```

## Troubleshooting

### OAuth authorization returns 'redirect_uri_mismatch' error during GoTo sign-in

Cause: The Redirect URI configured in the GoTo Developer Center app does not exactly match Retool's OAuth callback URL, including case sensitivity and trailing slashes.

Solution: In GoTo Developer Center → My Apps → your app → OAuth settings, verify the Redirect URI is set to exactly https://oauth.retool.com/oauth/user/oauthcallback (no trailing slash, exact case). For self-hosted Retool, use https://YOUR_DOMAIN/oauth/user/oauthcallback. Copy the URL directly from Retool's Resource settings where the callback URL is displayed to ensure no typos.

### API returns 403 Forbidden when querying meetings with the organizer key

Cause: The GoToMeeting account associated with the OAuth token does not have organizer privileges, or the organizer key in the URL path does not match the authenticated account.

Solution: Verify the GOTO_ORGANIZER_KEY configuration variable contains the correct organizer key for the authenticated GoToMeeting account. The organizer key is a numeric value visible in GoToMeeting account settings. If the OAuth account is a regular user rather than an organizer, upgrade the account or authenticate with an organizer-level account. Check that the OAuth token has the collab:meetings:read scope by reviewing the authorized scopes in the GoTo Developer Center.

### Create meeting query returns 'starttime must be in the future' error

Cause: The starttime value in the POST body is being constructed incorrectly — it may be in a format GoTo does not accept, or the local time zone conversion produces a past timestamp.

Solution: Ensure the starttime in the POST body is a valid ISO 8601 UTC timestamp (e.g., 2024-06-15T14:00:00Z). Use new Date(startTimePicker.value).toISOString() in Retool to convert the picker's local time to UTC ISO format. GoToMeeting requires the meeting to start at least one minute in the future — add a 5-minute minimum buffer when constructing the start time.

```
// Correct start time construction for GoToMeeting API
// Ensures the time is in UTC ISO format
const startTime = new Date(startTimePicker.value);
// GoTo requires ISO 8601: "2024-06-15T14:00:00Z"
const isoString = startTime.toISOString();
```

## Frequently asked questions

### Can I access GoToWebinar data using the same GoToMeeting Resource in Retool?

Yes. GoTo uses a unified OAuth system and the same access token works for both GoToMeeting and GoToWebinar endpoints. The base URL remains https://api.getgo.com, but GoToWebinar endpoints use the path /G2W/rest/v2/ instead of /G2M/rest/v2/. Configure your developer app with both meeting and webinar scopes during app registration, and you can create a single Retool Resource that queries both products. Alternatively, create a dedicated GoToWebinar resource with the same OAuth credentials for cleaner organization.

### Does GoToMeeting API support creating recurring meetings?

Yes. The GoToMeeting REST API supports creating recurring meeting series by including recurrence settings in the meeting creation POST body. Specify the recurrenceType (daily, weekly, monthly) and end conditions. However, managing recurring meeting series via API is more complex than one-time meetings — each recurrence setting has specific fields for interval, days of week, and end date. For simple use cases, create individual one-time meetings from Retool and let GoToMeeting's native interface handle recurring series management.

### How do I get the join URL for a meeting I just created via the API?

The GoToMeeting create meeting response includes the joinURL field directly in the response object. After a successful POST to /organizers/{key}/meetings, the response contains the meetingId, subject, startTime, endTime, and joinURL. Display this URL immediately after creation using {{ createMeeting.data.joinURL }} in a Link component or Text component, and optionally save it to your database using an On Success event handler that triggers a database insert query.

### What is the difference between a meeting ID and an organizer key in GoToMeeting?

The organizer key is a unique identifier for a GoToMeeting account (the organizer) and is used as a URL path segment in all API endpoints to specify whose meetings you are managing — it is essentially the account ID. The meeting ID is a unique identifier for a specific meeting session created within that account. You need the organizer key for all API calls, and the meeting ID for operations on a specific meeting (get details, delete, update). Find your organizer key in GoToMeeting Account Settings under the My Account section.

---

Source: https://www.rapidevelopers.com/retool-integrations/gotomeeting
© RapidDev — https://www.rapidevelopers.com/retool-integrations/gotomeeting