How to Import a Quiz into Blackboard from a Video

The short version

You can build a Blackboard test from a video without typing a single question. Generate the questions from the recording with a tool that reads the spoken content, export a tab delimited .txt, and upload it through Blackboard's Upload Questions option. Blackboard turns each row into a real question with the correct answer already marked. The format choice matters more than people expect: Blackboard also has a QTI importer, but Anthology documents it for QTI 2.1 packages and for the Original Course View only, while the tab delimited upload works in Original and Ultra alike. The whole loop takes minutes instead of the afternoon it takes to type twenty items into the test canvas by hand.

Why the Blackboard test canvas is the slow part

Blackboard is very good at the things that happen after a test exists: deploying it to a content area, timing it, grading it, and pushing scores to the Grade Center. What Blackboard does not do is write the questions. You start with an empty pool, and filling it means reading back through your lecture, deciding what is testable, writing each stem, adding plausible options, marking the key, and often skipping the per question feedback because there is no time for it.

For one test across a couple of sections, that is most of an afternoon. Do it every week and the test quietly shrinks to five rushed questions, or gets dropped for a participation grade. The bottleneck is never deployment. It is authoring.

The workflow: video in, Blackboard test out

Here is the route that removes the typing. It works for a recorded lecture, a Blackboard Collaborate recording, a course module, or a recorded webinar, anything with spoken content.

1. Generate the questions from the video. Paste the recording link into VidQuiz, a Blackboard quiz generator that reads the spoken content and drafts multiple choice questions, marks the correct answer, and writes a one line explanation for each. Every question also carries a timestamp back to the moment in the video it tests.
2. Review and cut. Read the draft once. Reword any stem, drop a weak item, and confirm the answer keys. This is the step that keeps a generated test honest, and it is far faster than writing from a blank page.
3. Export the Blackboard file. Choose the Blackboard export. You get a tab delimited .txt: one question per row, a type code in the first column, and each option followed by the word correct or incorrect.
4. Upload it into a test. In the Ultra Course View, open the test, select the plus sign, choose Upload questions from file, browse to the .txt and submit. In the Original Course View, go to Tests, Surveys, and Pools, open a test or pool, and use Upload Questions. The items arrive as native Blackboard questions you can edit, reorder and point.

That is the entire loop. The part that used to cost an afternoon, producing the questions, is done before you ever open the test canvas.

Original vs Ultra: the one thing to know

Blackboard has two separate ways to take questions from outside, and they do not have the same reach. Getting this right saves a wasted afternoon:

• The tab delimited upload works in both course views. In Original it lives under Tests, Surveys, and Pools; in Ultra it is the plus sign inside a test, then Upload questions from file. Same file, both places.
• QTI import is Original Course View only, and it wants QTI 2.1. Anthology's documentation is specific about both points. A QTI 1.2 package, which is what most tools generate because it is what Canvas and Brightspace read, is the wrong file to hand Blackboard.

So if someone tells you to export QTI for Blackboard, check two things before you spend time on it: which course view your course runs in, and which QTI version your tool actually writes. The upload file sidesteps both questions, which is why it is the route worth learning.

What the upload file actually looks like

It is deliberately plain. Each line is one question, the fields are separated by tab characters, and the first field is a type code: MC for multiple choice, TF for true or false, ESS for essay, plus MA, FIB, MAT and NUM for the types a video quiz rarely needs. For a multiple choice question the pattern is the question text, then each option followed by the literal word correct or incorrect.

MC  What does the Nyquist rate describe?  Twice the
highest frequency  correct  The average frequency
incorrect  The clock speed  incorrect

Three rules break these files when people write them by hand. There must be no header row, no blank lines between questions, and the marker words have to be in English regardless of the course language. Anthology also recommends keeping a batch under 250 questions, which a generated quiz will not come close to. Exporting the file rather than typing it removes all four concerns, because tabs and line breaks inside a question stem get flattened before the row is written.

If your source material is not a video but a slide deck or a set of lecture notes, the same idea applies from a different starting point: you can turn a PDF or a slide deck into a quiz and export it the same way.

Which question types survive the import

The upload handles Multiple Choice, Multiple Answer, True or False, Fill in the Blank, Fill in Multiple Blanks, Matching, Numeric Response and Essay. A generated video quiz is mostly multiple choice with the occasional true or false, so those land as native Blackboard questions with the key already set.

One limitation is worth planning around, because no amount of tooling gets past it: the tab delimited format has no feedback column. The one line explanation written for each question cannot travel through the upload, and neither can the timestamp. Both stay visible in the generator, and a PDF export keeps the explanations if you want them as your own answer key. Everything else you set inside Blackboard after the upload, because it belongs to delivery rather than content: point values, availability, timers, attempts, and whether questions and answers shuffle.

The honest caveats

Two things are worth stating plainly. First, a generated test is a strong first draft written from your material, not a validated instrument. Its difficulty has not been calibrated and it can occasionally test a detail that did not matter. Read the set before it counts toward a grade and edit anything that misses. For a low stakes weekly check, the review takes a couple of minutes; for a midterm, take longer.

Second, the timestamps earn their keep at exactly the moment you would expect. When a student emails to dispute question 12, you open the source video at the chip on that question and see the 40 seconds it came from, rather than scrubbing through an hour of lecture to reconstruct your own reasoning. That traceability is hard to get any other way.

Putting it together

A Blackboard test has two halves: writing the questions and deploying them. Blackboard owns the second half and always will. The first half, the authoring that actually costs you time, is the part worth handing off. Generate the questions from the recording, review the draft, export the tab delimited file, and upload it into a test in whichever course view you run. You keep Blackboard as the system of record, your students take the test exactly where they always do, and you get your afternoon back. When you are ready, turn a lecture video into a Blackboard ready test and run the import once to see how short the loop really is.