
Zoom LMS integration: connecting Zoom, Teams and Webex to a training management system
A Zoom LMS integration has four jobs: create a meeting when a session is scheduled, store the join link and the provider’s identifiers, listen for meeting events, and pull attendance once the meeting ends. Teams and Webex need the same four jobs. What changes is how you authorize, which ID you keep and how each provider limits and signals.
The vendor pages and “best LMS with Zoom” lists we reviewed say a platform supports Zoom, but not what happens between a coordinator saving a session and a learner clicking the link. This guide is for the engineers and operations leads who build or evaluate that path. It draws on each provider’s published developer documentation as of November 2026, not on hands-on testing; only the code sample was run, and only locally.
Key takeaways
- Treat the integration as four jobs: provision, store identifiers, listen, reconcile. Make each one safe to repeat.
- Choose the authorization model by who owns the video account: one account-level credential for your own account, user-level consent when each client or trainer owns theirs.
- Store the ID that names one occurrence of a meeting, not just the join link. Zoom, Teams and Webex each name occurrences differently.
- Webhooks make you faster, not complete. Zoom stops retrying after three failed attempts, so reconcile on a schedule.
- As of November 2026, Zoom limits meeting create and update calls to 100 per user per day, so bulk scheduling needs a queue.
What does a Zoom LMS integration actually do?
It turns a scheduled session in your training system into a meeting on the video provider, puts the join link where learners and trainers can find it, and brings attendance data back afterward. The training system stays the record of who is booked. The provider only hosts the room.
The work splits into four jobs:
- Provision: create, update or cancel the provider meeting when a session is created, moved or cancelled.
- Store identifiers: keep the join link and every ID you need to find that exact meeting again.
- Listen: receive provider events so you know when a meeting starts, ends or changes.
- Reconcile: fetch participant data afterward and match it to enrollments.
The join link belongs on the dated meeting row, not on the course or the session. Mundrisoft’s post on the TMS data model for sessions and meetings treats virtual delivery as a join link on the meeting, which is the shape this guide assumes.
If learners only need to launch a video tool from inside a course, a standards-based launch may be enough. Our guide to LTI 1.3 for third-party tools explains how such launches work, and notes that LTI does not handle sessions or attendance. This guide covers the case where your own platform must schedule meetings and judge attendance.
How do Zoom, Teams and Webex compare for a training system?
All three create meetings through an API and report participants afterward. They differ in how you authorize, which identifier names one occurrence, and which event tells you a meeting is live or over. The table below compares them from each provider’s developer documentation as of November 2026. Treat every cell as volatile.
| Question | Zoom | Microsoft Teams (Graph) | Webex |
|---|---|---|---|
| Create call | POST /users/{userId}/meetings |
POST /users/{userId}/onlineMeetings, or a calendar event with isOnlineMeeting |
Create a Meeting (scope meeting:schedules_write) |
| Authorization | Server-to-Server OAuth for your own account, or user-level OAuth | App permission OnlineMeetings.ReadWrite.All plus a tenant admin access policy, or delegated work or school account |
Integration authorized by users, or a service app with group-level privileges |
| What names one occurrence | Meeting ID for the series, a separate UUID for each instance | The onlineMeeting ID and its joinWebUrl; a calendar event has its own ID |
Series ID, scheduled-meeting ID, and an instance ID that arrives when the meeting starts |
| Live signal | Webhooks, such as meeting.participant_joined |
meetingCallEvents subscription, app-only, with a roster update event |
Webhook with resource meetings and event ended |
| Attendance afterward | Participant reports | Attendance reports and records | /v1/meetingParticipants and attendee reports |
| Throttling signal | HTTP 429; limits are per account | HTTP 429 with a Retry-After header |
HTTP 429 with a Retry-After header |
Two gaps matter. We did not find, in the Webex pages we could read, a documented webhook for individual joins and leaves; its guide documents a meeting-ended webhook. And in the part of Zoom’s webhook page we could read, meeting.participant_joined appears only in the scope list. Check each provider’s current event reference before you design around a live join feed.
Which authorization model fits a Zoom LMS integration?
Match the token to whoever owns the video account. If the account is yours, one account-level credential per provider is simplest. If each client or trainer owns an account, you need user-level consent and a stored refresh token per owner. Both models appear in real training platforms.
Two training systems show the split. Administrate’s documentation has a Zoom owner or administrator create a Server-to-Server OAuth app and share its credentials, and it requires the host’s Zoom email to match the contact record. TalentLMS’s help page has each instructor click “Connect with Zoom.us” and authorize, so every hosting instructor connects separately.
- Zoom: a Server-to-Server token comes from the
account_credentialsgrant for your own account, lasts one hour and has no refresh token. User-level tokens also last an hour, but refresh tokens expire after 90 days and each refresh returns a new one. - Teams: per Microsoft’s create online meeting reference, the app permission
OnlineMeetings.ReadWrite.Allworks only after a tenant admin creates an application access policy and grants it to a user. Personal Microsoft accounts are not supported for creating meetings. - Webex: an integration acts through users who authorize it. A service app can hold group-level privileges, and the admin who authorizes admin scopes must be a full org admin.
Pro tip: Model the connection as a row. Store owner, provider, granted scopes, status and last successful call for every connection. When an instructor removes the app or a refresh token lapses, you then see “needs reauthorization” on a dashboard instead of a trainer discovering a missing link on session day.
How do you build a Zoom LMS integration that creates meetings without duplicates?
Make provisioning an idempotent job keyed on your own meeting row. Save the row as pending first, call the provider once, then write the join link and identifiers back in a single update. If the call times out, look for a stored ID before retrying, so a retry never creates a second meeting for the same date.
A small status set is enough: pending, provisioning, ready, failed, needs_reauth and cancelled. A change of time, trainer or status should update or delete the same provider meeting, never create another.
What you store decides whether the later steps work. Record the provider, the connection that owns the meeting, the series ID, the instance ID once known, the join link, the time you provisioned it and the last error. Keep any host-only start link out of learner views.
Teams has a trap here. The online-meeting call creates a standalone meeting that does not appear on the trainer’s calendar. If trainers expect a calendar entry, you create an event instead, and then hold two IDs. A January 2026 answer from a Microsoft Q&A moderator says the attendance report belongs to the online meeting, not the calendar event, so store both and look up the meeting by its joinWebUrl. Zoom has a similar split: its developer blog says meeting IDs and UUIDs are not interchangeable, and each instance of a recurring meeting has its own UUID.
How do webhooks tell you who joined and left?
Providers push events to a public HTTPS endpoint you register. Verify each request, acknowledge it fast and process it later. Because each provider sends different events and some drop them after failed deliveries, treat webhooks as a way to learn sooner, not as the only record of who attended.
Zoom’s webhook documentation sets the rules. Your endpoint must answer an endpoint.url_validation challenge within 3 seconds with a token hashed using your secret, and Zoom revalidates every 72 hours. Each delivery carries a signature built from the timestamp and body. A 200 or 204 reply within 3 seconds counts as delivered. Zoom retries up to three times, at 5, 20 and 60 minutes, for 500-level responses but not for 3xx or 4xx, and after three failed attempts it sends nothing more for that event.
The sample below implements the validation answer and the signature check from those rules. The replay-age check is our own addition, not part of Zoom’s description.
import hashlib
import hmac
import time
def zoom_validation_response(plain_token: str, secret_token: str) -> dict:
digest = hmac.new(secret_token.encode(), plain_token.encode(),
hashlib.sha256).hexdigest()
return {"plainToken": plain_token, "encryptedToken": digest}
def zoom_signature_ok(secret_token: str, timestamp: str, raw_body: bytes,
signature_header: str, max_age_s: int = 300) -> bool:
if abs(time.time() - int(timestamp)) > max_age_s: # our own replay guard
return False
message = f"v0:{timestamp}:{raw_body.decode('utf-8')}"
expected = "v0=" + hmac.new(secret_token.encode(), message.encode(),
hashlib.sha256).hexdigest()
return hmac.compare_digest(expected, signature_header)
We ran this against self-generated values: a valid signature passes, and a changed body, a wrong secret and an old timestamp fail. We did not test it against Zoom’s servers, so run Zoom’s own Validate step before relying on it.
For Teams, a live roster feed uses a meetingCallEvents subscription, which needs application permissions and has a maximum lifetime of three days, so a renewal job is part of the design. For Webex, its meeting resources guide says to register a webhook for the meeting-ended event and to store the meeting ID it delivers, because Webex lists only future and in-progress meetings.
How should attendance be pulled after the meeting ends?
Treat provider data as evidence and your own roster as the record. After the meeting ends, fetch the participant list, match each entry to an enrollment and store the result with its source. Our post on attendance tracking for ILT compares join logs with other methods, so this section stays short.
- Zoom: no waiting period is documented in what we read. Developer forum threads from 2022 report that calling the participants endpoint right after a meeting-ended webhook sometimes returned 404 or partial lists, and users described pauses of 15 to 30 seconds. Retry with backoff instead of trusting one call.
- Teams: an attendance report is generated when the meeting ends. Its
attendanceRecordsare not returned by default, so expand them, and they carry no breakout room information. Reading them needsOnlineMeetingArtifact.Read.All. - Webex: after the meeting-ended webhook,
/v1/meetingParticipantsshows who attended, which the invite list does not.
Provider names and emails will not always match enrollment records, and a join log shows a connected account, not an engaged learner. Put unmatched rows in a review queue for the trainer to confirm.
Pro tip: Add a sweep, not just a handler. Run a scheduled query for meetings that should have ended but have no attendance result, and fetch them on a backoff schedule. It catches missed webhooks, expired Teams subscriptions and slow reports with one mechanism, and gives support a list instead of a guessing game.
What rate limits and failures should you plan for?
Plan for three failure types: throttling, missing configuration and missed events. All three providers answer throttling with HTTP 429, but their limits differ and Zoom’s are per account, not per app. Queue every provider call, honor the wait time returned, and keep a reconciliation job for events that never arrived.
Zoom’s rate limit page labels each endpoint Light, Medium, Heavy or Resource-intensive. As of November 2026, Light endpoints allow 30 requests per second on Pro and 80 on Business and above, and limits are shared by every app on the account. Separately, each user is limited to 100 meeting and webinar create or update requests per day, counted from 00:00 UTC. Webex says most REST APIs allow around 300 requests per minute and returns a Retry-After value in seconds. Microsoft’s throttling guidance for Graph also relies on Retry-After.
A worked example with illustrative numbers shows why the daily cap matters. A coordinator imports 140 sessions that all list one trainer as host. At 100 create calls per day, the first 100 succeed and the remaining 40 must wait for the UTC reset. A queue that spreads calls and marks rows pending turns that into a delay instead of an error. The page does not say whether the count follows the host or the requester, so test which one applies to you.
| Failure | What you see | What to do |
|---|---|---|
| Throttled call | HTTP 429 | Wait the returned time, retry from the queue, never retry in a tight loop |
| Slow webhook endpoint | Zoom stops after three failed attempts | Acknowledge fast, process later, reconcile on a schedule |
| Webhook validation lapses | Zoom disables the subscription after 6 consecutive failed revalidations | Alert on validation failures and keep the endpoint reachable |
| Teams access policy missing | Graph returns 403 for the app-only call | Ask the client’s tenant admin to create and grant the policy |
| Teams subscription expires | Roster events stop after three days | Renew before expiry, or create a new subscription |
| Wrong ID for the report | Not found or error on attendance | Store the onlineMeeting ID, the Zoom instance UUID or the Webex instance ID |
What should you do next?
Count your sessions by provider for the last 90 days, and note who owns each video account. That tells you which authorization model you need and which provider to build first. Build the four jobs once as a provider-neutral flow, then add one adapter per provider. Test one recurring session end to end, including a reschedule and a cancellation, before adding a second provider.
If you would rather evaluate than build, SimpliTrain, a Mundrisoft product, lists native integrations with Microsoft Teams, Zoom and Adobe Connect for virtual instructor-led training, and its page says join link distribution and attendance recording stay inside SimpliTrain. It does not list Webex. You can request a demo and ask which providers and which attendance path it supports.
Frequently asked questions
How does Zoom integrate with an LMS?
Platforms usually use the Zoom API: the LMS or training system creates meetings for an account, stores the join link and later reads participant data. Some LMSs instead use an LTI-based launch from inside a course. Choose the API route when your platform must schedule meetings and judge attendance, not only open Zoom.
Does every trainer need a separate Zoom connection?
It depends on the design. TalentLMS documents a per-instructor connection, where each instructor authorizes their own Zoom account. Administrate documents an account-level Server-to-Server app that an owner or administrator creates. Pick per-instructor consent when trainers own their accounts, and an account-level credential when your organization owns them.
Can one integration support Zoom, Teams and Webex?
Yes, if you separate the shared flow from provider details. Keep one provisioning flow, one meeting table and one attendance review queue. Put authorization, ID handling, webhook parsing and throttling behind an adapter per provider, since those are where the three differ most.
Why is attendance empty right after a session ends?
The data may not be ready yet. Teams generates its attendance report when the meeting ends, and Zoom developer forum threads from 2022 describe empty or partial participant lists when called immediately after the end event. Schedule a delayed fetch with retries, and let a sweep catch the rest.
Should we build this integration or buy a platform that has it?
Buy or adopt when you use one provider, standard scheduling and the attendance method you already have. Build when clients bring their own video accounts, you need provider-neutral reporting, or attendance rules are specific to your programs. Ask any vendor to show the identifiers it stores.
Tags :
