SCORM 1.2 vs 2004: Differences & Which SCORM Version to Use

Short answer: use SCORM 1.2 unless you need something only SCORM 2004 can do. SCORM 1.2 runs on virtually every LMS and is the right choice when all you track is completion and a score. SCORM 2004 (4th Edition) earns its place when you need completion and pass/fail recorded separately, more than 4,096 characters of saved progress, or the LMS to enforce the order of modules.

What Actually Differs Between SCORM 1.2 and 2004

In practice, five differences decide it:

1. Status. SCORM 1.2 has one field, cmi.core.lesson_status, so a learner is either "completed" or "failed", never both. SCORM 2004 splits it into cmi.completion_status and cmi.success_status, so "finished the content, failed the test" can be recorded.
2. Saved progress. SCORM 1.2 guarantees 4,096 characters of suspend_data; SCORM 2004 3rd and 4th Edition guarantee 64,000. Long Storyline and Rise courses run out of room in 1.2.
3. Sequencing. SCORM 1.2 has none, so any "finish Module 1 before Module 2" logic lives in the course. SCORM 2004 lets the LMS enforce prerequisites and navigation rules.
4. LMS support. Both are widely supported, but SCORM 1.2 behaves more consistently across platforms. SCORM 2004 support varies, especially for sequencing.
5. Code. The API object (API vs API_1484_11), the calls (LMSInitialize vs Initialize), the data model names and the imsmanifest.xml all differ, so a package built for one version won't run as the other without republishing or rewriting.

One of the first questions I get from clients is: "Which SCORM version should we use?" For the majority of projects I work on, the answer is SCORM 1.2 — it remains the dominant version in use. But a significant minority genuinely needs 2004's features, and the rest of this guide is about telling which camp you're in.

If you're not sure what SCORM is, start there. This guide assumes you know the basics and need to decide between versions.

All SCORM Versions, and Which Is the Latest

The latest SCORM version is SCORM 2004 4th Edition, released in March 2009. It is also the last: ADL has not published a SCORM version since, and its later work went into xAPI. Counting the SCORM 2004 editions separately there have been seven releases, but only two are worth considering for a new course today. Here is the full list, so you know what an LMS or authoring tool means when it lists "supported SCORM versions":

xAPI (2013) and cmi5 (2016) are often listed alongside these, but they are successors to SCORM rather than SCORM versions — they use a different runtime and a different way of storing data. If your project needs mobile, offline, or off-LMS tracking, they are worth a look; for a course that will live inside an LMS, the choice is still SCORM 1.2 or SCORM 2004 4th Edition, and the rest of this guide compares the two.

SCORM 2004 2nd vs 3rd vs 4th Edition

If you pick SCORM 2004, you also pick an edition. The run-time API and data model are essentially the same across all three; the differences are in limits and sequencing:

• 2nd Edition (2004) guarantees only 4,000 characters of suspend_data and has known ambiguities in its sequencing rules. Use it only if a legacy LMS supports nothing newer.
• 3rd Edition (2006) tightened the sequencing specification and raised suspend_data to 64,000 characters. According to Rustici, it is the most widely used 2004 edition.
• 4th Edition (2009) clarified sequencing further and added features such as shared data between SCOs and jump navigation. It's the edition I'd target if your LMS supports it; fall back to 3rd Edition if it doesn't.

How to Tell Which SCORM Version a Package Uses

Open the imsmanifest.xml at the root of the ZIP and look at the <schemaversion> element:

The JavaScript gives it away too: a SCORM 1.2 course looks for an object called API and calls LMSInitialize; a SCORM 2004 course looks for API_1484_11 and calls Initialize.

SCORM 1.2 vs SCORM 2004: Feature Comparison

Here's a side-by-side comparison of SCORM 1.2 and SCORM 2004 4th Edition — the edition to target if you choose 2004:

SCORM 1.2: The Reliable Workhorse

SCORM 1.2 has been around since 2001, and it's still the most commonly used version. There's a reason for that — it does the fundamentals well without unnecessary complexity.

What SCORM 1.2 Does Well

Broad compatibility. Virtually every LMS on the market supports SCORM 1.2 — it's the most widely adopted e-learning standard in existence. This matters enormously when you're deploying across multiple platforms or don't control which LMS your content ends up in.

Simple implementation. The API is straightforward. There are fewer data model elements to deal with, fewer edge cases, and fewer opportunities for things to go wrong. When I'm building custom SCORM courses, 1.2 packages consistently have fewer LMS-specific issues.

Battle-tested. Twenty-five years of real-world use means the quirks are well-documented and the workarounds are established. The common SCORM errors you'll encounter with 1.2 are well-understood.

Authoring tool support. Every SCORM authoring tool supports 1.2 output, and most default to it.

Where SCORM 1.2 Falls Short

Single status field. SCORM 1.2 combines completion and success into one field (cmi.core.lesson_status). A learner is either "passed," "failed," "completed," "incomplete," "browsed," or "not attempted." You can't separately track "completed the course but failed the assessment" without workarounds.

Limited suspend data. At 4,096 characters, the suspend data field can be tight for courses that need to save complex state — branching scenario progress, multiple quiz attempts, interactive element states.

No sequencing. SCORM 1.2 has no built-in mechanism for enforcing navigation order. If you need learners to complete Module 1 before accessing Module 2, the course itself must handle that logic, not the standard.

Basic score model. SCORM 1.2 supports raw, min, and max score sub-fields, but only at the course level — there's no scaled score, and per-objective scores don't integrate with sequencing or rollup. If you need granular competency-level reporting, you're working around the standard rather than with it.

SCORM 2004: The Feature-Rich Option

SCORM 2004 addressed the limitations of 1.2 with a significantly more capable specification. It went through four editions, with the 4th edition (2009) being the current version.

What SCORM 2004 Does Well

Separate completion and success. This is the single biggest practical improvement. With SCORM 2004, you can track that a learner completed all the content (completion_status = "completed") but failed the final assessment (success_status = "failed"). For compliance training, this distinction is often critical.

Multiple objectives. Each SCO (Sharable Content Object) can report against multiple learning objectives, each with its own completion and score. This enables detailed competency mapping — "the learner met Objective A and C but not B."

Sequencing and navigation. SCORM 2004 can enforce navigation rules at the LMS level: prerequisites, attempt limits, choice restrictions. The LMS controls what the learner can access and when. This is powerful for structured learning paths.

More data space. 64,000 characters of suspend data (in the 3rd and 4th editions) and 1,000-character bookmarks give courses much more room to save complex state.

Richer scoring. Scaled scores (-1 to 1) plus raw, minimum, and maximum values per objective provide much more granular performance data.

Where SCORM 2004 Falls Short

Sequencing complexity. SCORM 2004's Sequencing and Navigation (SN) specification is notoriously complex. Many LMSs implement it differently, leading to inconsistent behaviour. Some LMSs claim 2004 support but struggle with advanced sequencing rules. I've seen more hours lost to sequencing debugging than any other SCORM issue.

API differences. The API object name changes from API (1.2) to API_1484_11 (2004). The data model element names change too (cmi.core.lesson_status becomes cmi.completion_status and cmi.success_status). These aren't dramatic changes, but they mean a course built for one version won't work with the other without modification.

Implementation inconsistency. Because the specification is significantly larger and more complex than SCORM 1.2, LMS vendors interpret parts of it differently. A 2004 course that works perfectly in Moodle might behave unexpectedly in Cornerstone or SAP SuccessFactors. I encounter these discrepancies regularly in my testing and consultation work — and version choice is one of the most common questions I'm asked as a SCORM consultant.

Overkill for simple content. If you just need "did they finish?" and "what did they score?" — SCORM 2004 adds complexity without benefit.

Decision Framework

Here's how I advise clients:

Use SCORM 1.2 When:

• You need maximum LMS compatibility
• Your tracking requirements are straightforward (completion + one score)
• You're distributing content to multiple organisations or platforms
• You're converting PowerPoint presentations to e-learning
• You want the simplest, most reliable option
• Your LMS's SCORM 2004 support hasn't been verified

Use SCORM 2004 When:

• You need to separately track completion and pass/fail (common in compliance)
• You must track multiple learning objectives within a single course
• You need LMS-controlled sequencing (prerequisites between modules)
• You need more than 4,096 characters of suspend data
• You've verified your target LMS handles SCORM 2004 correctly
• Your reporting requirements demand per-objective scoring

Check With Your LMS First

Before committing to SCORM 2004, test it with your specific LMS. Upload a sample 2004 package and verify:

1. Completion status reports correctly
2. Success status (passed/failed) reports correctly
3. Scores record as expected
4. Bookmarking works on resume
5. Sequencing rules (if used) behave as intended
6. Terminate() fires correctly on all exit paths (normal close, browser close, session timeout) — improper termination is a frequent cause of lost data
7. Suspend data persists across sessions (especially if your course saves complex state)
8. Interaction/assessment data records correctly (question IDs, responses, results)
9. Rollup behaviour works as expected for multi-SCO courses

I've seen too many projects hit problems late in development because someone assumed their LMS fully supported 2004 features it only partially implemented. Always test on SCORM Cloud first, then on your actual production LMS. If you'd rather not build that test rig yourself, my SCORM testing service covers exactly this. See version-specific testing differences in our SCORM testing checklist.

Real-World Examples

Compliance Training

A client needed annual compliance training where employees must view all content AND pass a final assessment with 80% or above. SCORM 1.2 can only report one status — so if someone views everything but scores 60%, what do you record? "Failed" loses the completion data. "Completed" hides the failure.

SCORM 2004 was the right call here: completion_status = "completed", success_status = "failed". The LMS could then require a re-take of the assessment without making the learner redo the entire course.

Product Training Library

A company had 200+ short product training modules being deployed across three different LMS platforms (their own, a partner's, and a client's). Simple tracking — just completion, no scoring needed.

SCORM 1.2 was the obvious choice. Maximum compatibility, zero sequencing complexity, and the simplest possible tracking.

Competency-Based Programme

A professional development programme needed to track learner progress across 12 competency areas within a blended course. Each module assessed multiple competencies, and the programme needed to identify specific skill gaps.

SCORM 2004 with multiple objectives tracking was essential. Each SCO reported scores against 3-4 competency objectives via the cmi.objectives.n.* data model. Note that cross-SCO aggregation required careful use of global objectives and thorough LMS testing — rollup rules operate on activity status, not objectives directly, so this took extra implementation work to get right.

What About xAPI?

If you're evaluating SCORM versions, you might wonder whether to skip SCORM entirely and use xAPI (Experience API). xAPI is more modern and flexible, but:

• Not all LMSs support xAPI natively — many require plugins or a separate LRS
• xAPI requires a Learning Record Store (LRS), which adds infrastructure unless your LMS has one built in
• xAPI has no built-in sequencing or packaging standard (cmi5 addresses packaging and launch, but intentionally omits complex sequencing)
• SCORM's ecosystem of tools and expertise is vastly larger

For LMS-hosted courseware, SCORM remains the most practical choice in 2026. xAPI excels when you need to track learning beyond the LMS — but that's a different conversation.

My Recommendation

If you're not sure, start with SCORM 1.2. Most authoring tools let you republish in SCORM 2004 later, though you'll need to redesign course logic to actually use 2004-specific features like separate completion/success tracking or sequencing — simply changing the export format doesn't give you those capabilities automatically. Also note that historical learner data in your LMS may not migrate to a republished package (this varies by LMS). Still, this is far less painful than the alternative — discovering mid-project that your LMS doesn't handle 2004 well and having to strip out features your design depends on.

If you know you need SCORM 2004's features, invest time in testing early. Build a proof-of-concept, test it in your LMS, and verify the specific features you need actually work as expected before committing to a full development programme.

Need help deciding? I'm happy to review your requirements and give you a straight answer. Book a free consultation — it's the fastest way to get clarity on what'll work for your specific situation.

Frequently Asked Questions

What is the difference between SCORM 1.2 and 2004?

SCORM 1.2 reports one status field (cmi.core.lesson_status) covering both completion and pass/fail, stores 4,096 characters of suspend data, and leaves navigation entirely to the course. SCORM 2004 (4th Edition) splits completion and success into cmi.completion_status and cmi.success_status, adds a scaled score, raises suspend data to 64,000 characters, and lets the LMS enforce sequencing and prerequisites. The API object differs too — API with LMSInitialize/LMSCommit/LMSFinish in 1.2, API_1484_11 with Initialize/Commit/Terminate in 2004 — so the two manifests and run-times are not interchangeable.

Is SCORM 2004 better than SCORM 1.2?

SCORM 2004 is more capable, not universally better. It adds separate completion and success status, scaled scores, LMS-enforced sequencing and 64,000 characters of suspend data. But it is a larger, more loosely implemented specification, so LMS behaviour is less predictable. For a course that only needs completion and a score, SCORM 1.2 is the safer and simpler choice.

Which SCORM version is more widely supported?

SCORM 1.2. It is supported by virtually every LMS and remains the most widely used version. SCORM 2004 is also widely supported, but the depth of that support varies — many platforms handle the run-time data model well yet implement sequencing and navigation partially or inconsistently. Test SCORM 2004 in your specific LMS before committing to it.

Can I convert a SCORM 1.2 course to SCORM 2004?

Usually, yes. If the course was built in an authoring tool such as Articulate Storyline, Rise or iSpring, republish it and pick SCORM 2004 (4th Edition) as the output format. A hand-coded course needs more work: the API object changes from API to API_1484_11, data model elements are renamed (for example cmi.core.lesson_status becomes cmi.completion_status and cmi.success_status), and the imsmanifest.xml must be rewritten. Either way, converting does not automatically give you sequencing or separate completion/success tracking — those have to be designed in.

Why does my SCORM 1.2 course lose progress?

The most common cause is the 4,096-character suspend_data limit. Courses that save a lot of state — branching scenarios, many slides, multiple quiz attempts — can exceed it, and the LMS then truncates or rejects the data, so the learner resumes from the wrong place or from the start. Other frequent causes are the course not calling LMSCommit and LMSFinish when the learner closes the window, and session timeouts. If you're not sure which one you're hitting, SCORM testing against your LMS will show it. Fixes include trimming what the course stores in suspend data or moving to SCORM 2004, which allows 64,000 characters.

Does Articulate Storyline or Rise default to SCORM 1.2?

Yes. Both Articulate Storyline 360 and Rise 360 default to SCORM 1.2 when you publish for an LMS. SCORM 2004 (2nd, 3rd and 4th Edition), xAPI and cmi5 are available from the same publish dialog, so you can switch. If you leave the default in place, your course will report a single lesson_status and be limited to 4,096 characters of suspend data.

Should I use xAPI instead of SCORM?

Only if you need to track learning outside an LMS — mobile apps, simulations, offline or on-the-job activity. xAPI needs a Learning Record Store (LRS), and not every LMS has one built in. For a course that lives inside an LMS, SCORM 1.2 or SCORM 2004 remains the practical choice in 2026, and cmi5 is worth a look if your LMS supports it and you want xAPI-style tracking with SCORM-style packaging.

What is the latest version of SCORM?

SCORM 2004 4th Edition, released by ADL in March 2009. It is the final SCORM release — there is no 5th Edition. ADL's later work went into xAPI, and cmi5 followed as a way to use xAPI inside an LMS. In practice, "latest" doesn't mean "most used": SCORM 1.2 is still the most widely deployed version.

What is the difference between SCORM 2004 3rd and 4th Edition?

Both guarantee 64,000 characters of suspend data and use the same run-time API. The 4th Edition clarifies the sequencing rules further and adds features such as shared data between SCOs and jump navigation. Pick 4th Edition if your LMS supports it, and 3rd Edition if it doesn't.

Still not sure which way to go? A short consultation is usually enough to settle it.

Official SCORM Specifications (ADL)

SCORM was published by ADL (Advanced Distributed Learning), a US Department of Defense initiative, and the official specifications are split into "books". SCORM 1.2 has three: the Overview, the Content Aggregation Model (CAM, which defines imsmanifest.xml) and the Run-Time Environment (RTE, which defines the API and data model elements such as cmi.core.lesson_location). SCORM 2004 adds a fourth, Sequencing and Navigation (SN). ADL hosts the documents for each edition on its SCORM page. For day-to-day work, Rustici's run-time reference chart is quicker to search than the specification itself.

Further Reading

• SCORM Run-Time Reference Chart — the definitive data model comparison (Rustici Software)
• SCORM Versions: The Evolution of eLearning Standards — version history and adoption data
• SCORM 2004 Sequencing and Navigation — deep dive into the S&N specification
• ADL SCORM 2004 4th Edition Documentation — official specification documents
• xAPI Overview — if you're considering moving beyond SCORM
• cmi5 Technical 101 — the bridge between SCORM packaging and xAPI tracking