Authoring tool LMS integration — how Storyline, Rise, Captivate, and iSpring publish to SCORM, xAPI, and cmi5, and report completions into your LMS.
Got an LMS decision on your plate?
45-minute call. Plain-English audit. Fixed-price quote if there's a fit, or a "no" if there isn't. No deck. No pitch.
A plain-English comparison of SCORM, xAPI, and cmi5 — what each does, where they differ, and which to choose for your training content.
A practical look at AI course authoring for corporate training — what it speeds up, where human review is mandatory, and why an owned platform keeps your content yours.
Build interactive video, branching scenarios, and drag-and-drop right inside your LMS — no separate authoring tool, no per-author fees.
Authoring tool LMS integration is the plumbing that takes a course built in a tool like Articulate Storyline and makes it land in your LMS as a trackable, reportable assignment — with completions and scores flowing back automatically. The connection at the heart of any authoring tool LMS integration is not a live API but a published package in a standard format, and how well that package reports depends entirely on which standard you pick and how the LMS reads it. For a compliance-driven firm, a botched integration produces the worst failure of all: people finish the training, but the completions never record.
This guide covers how the major authoring tools publish, how packages report into the LMS, versioning and re-import, when to author in a tool versus build natively in Moodle, and how completion and score tracking works. Because Aquilon builds platforms you own outright, you keep full control of how packages are ingested and reported — no waiting on a vendor to support the format your team authored in.
The mental model that matters: authoring tools do not plug into your LMS the way an app connects to an API. Instead, the tool publishes the finished course as a self-contained package — typically a zip file — that you upload into the LMS. The LMS launches it in the learner's browser, and standardized code inside the package talks back to report progress.
The four tools most US L&D teams use all follow this pattern:
The output is always a standards-based package, and the standard you choose at publish time determines what the LMS can see.
This is the decision that shapes the whole integration, so it is worth being precise. The package speaks one of three languages, and each carries a different amount of information back to the LMS.
If you are choosing between them, our SCORM vs xAPI vs cmi5 comparison walks through the trade-offs. Short version for compliance: SCORM if you only need completion and score in the LMS, cmi5 if you also want detailed engagement data to report on later.
Once uploaded, the package needs to communicate reliably, and this is where real integrations succeed or quietly fail. For SCORM, the content talks to the LMS through the browser using the SCORM runtime API while the course is open. When the learner completes a lesson or finishes a quiz, the package writes completion and score back to their transcript. The catch: the data flows only while the window is open and the session closes cleanly. Courses that let learners close the tab mid-quiz, or that never call the "commit" step, are the usual cause of "they finished but it says incomplete."
For xAPI and cmi5, statements go to an LRS. With cmi5, the LMS coordinates the launch and reads back completion and pass/fail, while granular statements accumulate in the LRS for reporting. This is why xAPI-based approaches pair naturally with a learning record store you own — the detailed data has a home you control.
Courses change — a policy updates, a quiz question is reworded — and now you need version 2 without breaking version 1's records. This is where discipline pays off.
A few rules that prevent painful cleanups:
Careless re-importing is the quiet way to orphan a learner's in-progress attempt or reset completions you were relying on for an audit. Treat every package swap as a small release, not a file upload.
Not every course should be a published package. It depends on how polished, portable, and editable the content needs to be.
Author in a tool when you want highly designed, branded, interactive courseware — branching scenarios, software simulations, animated modules — and the course is relatively stable once shipped. A published SCORM or cmi5 package is also portable: it runs on any conformant LMS, which matters if you might re-platform.
Build natively in Moodle, often with H5P for the interactive pieces, when the content changes frequently, when you want it editable directly by an admin without a round-trip through an authoring tool, or when you want the richest native reporting rather than what a package exposes. H5P interactions live inside the platform and report natively, keeping the edit cycle short; our Moodle H5P interactive content guide covers what it does well. Teams increasingly lean on AI course authoring to draft either path faster. Many programs mix both: authored packages for flagship courses, native Moodle and H5P for material that changes every quarter.
The record at the end is the whole point, so confirm it works before rolling out at scale.
Completion can be driven a few ways depending on the package: reaching the final slide, passing an embedded quiz above a threshold, or an explicit "mark complete" the author wired in. Score, where relevant, passes back as a percentage stored against the transcript. The recurring mistake is assuming the default completion trigger matches your compliance rule — if policy says "pass the assessment at 80 percent," the package must be published to report that pass condition, not merely "viewed all slides." Test one real learner path end to end, check the transcript, then assign it broadly.
On a rented per-seat LMS, you accept whatever package formats and reporting depth the vendor supports; if your team authored in a format the platform handles poorly, that is your problem to work around.
On a platform you own, ingestion and reporting are configured to your standards. You decide whether xAPI statements flow to an LRS you control, how completion maps to your compliance rules, and how versioned re-imports are handled — never blocked from a format because it sits behind a premium tier. Own the platform, and the authoring pipeline bends to your process, not the reverse.
No. They publish a self-contained package in SCORM, xAPI, or cmi5, which you upload into the LMS. The package's standardized code then reports progress back at runtime.
Most often the SCORM session did not commit — the learner closed the tab before the package wrote back, or the completion trigger was misconfigured. Test one real learner path and confirm the transcript before assigning broadly.
Author in a tool for polished, stable, portable courseware. Build natively in Moodle with H5P for content you will edit often and want reported natively. Most programs use both.