Import an Adobe Captivate course (.cptx or published output)

Three different Captivate formats are recognized, and the importer decides which one it has by looking inside the file, not at its name:

• A Classic HTML5 publish (Captivate 9 to 2019, i.e. 11.x). Captivate compiles the whole project into assets/js/CPM.js. It is the same whether you published to SCORM 1.2, SCORM 2004, xAPI or plain HTML5. Tested against real publishes from Captivate 9.0.2, 2019 11.0.1, 11.5.5 and 11.8.3.
• An all-new Captivate publish (12.4 onward, including 13.x). There is no CPM.js; the model lives in assets/js/project.js. Tested against publishes from 12.6, 13.0 and 13.2.
• A Classic project file (.cptx). Read directly from the binary project format, answer keys included. Tested against real project files from Captivate 9.0, 2017 (10.0) and 2019 (11.0).

Nothing in a published package is ever run: the JavaScript files are parsed as data, and only literal values are read.

You do not need the .cptx. A Captivate HTML5 publish carries the slides, the text (as caption HTML where the version keeps it, and always as each item's accessibility text), the images, audio, video, closed captions and the quiz definitions, including which answers are correct. That is what the importer reads.

This matters because the published zip is very often the only thing that survived: the project was on a departed colleague's laptop, or the vendor delivered only SCORM.

Unless its actions keep state (see the next section), each Captivate slide becomes a lesson of ordinary, editable blocks in reading order — headings, paragraphs, images, audio and video — rather than a fixed-size slide. The point of leaving Captivate is a course that reflows on a phone, reads correctly with a screen reader and can be edited by anyone, so pixel positions and slide timing are deliberately not kept.

• Questions with their answer keys: multiple choice (true/false publishes as a two-option choice), multiple answer, fill-in-the-blank, matching and sequence.
• Short answer: one-to-three-word answers become a fill-in-the-blank with the same accepted answers; longer answers become a reflection that shows the author's model answer, because Captivate only ever accepted an exact sentence.
• Hotspot questions become questions where the learner chooses the right area by name, so they work by keyboard and screen reader.
• Drag-and-drop questions and interactions become matching or categorize questions when every item and target has words to choose by.
• Question pools: a pool that random question slides drew from becomes a lesson holding its questions that draws as many per attempt as Captivate did.
• Click-to-reveal buttons become accordion sections; buttons that opened a web page stay as links.
• Closed captions are kept as transcripts; narration clips are kept and start when the learner presses play.
• The pass mark from the quiz settings becomes the course passing score.
• Text and logos repeated on most slides (master-slide furniture) are kept once, and Captivate's own results slides are left out.

A course whose actions only move between slides or reveal text loses nothing by reflowing. One whose actions keep state cannot: a variable set on one slide and tested on another, an advanced action that shows the Next button once every topic has been visited, a portrait that switches to its COMPLETED state. When a Classic publish has any of those — a variable assigned, a condition tested, an object's state changed — the whole course lands on the slide canvas instead: each slide at its size, each object where Captivate placed it and under the name Captivate gave it, and its actions rebuilt as triggers that run in the exported package.

What comes across as working triggers:

• Events: the success action of a button, a click box or a smart shape used as a button (a click); a slide's On Enter action (when the slide starts); its On Exit action (when the slide's timeline ends), on a slide that never pauses for a click.
• Jumps: go to the next or previous slide, jump to a slide. Captivate jumps once the whole action has run, so the jump runs last here too.
• Show and hide of objects on the same slide.
• Variables: the project's own, with their starting values; assign, increment and decrement. Captivate's system variables (cpInfo…, cpCmnd…, cpQuiz…) are left behind.
• Conditional (advanced and shared) actions: each if becomes a trigger per branch; AND becomes *all conditions*, OR becomes *any*, else the opposite. A toggle — an action that changes the variable its own condition tests — gets a small variable of its own (branch_1 and on) so it reads its condition once, as Captivate does.
• Change state, to a state the object has, with the state's picture or words. A state Captivate resets on every visit (Retain state off, its default) is reset the same way.
• Open URL (web and mailto links) in this window or a new one.

The rest of the slide comes with it: captions and shapes as text with their words, images, shapes drawn as rectangles, ellipses and lines, video, narration, and the questions as question objects that grade the same way. A question with no slide equivalent (fill-in-the-blank with several blanks, for example) is kept as text on the slide and counted in the report as Questions kept as text on the slide. Closed captions on this route are kept as slide notes.

An all-new publish keeps its actions in assets/js/project.js as small scripts, which are read as data and never run. They come across as working triggers when two things are true: an action a learner sets off keeps state (a variable assigned, a condition tested, an object's state changed), and every slide is free-positioned — each object placed where you drew it, as on a PowerPoint deck imported into Captivate. Responsive slides (paragraph and image cards, tabs, flip cards, timelines, carousels, drag-and-drop widgets, question and results slides) are laid out by Captivate's player per screen size and rebuild well only as lesson blocks, so a publish with any of them reflows into lessons; its actions that keep state are then counted in the report under Buttons and click interactions, with the kinds listed.

On the slide canvas each object sits where Captivate's own player puts it (checked against that player rendering a real 13.2 publish), under the id Captivate gave it. What comes across as working triggers:

• Events: an object's click actions, including when this object is clicked, once (it gets a variable of its own, once_1 and on, that slide entry clears, as Captivate clears what was clicked); a slide's On Enter; hover.
• Jumps: next, previous, go to slide. Captivate's new player jumps where the jump is and runs the rest of the action after the next slide has entered; here the jump runs last. Where that order would show — the rest of the action writes a variable that a slide's On Enter reads, or reads one it writes — the whole action is left out and counted.
• Show and hide of objects on the same slide.
• Variables: your own, with their starting values (a Boolean comes across as a number, 0 or 1, as Captivate stores it, and a number starts where Captivate's player reads it: as a whole number); assigning a value; Adjust variable adding or subtracting a whole number; Toggle variable on a number or Boolean (it reads the variable once, as Captivate does, through a branch_ variable). Captivate's own variables (Quiz., Project., Date., LMS. and the rest) are left behind.
• Decisions: each one becomes a trigger per branch, several in order, each reading what the ones before it left, as Captivate does; AND is *all conditions*, OR is *any*, else the opposite. Comparisons are equal, not equal, greater and less, as the player reads them.
• Change state to one of your own states, with the state's words, picture, fill and text color. A state change set to reset on revisit puts the object back on every visit.

Left out and counted in the report, by reason: Execute JavaScript; animations; enable and disable; a delayed or repeated action; a while loop; slide exit actions; conditions on Captivate's own variables, comparing two variables, or about objects (visited, hidden, clicked, selected); assigning from another variable or an expression; multiplying or dividing a variable, or adding a fraction; toggling a text variable, or toggling on hover; a change to a random state or to Captivate's own hover, down, visited or selected looks; return to the last visited slide; "when objects are clicked" naming other objects; and anything reading a variable a text entry field or a left-out action writes. Text entry fields themselves, shapes Scenes cannot draw (arrows, stars, irregular outlines) and the variable shown in a text are counted too. Closed captions are kept as slide notes.

Every one of these is counted in the import report, by reason, never dropped silently:

• Execute JavaScript and Apply Effect actions, and widgets.
• Actions that depend on the timeline stopping: Continue, Pause, and an On Exit action on a slide that waits for a click. Slides on the canvas do not stop, so learners move on with Next.
• Return to the last visited slide, and an action that jumps more than once (only the last would happen in Captivate).
• Conditions on Captivate's own variables, comparing two variables, or mixing AND with OR; assigning one variable from another or from an expression; and any action reading a variable that something left out (JavaScript, a text entry box) writes.
• Showing or hiding an object on another slide, the click-outside (failure) and last-attempt actions of a click box, and Captivate's own rollover, down and visited looks.
• Enable and disable, go to the next or previous state, play or stop audio, send e-mail, exit, and player commands (mute, volume, playbar, table of contents); links to files rather than web addresses; a jump to a point partway into a slide; setting a variable the project does not declare.
• In an all-new Captivate (12/13) publish with responsive slides, actions are not converted: the course reflows into lessons (see the section above for free-positioned ones).
• In a reflowing course (one whose actions keep no state), button actions themselves: jumps are the lesson order, revealed text is ordinary content. Text that displayed a variable, such as the learner's name, has the variable removed.
• Text entry boxes outside questions, widgets, web objects and animations.
• Scored clicks on slide objects (Captivate's click-box scoring), Likert surveys (kept as text) and drag-and-drop driven by the author's own JavaScript.
• Pretest branching (the questions are imported as ordinary questions).
• Software simulations keep their screenshots, captions and the jumps their click boxes make; the scoring, the failure captions and the timing of the click-by-click simulation do not.

An imported course is editable content running in Scormbusters' player, not a copy of the Captivate player.

A .cptx is read directly from its binary object store, validated against real project files saved by Captivate 9, 2017 and 2019 — in each case against the HTML5 publish of the same project, so what this route reads was checked object by object against what Captivate itself publishes.

A .cptx always lands on the Scenes slide canvas. From a .cptx you get: the slides in order with their labels, every caption's text at its real position, images (including the raw-bitmap form Captivate stores for pasted or PSD-sourced pictures), slide narration audio, and the questions with their full definition — question text, options, the answer keys, points, and correct/incorrect feedback — for multiple choice, true/false, multiple answer, short answer, fill-in-the-blank (the list-of-answers style), matching, sequence and hotspot. Question pools come across drawing the same number of questions per attempt as Captivate did. Likert surveys are kept as text, as in the published route.

Actions come across from a .cptx too, read from the project's own action records and checked one by one against the publish of the same project: the success actions of buttons, click boxes and smart shapes used as buttons, slide On Enter and On Exit, advanced and shared actions (with their parameters), go to the next slide, jump to slide, show, hide, assign, open URL, and conditions comparing one variable with == or !=. Objects keep their names and start hidden when *Visible in output* was off. A decision with several conditions, Change state and the rarer actions are counted in the report instead — the publish carries those in a form that has been checked, so import it when they matter.

What the .cptx route does not read, each counted in the import report: video files stored inside the project, closed captions, the quiz pass mark, and the fill-in-the-blank style whose blank is a marked word in the sentence rather than a listed answer (the sentence itself still comes across). The published route reads closed captions and the pass mark, so if those matter, import the publish — or both, and compare.

Point releases of Captivate 2019 later than 11.0 (11.5, 11.8) write the same format family but no real project file from them has been through the validation corpus; the record layout is checked as it is read, so a file this route cannot read is refused with a clear message — it never imports junk. In that case publish to HTML5 and upload the output, which is validated through 11.8.3. Very old projects (the pre-.cptx .cp format from Captivate 4 and earlier) are not supported.

Adobe added a beta importer for Classic projects to Captivate 13.1, announced on 16 April 2026 (Adobe's announcement). If you want to keep authoring in Captivate, it is the natural thing to try first — it is part of the subscription you already pay for. The differences that decide between them:

• Status. Adobe's importer is labeled beta; Adobe says imported projects may need manual fixes.
• Input. Adobe's importer needs the .cptx. It cannot start from a published-only course. Scormbusters can.
• Versions. Adobe's release notes say projects from versions earlier than 11.8.3 are not officially supported. Scormbusters reads Classic publishes from Captivate 9 onward.
• Layout. Adobe's importer produces non-responsive projects. Scormbusters produces lessons that reflow.
• Where you end up. Adobe's importer leaves you in the all-new Captivate; Scormbusters leaves you in an editor with SCORM 1.2, SCORM 2004, cmi5 and xAPI export and a portable source file.

Captivate Classic has not reached end of support. Adobe lifted its earlier end date in March 2025 and says Classic will be supported until customers have transitioned (Adobe blog, 17 March 2025). Migrate when responsive output, accessibility or editing without a Captivate license matter to you, not because of a deadline.