How I Integrated Google Meet with Oracle APEX (Automatic Links and Attendance)

On a recent client project we run a training platform built on Oracle APEX: an admin app for the head office and a learning app for employees. Live webinars were already part of it, but everything around the meeting itself was manual.

• The admin created a meeting somewhere and copied the link by hand into the webinar slot.
• The link was visible in the page source for everyone.
• After the webinar the admin ticked attendance person by person, from memory or from a screenshot.
• Nothing stopped two webinars from running at the same time.

Plus two wishes from the team: a calendar that shows all webinars, and no overlapping webinars. Here's how we built all of it in pure PL/SQL, with no middleware and no extra server.

No middleware. Every call to Google goes straight from the database through APEX_WEB_SERVICE. That keeps the integration inside the normal deployment process (SQL scripts plus APEX exports), and inside the existing table APIs and history tables.

We didn't add a single table. The integration builds on three existing ones and adds seven columns. All our tables follow the same standard: a 4-letter column prefix, audit columns, soft delete, and a history table (H_<TABLE>) filled by a trigger. The new columns went in through our code generator, which regenerates the table API package (API_<TABLE>_PKG) and the history table and trigger. Application code never writes to the tables directly.

WEBINAR: the topic (unchanged)

WEBINAR_SLOT: one date of a webinar (4 new columns)

EMPLOYEE_WEBINAR: registration and attendance (3 new columns)

GLOBAL_PARAMETER: configuration

Everything is entered on a settings page, never in a script.

Code objects

Let's follow one webinar from start to finish: "First Aid Basics" on 5 November 2026, 10:00 to 11:00, with 20 seats, and an employee called Anna Schmidt. The values are examples and the ids are illustrative.

The admin enters the client id and secret, clicks Connect, approves with the organizer account and clicks Finish. Afterwards:

Nothing goes to Google yet. The Meet link belongs to a date, not to the topic.

1. Validation UTIL_WEBINAR_PKG.fn_slot_conflict: is the end after the start? Is any other active slot of a non-cancelled webinar at the same time? None, so saving continues.
2. Create through API_WEBINAR_SLOT_PKG.
3. Process "Google Meet sync" calls pr_google_sync_slot: POST calendar/v3/calendars/primary/events?conferenceDataVersion=1 creates the event with a Meet conference, PATCH meet/v2/spaces/{space} sets accessType = OPEN, and the result is written to the slot.

The event also appears in the organizer's Google Calendar. If the admin later changes the time, the same event is patched and the link stays. If the slot is deleted or the webinar cancelled, the event is cancelled at Google and the sync status becomes CANCELLED.

UTIL_WEBINAR_PKG.fn_visible_for_employee decides whether Anna sees the webinar at all (everyone, her region, or her company). WEBINAR_REGISTER_PKG checks the seats: REGISTERED plus ATTENDED must be below 20.

The webinar now shows in Anna's Calendar tab, in green because she's registered.

The Ajax process JOIN_WEBINAR calls UTIL_WEBINAR_PKG.fn_join(310, ...):

• Registered? Yes. Webinar published? Yes.
• Is 09:52 at or after 09:45 (15 minutes before the start) and before 11:00? Yes.
• Update through API_EMPLOYEE_WEBINAR_PKG, return the Meet URL, and the browser opens Google Meet.

The old row version is kept in H_EMPLOYEE_WEBINAR. If Anna clicks Join now again, say after a network problem, she's simply redirected again and her seat stays taken. Too early, not registered or after the end? fn_join returns a message instead of the link, for example "The webinar opens 15 minutes before the start (05.11.2026 10:00)."

Anna is in the meeting from 09:53 to 10:58. Ben, another registered colleague, never clicks "Join now" and doesn't attend. Clara gets the Meet link from Anna and opens it directly instead of using the app's button. She stays 40 minutes.

At 11:30 the job WEBINAR_ATTENDANCE_JOB runs pr_google_sync_attendance(310):

1. GET meet/v2/conferenceRecords?filter=space.meeting_code="abc-defg-hij" finds the conference record, which must be ended.
2. GET .../participants and GET .../participantSessions give the time per participant.
3. Names are matched against the registrations (letters only, both name orders).
4. Minimum time is 50 % of 60 minutes, so 30 minutes.

Slot 310 gets WESL_ATTENDANCE_DONE_YN = YES and the message "Attendance 05.11.2026 11:30: 2 attended, 1 no-show (min. 30 min)." If someone had joined through the app but stayed only 5 minutes, or wasn't found in Meet, the message would list them for checking. Meet participants without a registration are listed as well.

The attendance dialog shows the list and a Google box with the link, the sync status and the summary. The admin can still change any line by hand. That sets EMWE_ATTENDANCE_SOURCE = MANUAL, and later Google imports never overwrite it. Load attendance from Google Meet runs the import on demand.

All webinars are created in the calendar of one dedicated organizer account. The app holds an OAuth 2.0 refresh token for that account with exactly three scopes:

Why not a service account? A service account signs its own tokens with RSA. Older Oracle versions can't do that in PL/SQL, and service accounts can't create Meet links in a normal Google account without Workspace domain-wide delegation. A refresh token only needs a plain HTTPS POST, so it works on every database version.

The access token is cached for the session:

FUNCTION fn_access_token RETURN VARCHAR2 IS
    v_resp CLOB;
BEGIN
    IF g_token IS NOT NULL AND g_token_until > SYSDATE THEN
        RETURN g_token;                                   -- still valid
    END IF;

    v_resp := fn_request(
                  pi_method       => 'POST'
                , pi_url          => 'https://oauth2.googleapis.com/token'
                , pi_body         => 'grant_type=refresh_token'
                                  || '&client_id='     || UTL_URL.ESCAPE(fn_param('GOOGLE_CLIENT_ID'), TRUE, 'UTF-8')
                                  || '&client_secret=' || UTL_URL.ESCAPE(fn_param('GOOGLE_CLIENT_SECRET'), TRUE, 'UTF-8')
                                  || '&refresh_token=' || UTL_URL.ESCAPE(fn_param('GOOGLE_REFRESH_TOKEN'), TRUE, 'UTF-8')
                , pi_content_type => 'application/x-www-form-urlencoded'
                , pi_token        => NULL);

    APEX_JSON.parse(v_resp);
    g_token       := APEX_JSON.get_varchar2(p_path => 'access_token');
    g_token_until := SYSDATE + (APEX_JSON.get_number(p_path => 'expires_in') - 120) / 86400;
    RETURN g_token;
END fn_access_token;

Connecting the account without SQL

On production nobody should have to run SQL scripts with secrets in them, so the admin app got a Google Meet Settings page:

1. Enter the Client ID and Client Secret (the secret is never shown again), then Save.
2. Connect shows Google's approval link. Sign in with the organizer account and click Allow.
3. Paste the address the browser ends up on, then click Finish.
4. The page runs a test straight away: "Google account connected. Test: OK".

There's also Test connection and Disconnect, which revokes the token at Google. A state value stored on the server protects the approval step against foreign or replayed codes.

When the admin saves a slot, an APEX process calls the sync procedure. It builds a Calendar event with a conference create request:

APEX_JSON.initialize_clob_output;
APEX_JSON.open_object;
APEX_JSON.write('summary', v_title);
APEX_JSON.open_object('start');
APEX_JSON.write('dateTime', TO_CHAR(v_start, 'YYYY-MM-DD"T"HH24:MI:SS'));
APEX_JSON.write('timeZone', 'Europe/Berlin');     -- your organisation's time zone
APEX_JSON.close_object;
-- ... end in the same way ...
APEX_JSON.open_object('conferenceData');
APEX_JSON.open_object('createRequest');
APEX_JSON.write('requestId', 'webinar-slot-' || pi_wesl_id || '-' || TO_CHAR(SYSTIMESTAMP, 'YYYYMMDDHH24MISSFF3'));
APEX_JSON.open_object('conferenceSolutionKey');
APEX_JSON.write('type', 'hangoutsMeet');
APEX_JSON.close_object; APEX_JSON.close_object; APEX_JSON.close_object;
APEX_JSON.close_object;

v_resp := UTIL_GOOGLE_PKG.fn_call('POST',
              v_calendar_api || '/calendars/primary/events?conferenceDataVersion=1&sendUpdates=none',
              APEX_JSON.get_clob_output);

The response contains hangoutLink, the Meet URL, which is stored on the slot. Google may create the conference asynchronously, so the code asks again a few times if the link is still missing.

Then the meeting space is opened, so learners from outside the organisation join without knocking:

PATCH https://meet.googleapis.com/v2/spaces/{space}?updateMask=config.accessType
{ "config": { "accessType": "OPEN" } }

Changes and cancellations are synchronised too: a changed time patches the same event (the link stays), a deleted slot or a cancelled webinar cancels the event. And Google errors never block saving. They're stored on the slot and shown to the admin.

The old "Join now" button was a plain <a href="{meeting url}">. The new one calls an Ajax process:

function joinWebinar(id) {
    var w = window.open("", "_blank");            // opened synchronously, so no popup blocker
    apex.server.process("JOIN_WEBINAR", { x01: String(id) }, {
        dataType: "json",
        success: function (d) {
            if (d && d.url) { w.opener = null; w.location.href = d.url; }
            else { w.close(); apex.message.alert(d.error); }
        }
    });
    return false;
}

On the server, UTIL_WEBINAR_PKG.fn_join checks that:

• the employee is registered for this slot,
• the webinar is published,
• it's between 15 minutes before the start and the end, in local time.

Then it marks the registration ATTENDED (source JOIN), logs the first join time and returns the URL. The employee can rejoin until the end, and a learner who joined keeps the seat.

Thirty minutes after a webinar ends, the scheduler job reads the meeting from the Meet REST API:

GET /v2/conferenceRecords?filter=space.meeting_code="abc-defg-hij"
GET /v2/{conferenceRecord}/participants
GET /v2/{participant}/participantSessions

For each participant the sessions are added up to the time in the meeting. Then:

• The learning app got a Calendar tab (APEX CSS Calendar) with exactly the webinars an employee is allowed to see. The visibility rule (everyone, region or company) moved into one PL/SQL function, and we checked it against the old card logic: 602 employee and webinar pairs, 0 differences. Own registrations are green.
• The admin app shows drafts in the calendar too, because they block their time.
• Overlap check: a slot can't be saved if it overlaps any active slot of another non-cancelled webinar, and the end must be after the start. The same check runs when a cancelled webinar is reactivated.

We wrote browser tests (Playwright) for the whole flow, plus a small Google mock server (Python standard library only) that imitates the OAuth, Calendar and Meet endpoints. All Google base URLs are configurable, so the tests point the app at the mock and never create real events. The test runner even switches a real Google connection off during the run and restores it afterwards.

The end-to-end test does exactly what the business asked for: admin creates a webinar, the Meet link appears, a second slot at the same time is refused, an employee applies, Join now opens the Meet link and marks ATTENDED, and after the webinar the admin sees the attendance. Full suite: 65 tests passing.

Then the real test: a live meeting with seven participants on a local copy, and a second real webinar on the development environment. Meet link generated, join marked, participant list read, attendance loaded on the admin page.

• Secrets (client secret, refresh token) live only in the database configuration and in root-only files on the server. Never in the repository, never in chat, never on a page.
• The meeting link is only handed out to registered employees, inside the join time window.
• A dedicated organizer account with the minimum scopes. Access can be revoked any time in the Google account, or with one click on the settings page.
• Test and production use different Google accounts.

The admin's manual work went from copy the link, collect screenshots, tick attendance to saving a time slot. If you're planning something similar in your own APEX app and get stuck, leave a comment below.

Stack: Oracle Database 19c / 23ai, Oracle APEX 23.2, Google Calendar API v3, Google Meet REST API v2.