New: the SCORM Central WordPress plugin. Put a course on any WordPress page and see who finished. Get the plugin →

Start free →
FREE TOOL

Test a SCORM package before the LMS does.

Upload a SCORM zip and watch every runtime call it makes — Initialize, SetValue, Commit — with manifest checks alongside. Free, in the browser, no account.

01 · MANIFEST

Is the package valid?

The imsmanifest.xml is checked for the problems that stop an import: a missing launch file, files the manifest lists but the zip doesn't have, a missing version. Errors are in plain English.

02 · RUNTIME

What does it actually report?

Launch the course and see the full call log per attempt: every SetValue, every Commit, in order, with the values the LMS would receive.

03 · RESULT

What did the attempt end with?

Completion, success, score, total time, and the bookmark, exactly as an LMS would have stored them.

WHAT YOU GET BACK

The attempt, as the LMS would have seen it.

A real run of a two-file SCORM 1.2 package through the tester: the attempt state on the left, the full runtime call log on the right — every call, its value, and its return code, in order.

SCORM Central tester after a completed attempt: state panel showing attempt finished, completion completed, success passed, score 84%, 6 commits, 0 API errors, bookmark module-1; API log listing LMSInitialize, LMSGetValue cmi.core.lesson_status and cmi.core.entry, LMSSetValue cmi.core.lesson_location, LMSCommit, LMSSetValue for score min, max, raw and lesson_status passed, LMSCommit, LMSSetValue cmi.core.exit, LMSFinish

Score written before status, a commit straight after, exit set before LMSFinish — the healthy pattern from the log examples below. Manifest validation runs on upload, before any attempt, and reports in the same place.

WHAT IT CHECKS

Three questions, answered before anyone else sees the file.

Will the LMS accept the package at all?

Most import failures are manifest failures, and they happen before a learner ever launches the course. The tester reads imsmanifest.xml and checks what an LMS checks first: that it is well-formed XML at the root of the zip, that it declares a SCORM version, that it has an organization, a launchable item and a resource, that the launch file exists, and that every file it lists is in the zip. It reports what is wrong in words rather than XSD error paths. The usual culprits: a resource href that points at a file not in the zip, a manifest nested inside a folder instead of sitting at the root, or a missing schemaversion. Any one of them stops the import cold. The manifest, explained covers the structure in detail.

What does the package actually send?

This is the part no authoring-tool preview shows you. The tester launches the course against a real SCORM runtime and records the conversation: every Initialize, GetValue, SetValue, Commit and Terminate, in order, with the exact string values that would reach an LMS and the return code for each call. A course that never sets cmi.completion_status, or sets it and then never commits, is obvious in ten seconds in a log and invisible everywhere else.

Will completion and score survive?

The log answers this if you know what to look for: is score written before status, so a platform that evaluates a mastery score at the moment status arrives has the number it needs; is there a Commit after the status writes, before the fragile exit; is cmi.suspend_data inside the cap for the declared version — 4,096 characters for SCORM 1.2, 64,000 for 2004. The tester shows you the calls and the stored values; automatic checks for these patterns are coming soon.

READING THE LOG

What a broken package looks like.

Two logs from courses that behave identically for the learner. One reports; one does not.

Healthy. Score before status, a commit straight after, exit set before termination:

SetValue("cmi.score.scaled", "0.84")           → "true"
SetValue("cmi.success_status", "passed")       → "true"
SetValue("cmi.completion_status", "completed") → "true"
Commit("")                                     → "true"
SetValue("cmi.exit", "normal")                 → "true"
Terminate("")                                  → "true"

Broken. Status written first, no commit before the learner closes the tab, and a final write that lands after the session has already closed:

SetValue("cmi.completion_status", "completed") → "true"
SetValue("cmi.score.scaled", "0.84")           → "true"
Terminate("")                                  → "true"
SetValue("cmi.score.raw", "21")                → "false"   error 133: store after termination
Both courses look finished to the learner. The second one loses the score on any platform that evaluates mastery when status arrives, and loses everything on any platform that buffers values until a commit. This is the single most common cause behind courses that lose completions, and it is only visible in the call log.

Once you can read the log, the same discipline applies to every package you ship. The SCORM API explained walks through each method and the error codes worth knowing, and testing a SCORM package before upload is the full pre-flight checklist.

THE ALTERNATIVES

Ways to test a SCORM package, compared.

ApproachWhat it tells youWhat it costs you
Authoring-tool previewThat the content rendersNothing — but it stubs the SCORM API, so it cannot fail on a missing commit or a late write
Upload to the real destination LMSThe truth, for that one platformYou need access, and a failure is often already a customer-visible one
A hosted sandbox with an accountRuntime behaviour against a reference playerSignup, and usually a registration or upload allowance
Browser developer toolsWhatever you instrument yourselfYou have to wrap the API object by hand and know what to look for
This testerManifest validity plus the full runtime call logNothing, and no account — results are not saved between sessions

None of these replaces testing on the destination platform when you know what it is. What a pre-flight check buys you is that the package is already correct when it gets there, so a failure points at the platform rather than at your zip — and platform quirks are their own subject, covered in runtime behaviour profiles, which the Pro and Business plans can replay a package against.

WHY THIS EXISTS

"It worked in the authoring tool" is not a test.

Most SCORM problems only show up at runtime, in someone else's LMS, after the course has shipped. A five-minute check of the actual call log catches lost completions, missing scores, and bookmark failures while they are still your problem to fix quietly — not a support ticket from a customer.

The tester runs in the guest workspace — nothing to install and no signup. If you want to keep the results, or fix the source file and rebuild the package, that is what the full product does. Replay against saved LMS profiles comes with Pro and Business.

Questions

Do I need an account to test a SCORM package?
No. The tester runs in a guest workspace in your browser. There is nothing to install and no signup step.
Which SCORM versions can it test?
SCORM 1.2 and SCORM 2004. The runtime implements the SCORM 1.2 API and the SCORM 2004 4th Edition API.
What does the tester actually check?
Two things. First, whether imsmanifest.xml has what an LMS needs: well-formed XML at the zip root, a declared version, an organization, a launchable item and resource, the launch file, and every file it lists. Second, what the package sends at runtime: every Initialize, GetValue, SetValue, Commit and Terminate call in order, with its value and error code. You also see the completion, success, score, and time each attempt ended with.
Why did my course work in the authoring tool but not in the LMS?
Authoring-tool previews usually stub the SCORM API rather than enforcing it. They do not fail on a missing Commit, a status written before a score, a value written after Terminate, or suspend data over the version cap. Those only appear against a real runtime, which is what the call log shows you.
Is my package uploaded anywhere?
The package is processed in the guest workspace for the session so it can be launched and its runtime calls recorded. Saving results between sessions is what an account is for.
How big a package can I test?
Up to 50 MB per zip, and a few uploads per visitor in the guest workspace. Typical converted decks, documents and single-SCO courses are well inside that. Very large media-heavy packages are better tested after trimming the media, since the runtime behaviour is what is being checked, not playback.

Start with one file.

Upload a PowerPoint, PDF, or video you already have, build it as a SCORM package, and run it in the tester to see every call it makes.

→ upload  handbook.pdf
  rendering … 86 pages
  course … 1 lesson, 86 pages
  building … SCORM 2004 4th Ed
  validating … 0 errors
✓ handbook-scorm2004.zip