A SCORM file is a zip archive holding a course and a manifest, and the manifest tells a learning management system how to launch the course and what to record. That second half is the whole job: the package either reports a completion your auditor will accept, or it plays perfectly and reports nothing, and most teams find out which after the rollout starts. This guide opens the zip, settles the 1.2-or-2004 question, names the failures that stop an import, and gives you a test to run this afternoon.
If the module doesn’t exist yet, you can build the course itself from a policy document you already have.
Key Takeaways
– One attribute inside the manifest,adlcp:scormtype, decides whether your LMS tracks anything at all. A lesson marked the wrong way imports cleanly, plays perfectly and never completes.
– SCORM 1.2 has one status field, so “finished the module” and “passed the test” can’t both be reported. SCORM 2004 splits them in two.
– A package that can’t find the LMS — opened from a desktop, hosted on a different domain, nested too deep in the page — records nothing. The most anyone sees is a browser alert.
– “SCORM compliant” is a claim with nobody behind it: the organization that wrote the standard has been shut down, the test suite hasn’t changed in eleven years, and no register of certified products is reachable. Ask for a version and tested platforms instead.
– Stage one of testing costs nothing: SCORM Cloud’s Trial plan is $0 and covers three courses and ten resettable registrations (Rustici’s published pricing, September 2026).
SCORM Is Not Software
SCORM gets sold as a file, a format, a product, a platform and a compliance regime. It is one thing: an agreement about how a package of course files and a learning platform talk to each other. Nobody ships it, nobody licenses it, there is no version to install. Four distinctions do most of the work.
- It isn’t the LMS. The platform holds the enrollments, the gradebook and the completion record; the package holds the content and the rules for what gets reported.
- It isn’t what plays the course. A package is ordinary web files and the browser draws them. There is no SCORM player to buy.
- It isn’t a product. What you buy is a tool that exports a package, or a platform that accepts one.
- It isn’t a badge anyone currently issues. “SCORM compliant” on a feature list is a self-description, for reasons below.
What it is comes in two halves. Packaging is what goes in the zip and the manifest describing it: get that right and your package imports. The run-time conversation is what the content says to the platform while a learner works through it: get that right and it records something.
Two neighbors are worth separating out. LTI plugs an external tool into a platform: the content stays with the tool and the platform only launches it — the opposite trade from SCORM, where the content is handed over as a file. AICC is the older standard some platforms still accept, which is why its name turns up in import screens.
And because SCORM is an agreement rather than a product, nothing enforces it inside the thing you bought: two vendors can both say “SCORM” and hand you packages that behave differently in the same platform. Every check below is one you run yourself.
What’s Actually Inside a SCORM File
Unzip one and you get an ordinary folder of web files. A complete, working multi-lesson SCORM 1.2 package runs to 28 files and 292 KB unpacked: nine HTML pages, nine images, one stylesheet, four JavaScript files, the manifest, and four schema files. Four kinds of thing — the course a learner sees, the JavaScript that talks to the LMS, the manifest, and schema files defining what the manifest may say. Nothing on screen tells you whether the package will report anything, and the file that decides it is the one nobody opens.
The manifest is the only file your LMS reads first
imsmanifest.xml sits in the root of the zip. It declares what the package is, which version of the standard it claims, which files exist, which one launches, and which parts of the standard it uses — a short list in SCORM 1.2, a longer one in 2004. Everything your LMS knows before a learner clicks anything comes out of that one file. Stripped to the parts that decide something:
<metadata>
<schema>ADL SCORM</schema>
<schemaversion>1.2</schemaversion> <!-- picks the run-time -->
</metadata>
...
<resources>
<resource identifier="lesson1"
adlcp:scormtype="sco" <!-- tracked: gets a status -->
href="lesson1.html"> ... </resource>
<resource identifier="shared_files"
adlcp:scormtype="asset" <!-- delivered, never tracked -->
href="shared/style.css"> ... </resource>
</resources>
The two commented lines are why you open a manifest. The version string decides which run-time your platform serves; adlcp:scormtype decides whether a resource reports anything. Here the lessons are sco and the shared stylesheet and scripts are asset — right, since shared files have nothing to report. The rest is bookkeeping.
One attribute decides whether anything is tracked
A resource marked sco gets a live connection to the LMS and a status of its own. One marked asset is delivered and carries nothing back. SCO is the acronym at the center of the standard: a sharable content object, the trackable unit the whole thing is named after.
Getting it wrong is the most expensive failure in the category, because nothing looks wrong. A package whose lessons are marked as assets imports cleanly, plays perfectly and never completes for anyone. Read that attribute resource by resource in any export you didn’t produce, and when a module shows incomplete for every learner, check it before blaming the LMS, the browser or the people who took it.
How a SCORM Package Reports Back (and Why It Sometimes Doesn’t)
A SCORM package doesn’t send results anywhere. It looks for the LMS in the page around it, and if it can’t find one, the course plays regardless.
At launch it looks for the LMS’s connection point in the window it sits in, then that window’s parent, then that parent’s parent, up to seven levels, then the window that opened it. The discovery code shipped inside a standard package gives up there with a browser alert — “Error finding API — too deeply nested.” after the seventh frame, “Unable to find an API adapter” after the opener — then runs the course anyway. An alert in one learner’s browser is not an alert in your gradebook.
That mechanism explains three situations you will otherwise walk into:
- You double-click the launch page on your own machine to “check it.” No LMS in the page, so nothing is recorded.
- You host the content on the company web server and point the LMS at that address. Moodle documents that externally hosted content plays from where it lives rather than being unpacked into the platform; when that address is on a different domain, the browser blocks the conversation and no grade or tracking data comes back.
- The package sits too deep inside a platform’s own page layout. It hits the seven-level limit and gives up.
The error wording and platform behavior in this article are Moodle’s, because Moodle publishes both. Other platforms word the same failures differently.
One thing that connection carries deserves its own decision. Resume state — the small field a package uses to remember where a learner stopped — is stored by the LMS and readable by the LMS, which is why Mini Course Generator’s SCORM documentation for its open-source role-play activity keeps raw transcript text out of it. Before assigning an activity that captures what a learner types, ask where the words end up.
An LMS and a SCORM File Do Two Different Jobs
The two get compared as if you had to choose, and you don’t. The package carries the content and the rules for what to report; the platform hosts it, launches it, keeps the record and decides what it accepts.
Which makes “is our LMS SCORM compliant?” the wrong question. The useful one is compliant at what, because a single badge covers three capabilities that are bought, built and broken separately:
| The capability | What it means in practice | How you’d know |
|---|---|---|
| Accepting the import | The zip goes in and the lessons appear | Import one and watch for an error |
| Running the 2004 rules | Sequencing and navigation decide what a learner may open next | Take a 2004 package through a branch, see if the platform obeys |
| Returning a usable record | A status, a score and a date, per learner, in the gradebook | Take the module as a test learner and read the gradebook |
Almost every platform does the first. The distance to the second is longer than a feature list suggests, and it’s where SCORM 2004 projects go wrong. The third is what your auditor cares about, and nobody demonstrates it unless you ask. None is settled by a badge; they’re settled by putting your own package in the platform and reading what came back.
One fork is worth naming before you build anything: SCORM is what you produce when the content has to run inside a system somebody else owns — most client, customer and parent-company training, very little internal training.
The handshake runs both ways, and a platform can sit on both sides of it. Mini Course Generator exports a course as a SCORM package for a system you don’t control, and its SCORM Upload Block accepts a package produced elsewhere, places it inside a course, and reports how learners interact with it. Most authoring tools only export.
SCORM Is a Finished Standard, and What That Does to “SCORM Compliant”
The ADL Initiative, the organization that wrote SCORM, has been shut down and its work archived for public use. There will never be another SCORM version, and the packaging structure the zip inherits stopped moving years before that — which is why a package built in 2014 still imports today.
That removes the argument most teams reach for first: “future-proofing” is not a reason to pick a version, because there’s no future to proof against. The only live question is which version your LMS handles.
Then there’s the version string. The version a platform serves comes from a plain line of text in the manifest, and Moodle matches that line against five exact values — 1.2, 1.3, CAM 1.3, 2004 3rd Edition and 2004 4th Edition — and anything else falls through to the SCORM 1.2 runtime. A manifest that says “SCORM 2004” or “2004 2nd Edition” gets served 1.2, every 2004 call the package makes then fails, and the import screen shows no error. Which drains most of the meaning out of “SCORM compliant”: the line deciding the run-time is text any exporter can write, and nobody is checking what gets written.
None of this means stop using SCORM — only that no new versions are coming. SCORM 1.2 is still what LMS imports overwhelmingly accept. If your question is which standard you actually need rather than which SCORM version, that’s a different comparison.
SCORM 1.2 or SCORM 2004: The One Difference That Decides It
The version question gets framed as “2004 is newer and richer”, which decides nothing. Two questions do: does an auditor need completion and pass as two separate facts, and does your LMS actually run 2004.
| What it does | SCORM 1.2 | SCORM 2004 |
|---|---|---|
| Status | One field, one value at a time: passed, completed, failed, incomplete or browsed | Two independent fields: completion status and success status |
| Resume state | 4,096 characters | 64,000 characters |
| Score | Raw score, declared range 0 to 100 | Raw, minimum and maximum, plus a scaled score from -1 to 1 |
| Schema files in the package | Four | Twenty-nine |
| Parts of the standard declared in the manifest | Three | Six, the extras being sequencing and navigation |
One status field, or two
That first row is the whole decision. If an auditor needs to see that somebody both finished the training and passed the assessment, SCORM 1.2’s one field forces you to report one or the other — and teams tend to meet that at the first audit, not before the first upload. Where compliance training records have to carry both facts for the same person, the version is decided for you: 2004.
How much the course can remember
Resume state is what lets a learner close a module on Tuesday and pick it up on Thursday in the right place, and the ceiling an LMS enforces on that field differs by a factor of fifteen. A short linear module never comes close. A long branching course that stores every choice a learner made can outgrow the smaller one, and the state then truncates silently and the learner loses their place mid-course. A length-of-course question, not a feature question.
Scores
SCORM 1.2’s raw score carries a declared range of 0 to 100; 2004 adds minimum, maximum and a scaled score. The effect shows up in the gradebook: a 40-question assessment scored out of 40 has to be converted to a percentage before it’s reported, or the number that lands is either rejected or meaningless.
Why “supports SCORM 2004” is a bigger claim than it sounds
The last two rows are the measure of it. Four schema files become twenty-nine; three declared parts of the standard become six, and the extras are sequencing and navigation — the rules deciding what a learner can open next, and the part platforms implement least consistently. So “we support SCORM 2004” and “we run your SCORM 2004 sequencing rules” are two different claims. Put the second to your LMS admin and ask them to prove it with a package, not a feature list.
The decision rule: default to SCORM 1.2, choose 2004 only for one of the two reasons above, and then confirm it by running a 2004 package end to end in your own LMS, sequencing included, before you commission the content. For the two versions side by side, edition by edition, that comparison is here.
What “SCORM Compliant” Actually Means
Start with the collision, because it’s the expensive one. In a regulated industry, compliance is a regulator’s word — OSHA, HIPAA, FINRA, an FDA inspector. SCORM compliance is not that word: no regulatory standing, no regulator with an opinion about it, no inspector who will accept or reject it. It’s a claim about whether a file and a platform can talk to each other. And both meanings turn up in the same document — an RFP asking for “SCORM compliant compliance training” switches senses between two lines, and nobody flags the switch.
Compliant, conformant, certified
Three words get used as one, and they promise different things.
| The word | What it claims | Who can honestly say it |
|---|---|---|
| Compliant | Everyday, loose usage: this thing works with SCORM | Anyone, about anything |
| Conformant | This content, or this platform, follows the standard’s rules | Content and platforms |
| Certified | A product was tested against the standard by an authority and labeled as passing | Nobody, currently |
A widely used industry reference on the standard treats the first two as more or less interchangeable and notes that the third has a specific and important meaning. It is also plain about a distinction most feature pages ignore: only content and platforms can technically conform. A tool that produces content can’t — it can produce conformant output, which is narrower and checkable. So “SCORM compliant authoring tool” is a category error by the standard’s own definitions. Not dishonest so much as empty. “Our export produces SCORM 1.2 packages, and we’ve run them through these three platforms” is the sentence that means something.
Nobody is checking
The same reference still describes the certification program in the present tense: a product is submitted, tested, its conformance validated, an official label issued, the certified products published in a list. That program belonged to ADL, the organization shut down earlier in this guide, and no public register is left to check a vendor against. The official conformance test suite for SCORM 2004 hasn’t changed in eleven years either — nobody maintains it, and no result from it is recorded anywhere.
That isn’t a scandal and it doesn’t make the standard useless: packages built a decade ago still import, and every mechanism in this guide still holds. What’s gone is the audit. A “SCORM certified” badge in circulation today is a self-assessment — a different thing from a lie, and a very different thing from an independent test. It is not evidence you can put in front of an auditor. A completion record from your own platform, produced by your own package, is.
What to ask instead
Four questions. Each is checkable, each has a wrong answer, none needs a certifying body.
- Which SCORM version does your export produce? A version, in writing. “SCORM” is not a version and “the latest” is not an answer.
- Which platforms have you tested against, by name, and when? “Every major platform” means nobody wrote any of them down.
- Can I run my own package through it before I buy? A yes with a route beats a yes.
- If we leave, does the content come back out, and in what form? Ask that one before you sign, not during the migration.
Ask them of the authoring tool and of the platform separately: different vendors, different answers, and your package has to survive both. Score them in the RFP — a vendor can fail these, which is the point — and weight the second one, because “we support SCORM” and “we’ve seen a package like yours work” are not the same claim.
How to Make a SCORM File: Five Routes and What Each One Suits
Five ways to produce a package, and the right one is decided by who maintains the content after it ships, not by what’s cheapest this week.
An authoring tool
The route most teams take, and the tool choice is a separate decision. Articulate, Adobe Captivate, iSpring and Easygenerator are among the tools that publish SCORM. Whatever you pick, ask which version it exports and put one package through a full test before moving a library into it.
Exporting from the platform that hosts the course
Where the course already lives on a platform, producing a package is a button rather than a build. Mini Course Generator is our product, and it will export a course as a SCORM package; a dynamic SCORM export is a higher-tier feature, and the plans and what’s included page is where to check that. The route suits a team that owns the content and has to hand a copy to a client, a franchisee or a parent company running its own LMS.
Generating the activity and the package together
An agent can produce an interactive activity and wrap it as a package in one pass — a different job from building a full course. Generating the activity and the package together covers how it works and where it goes wrong.
Mini Course Generator’s [AI Role-play Agent Skill](/skills/role-play/) exports as SCORM. Its open-source documentation names the SCORM version it produces, 1.2, and the platforms it has been tested with: Moodle, Canvas, Cornerstone, SAP SuccessFactors, Mini Course Generator and SCORM Cloud.
By hand
Writing the manifest yourself is legitimate for one self-contained HTML activity and wrong for a multi-lesson course, where keeping a hand-maintained list of resources in step with the actual files is where the mistakes live.
One rule applies whichever route you take, and it causes more failed imports than anything else: the manifest has to sit at the root of the zip. Select the folder’s contents and compress those, rather than compressing the folder.
If you’re converting a deck, a video or a PDF
A converter will turn a slide deck, a video or a PDF into a package, and the package will import. What it can report afterwards is the question nobody asks first. A deck with no questions in it has nothing to say except that somebody opened it, and a video is the same story with more confidence attached: the package reports what the wrapper was built to report, usually that it launched, not that anyone watched to the end. If the record has to show more than “opened”, the conversion is the starting point and the assessment is the work.
Conversion is also the one route where nobody decided how the content would be declared. You didn’t set adlcp:scormtype and neither did the person who sent you the deck — the converter did, and its default is the difference between a module that completes and one that never will. Open the manifest of anything a converter produced and confirm the lessons came out trackable.
The Four Failures, in the Words Your LMS Uses
Four causes account for most import failures, plus a silent fifth that produces no message at all. In Moodle’s wording:
| What you see | What actually happened | What to do |
|---|---|---|
| A manifest was found, but not in the root of your zip file | The folder was compressed instead of its contents | Open the folder, select everything inside, compress that |
Incorrect file package, missing imsmanifest.xml or AICC structure |
No manifest anywhere in the archive | Re-export, and check you uploaded the package and not a stray file |
| The following resources were referenced in your manifest but couldn’t be found | A filename in the manifest doesn’t match a real file, capital letters included | Rename the file to match the manifest exactly |
| You must provide a valid zip file, or an error during unzip | The archive is corrupted or in the wrong format | Re-download or re-export the package |
| Nothing. It imports, it plays, it never completes | The content is marked as an asset instead of a trackable object, or the version line wasn’t recognized | Open the manifest, check adlcp:scormtype and the version line, re-export |
The wrapper-folder failure at the top is common enough that Moodle keeps a deliberately broken package in its test suite for it. If an import fails and you changed nothing about the content, rule that out first.
Some platforms are also more forgiving than others, which sets a trap. Moodle will mark a package complete when the package never set a status, and will recompute pass or fail from a mastery score you configured. A stricter platform won’t do either — so “it worked in Moodle” and “it will pass an audit in our production LMS” are two different claims, which is why the test below has two stages.
Test It Before It Touches Your Live LMS
Two stages, and the first costs nothing.
Stage one: a validator outside your LMS. SCORM Cloud plays a package the way an LMS would. Its Trial plan costs $0 and includes three courses, 5 GB of storage and ten resettable registrations, with the first paid step at $40 a month (Rustici’s published pricing, September 2026). Rustici’s own wording is that the trial isn’t time-based, so an account can stay on it for years, and a registration is one learner in one course who can come back without using another. Stage one catches manifest errors, missing files, the wrapper folder, an unrecognized version line and packaging faults — every row of the table above, in minutes, with no budget request.
Stage two: your own LMS, with a test learner. Stage one can’t tell you how your platform behaves:
- Import the package into a course nobody is enrolled in.
- Enroll one test account and take the module the way a learner would.
- Check the gradebook: is there a status, is there a score, and is the score the number you expected.
- Leave halfway through, come back, and confirm it resumes in the right place.
- Do the whole thing once on a phone.
That catches what stage one can’t: how your platform nests the player, whether the content is served from the same address, how it reads a status, where a score lands, and whether the player works on the device your staff will actually use. “It passed the validator” is not “it works in ours”, and only the second survives an audit.
Can You Download a SCORM File, or Turn One Into a PDF?
A SCORM package is an ordinary zip, so it downloads like any other file from wherever you keep the source. Getting one back out of a platform you already imported it into is a different question. Moodle documents that packages are unpacked on import, with externally hosted packages as the exception, and a platform that unpacks a package serves those unpacked files — so there’s no archive left to hand back unless somebody built a re-export on purpose. Check your own platform rather than assuming, and keep the source zip in your own storage, versioned and dated in the filename. That’s the copy you re-upload when the policy changes, and hand over when the LMS changes.
There’s no PDF of a SCORM course either, because a SCORM course isn’t a document. It’s a small web application, and the quizzes, branching and scoring have no print equivalent; converting one into a page of text throws away the only parts that produce a record. If somebody needs something printable, produce it from the source material — an argument for keeping the content somewhere that does both. Mini Course Generator, for one, exports a mini-course as a PDF or as a SCORM package at any point, so the handout and the package come from the same source instead of from each other. And if you’re holding a package somebody else produced, with nowhere to put it, the upload route named earlier gets you a record without opening it.
Opening a package without an LMS
Unzip the file and open the launch page in a browser: you’ll see the content, because a browser is all a small web application needs to draw itself. It records nothing, since there’s no LMS in the page. A local open is a content check, never a tracking check.
Before You Upload Anything
Four steps, in this order.
- Open the zip. Confirm the manifest is at the root and the lessons are marked as trackable objects rather than assets.
- Default to SCORM 1.2; choose 2004 only for a separately recorded pass and completion, or a course long enough to outgrow the resume limit.
- Run the package through a free validator and fix everything it finds.
- Then run it in your own LMS with a test learner, on a desktop and a phone, before a single person is assigned.
And if you control where the training runs, the package may not be the answer at all: you can run the course on your own LMS, where the platform holds the completion record and there’s nothing to build, version or re-upload. Either way, test with a learner account before the rollout, not after.
Frequently Asked Questions
What does SCORM stand for?
Sharable Content Object Reference Model. Sharable, because the same package is meant to move between platforms; content object, because the tracked unit is a piece of content rather than a whole course; reference model, because it’s a set of agreements other people implement, not software anybody ships. It’s said as a word — “skorm”, rhyming with storm — and the standard spells “Sharable” with one E, so you’ll see “shareable” just as often for the same thing. The middle two words are the ones to carry around: a sharable content object, or SCO, is the unit that gets a live connection to the platform and a status of its own.
Is a SCORM file the same thing as a SCORM package?
Yes. “Package” is what an export produces and “file” is what lands on your disk: the same zip, the same manifest.
What’s the difference between a learning management system and SCORM?
An LMS is software: it holds your people, your enrollments and your completion records. SCORM is an agreement about how a course and an LMS talk, so a course built anywhere can be dropped into a platform bought from somebody else. You buy the first; nobody buys the second — a platform either handles it or it doesn’t.
What does “SCORM compliant” mean?
That a vendor is telling you their content or their platform works with SCORM. It isn’t an independently verified status: the organization that once certified products has been shut down, and no public register is left to check a claim against. Treat it as the start of a conversation — which version, which platforms — not an answer.
Are all learning management systems SCORM compliant?
No. And among those that say they are, the badge covers three separate capabilities: accepting the import, running SCORM 2004’s sequencing rules, and returning a completion record an auditor will accept. Ask which of the three your platform does, then prove it with one package and a test learner.
What does an LMS need before it will record a completion?
Three things at once. The lesson has to be declared as a trackable object rather than an asset. The version line has to be one the platform recognizes, or it gets served a different run-time and the calls fail. And the package has to reach the platform in the page around it — same address, not nested too deeply, not opened from a desktop. Miss any one and the course still plays perfectly.
It plays, but nothing appears in the gradebook, or everyone shows incomplete.
The two silent failures, and they map onto the conditions above. Nothing in the gradebook usually means the package can’t find the LMS: a local copy, a different address, or too deep in the page. Everyone stuck at incomplete usually means the lessons were declared as assets, or the version line wasn’t recognized — open the manifest and read those two lines before blaming the platform or the learners.
Our LMS only accepts SCORM 1.2. Is that a problem?
For most training, no. It becomes one when an auditor needs completion and pass as two separate facts for the same person, or when a long branching course has more to remember than 4,096 characters. Outside those two cases 1.2 does the job, and it’s the version LMS imports accept most widely.
Do I need SCORM at all?
Only when the content has to run inside an LMS you don’t control: a client’s, a customer’s, a parent company’s. If you own the delivery, the platform hosting the course tracks who finished and a share link or an embed is all the learner needs — which is what delivering without a package covers.
How do I decide between SCORM and xAPI?
Choose SCORM when the content has to import into an LMS you don’t control, still the common case. Choose xAPI when you need a record of learning that happens outside a course and you have somewhere to store it.
Sources
- The ADL Initiative’s archived repositories, and the official SCORM 2004 4th Edition conformance test suite, unchanged in eleven years
- Moodle’s SCORM settings documentation and its own SCORM module: the import errors, the externally-hosted behavior, the five version strings, the mastery-score recalculation, and the package counts and data-model limits quoted above
- The API discovery routine shipped inside standard SCORM packages: the seven-frame search, the opener fallback, the two alerts
- The SCORM documentation for the open-source edu-role-play activity: its SCORM version, the resume-state rule and the platforms it was tested against
- A widely used industry reference on the standard: the three words, the certification programme it still describes, and the rule that a tool producing content cannot conform
- Mini Course Generator’s product documentation, for the SCORM Upload Block
- Rustici Software’s published SCORM Cloud plans and pricing, read in September 2026
