How do I use AI to check a marketing video before publishing it?

What you will have at the end

A Python script, check_video.py, that gives Claude one still frame per shot and asks one thing: list every line of text you can see, copied exactly, misspellings included. Claude reads the image through the Claude API’s vision support (read 2026-11-04). The script then compares what Claude read with the on-screen text your video script asks for, using ordinary Python. It prints a verdict for each shot, writes check_video-results.csv, and saves every request and answer in check_video-answers.json, so anyone can re-run every check from that file with no key and no cost. A live run uses your own Anthropic API key and is billed to your account; our nine frame reads cost $0.0008.

The demo is an invented product video: Tallybright is not a real product, and its six shots are written in the script. The script draws the six demo frames itself, so there is no video file to download. A reader exports one still per shot from a real video, for example with ffmpeg; we did not run ffmpeg for this guide.

The key design choice is that Claude is never shown your script. If it were told the title should read “Cash forecast in minutes”, it could read the right words into a frame that has the wrong ones. It is asked only what the frame says, and the comparison is made afterwards by code.

This is the checking step before a marketing video goes out, nothing more. It does not make the video, and it judges only the text on the frames. It sends and publishes nothing. It is a standalone script we wrote for this guide. The In-House AI Marketing Engine’s solution page does not describe a video check; it lists social media and video as part five (solution page, read 2026-11-04).

Step 3. Compare what Claude read with the script

The check is ordinary Python. It makes five tests on each shot. answer: Claude’s answer must be JSON with a list of text lines; an answer that is cut off, empty or missing is reported, never skipped. frame: the frame the check is given must be the same file Claude read, by fingerprint. missing: every line of on-screen text the script asks for must be on the frame as a line of its own (or wrapped onto several), after whitespace is made plain and letter case is ignored. extra: every line Claude read must be a whole line of the script’s text for that shot (or text you allow on every frame, such as a logo), and each script line can be matched only once; a line the frame wraps onto several lines still counts as one. number: every number on the frame must be a number the script uses for that shot, in its on-screen text or its narration, or in text you allow on every frame. Each shot ends as PASSED or CAUGHT, and a caught shot goes to a person.

def compare(scene, read):
    """The three comparisons, against the script for this shot. Returns a list of flags."""
    wanted = [x for x in (scene.get("on_screen") or []) if isinstance(x, str) and x.strip()]
    allowed = [norm(x) for x in [*wanted, *ALLOWED_EXTRA] if norm(x)]
    read_norm = [norm(x) for x in read if norm(x)]
    unread = [norm(x) for x in wanted if norm(x)]       # script lines no read line has used up yet
    extra = []
    i = 0                    # each read line, or a run of them (a wrapped line), uses up one script line, once
    while i < len(read_norm):
        j = next((j for j in range(len(read_norm), i, -1) if " ".join(read_norm[i:j]) in allowed), None)
        if j is None:                                                     # check "extra"
            extra.append(f'extra: the frame shows "{read_norm[i]}", which the script does not ask for')
            i += 1
        else:
            line = " ".join(read_norm[i:j])
            allowed.remove(line)                                          # a script line before an allowed extra
            if line in unread:
                unread.remove(line)
            i = j
    flags = []
    for w in wanted:                       # check "missing": a script line no read line used up is not on the frame
        if norm(w) in unread:
            unread.remove(norm(w))
            near = difflib.get_close_matches(norm(w), read_norm, n=1, cutoff=0.5)
            flags.append(f'missing: the script says "{squash(w)}" but the frame does not show it'
                         + (f' (closest on the frame: "{near[0]}")' if near else ""))
    flags += extra
    script_numbers = numbers_of(" ".join([*wanted, *ALLOWED_EXTRA, str(scene.get("narration") or "")]))
    for n in sorted(numbers_of(" ".join(read)) - script_numbers):         # check "number"
        flags.append(f"number: the frame shows {n}, which is not a number in the script for this shot")
    return flags

def check(items):
    """One result per shot. Each item: {"scene", "frame", "rec"}. Checks: answer (parses), frame (the file
    Claude read), missing, extra, number. Said where each is made; the planted faults say which trips which."""
    results = []
    for n, it in enumerate(items, 1):
        scene, frame, rec = it["scene"], it["frame"], it["rec"]
        wanted = scene.get("on_screen")
        res = {"n": n, "id": str(scene.get("id")), "script": [str(x) for x in wanted] if isinstance(wanted, list) else [],
               "read": [], "problem": "", "flags": [], "outcome": "", "sha": frame["sha"], "label": it.get("label", "")}
        if frame["problem"]:
            res["problem"] = frame["problem"]
        elif not isinstance(wanted, list) or not any(isinstance(x, str) and x.strip() for x in wanted):
            res["problem"] = "the script lists no on-screen text for this shot: nothing to compare"
        elif rec is None:
            res["problem"] = "no saved answer for this frame"
        elif rec.get("frame_sha256") != frame["sha"]:
            res["problem"] = "the frame is not the file Claude read (its fingerprint changed)"      # check "frame"
        else:
            lines, problem = parse(rec.get("raw_answer"))                                           # check "answer"
            if problem:
                res["problem"] = problem + (f" ({rec['error']})" if rec.get("error") else "")
            else:
                res["read"] = lines
                res["flags"] = compare(scene, lines)
        res["outcome"] = "caught" if res["problem"] or res["flags"] else "passed"
        res["action"] = ("approve this shot" if res["outcome"] == "passed"
                         else "a person looks at this frame and decides: fix the video or the script")
        results.append(res)
    return results

A misspelled title trips two tests at once, because the right line is missing and the wrong one is extra. The script names the closest line Claude read, so the person sees the difference without opening the video.

Run 2: plant six faults and see whether the check notices

python3 check_video.py --replay check_video-answers.json --plant-error. Six shots each get one fault. The script stops with an error if a fault cannot be planted, or if a planted frame’s drawn text would pass the check. The first three faults are real frames that Claude read in run 1’s session, so Claude really did read the misspelling. The other three damage the saved answers or the frame handed to the check. If Claude’s reading of a planted frame passes the check anyway, for example because it quietly corrected the misspelling, run 2 prints “A PLANTED FAULT WAS NOT CAUGHT” and exits with code 2.

model claude-haiku-5-5, run date 2026-11-04, temperature not set (the model refuses it), 9 frames read, 6 checked below
tokens in 6039, tokens out 355, cost $0.0008

S1  Planted fault: misspelled title, on shot 1  (frame fingerprint 61e459307739)
    script: TALLYBRIGHT / Cash forecast in minutes
    read:   TALLYBRIGHT / CASH FORCAST IN MINUTES
    CAUGHT: missing: the script says "Cash forecast in minutes" but the frame does not show it (closest on the frame: "CASH FORCAST IN MINUTES")
    CAUGHT: extra: the frame shows "CASH FORCAST IN MINUTES", which the script does not ask for
    -> CAUGHT: a person looks at this frame and decides: fix the video or the script
S2  Planted fault: leftover text, on shot 2  (frame fingerprint 1c07abeb6907)
    script: Connect your bank / Read-only access
    read:   CONNECT YOUR BANK / READ-ONLY ACCESS / DRAFT NOT FINAL
    CAUGHT: extra: the frame shows "DRAFT NOT FINAL", which the script does not ask for
    -> CAUGHT: a person looks at this frame and decides: fix the video or the script
S3  Planted fault: wrong number, on shot 3  (frame fingerprint cd44daf872d9)
    script: Invoices by due date / Overdue: 3
    read:   INVOICES BY DUE DATE / OVERDUE: 8
    CAUGHT: missing: the script says "Overdue: 3" but the frame does not show it (closest on the frame: "OVERDUE: 8")
    CAUGHT: extra: the frame shows "OVERDUE: 8", which the script does not ask for
    CAUGHT: number: the frame shows 8, which is not a number in the script for this shot
    -> CAUGHT: a person looks at this frame and decides: fix the video or the script
S4  Planted fault: answer cut off, on shot 4  (frame fingerprint 096c9c182fbb)
    script: Forecast: next 13 weeks
    PROBLEM: answer is not the expected JSON (JSONDecodeError)
    -> CAUGHT: a person looks at this frame and decides: fix the video or the script
S5  Planted fault: no answer, on shot 5  (frame fingerprint aeb498e8d3f9)
    script: Plans from $39 a month / Free for 14 days
    PROBLEM: no answer text
    -> CAUGHT: a person looks at this frame and decides: fix the video or the script
S6  Planted fault: wrong frame, on shot 6  (frame fingerprint 42d398b26982)
    script: Try it free / tallybright.example.com
    PROBLEM: the frame is not the file Claude read (its fingerprint changed)
    -> CAUGHT: a person looks at this frame and decides: fix the video or the script

passed: 0, caught for a person to look at: 6
RESULT: CHECK FAILED, a person looks at the caught shots before the video goes out

All six were caught, and a person would look at each one. A planted results file and a planted run view are written under their own names, so this run never overwrites the clean run’s files. That is six faults the check was built for, caught. It says nothing about how often a real model misreads other kinds of frame.

Method

• Input: an invented six-shot video for an invented product, written in the script. The six frames are drawn by the script, in capitals, with a built-in dot font and no image library. No real person, company, video or message is used.
• Model: claude-haiku-5-5 through the Claude API, one request per frame, no web search, temperature not set (the model refused 0), at most 40 shots a run.
• What Claude is asked: only to list the lines of text it sees. It is never shown the script, the expected words or the other frames.
• What counts as a match: a line of script text is on the frame when one line Claude read is that line, or several read lines join to make it, after whitespace and curly quotes are made plain and letter case is ignored; a word inside a longer line, such as a logo’s web address, does not count. A line Claude read is allowed when it is a whole line of the script’s text for that shot or of ALLOWED_EXTRA, or several read lines join to make one such line. Each script line can be matched only once, so a fragment or a repeated line is caught. Set CASE_SENSITIVE to True to compare capitals too.
• Checks on the answers, each with the planted fault that trips it: see the table in run 2.
• Safeguards no run trips: the script stops before it asks if two shots share an id, if there are more than 40 shots, or if its worst-case cost estimate passes $2.00.
• Cost: tokens are read from the API response and priced at Anthropic’s price list (read 2026-11-04), at the rate for prompts up to 100,000 tokens.

Limits

• This is not a client result. The video is invented, and nothing here describes any real video, campaign or result. We make no claim about how often Claude reads real frames correctly.
• The frames are easy. They are large, high-contrast capitals on white. Real video has small type, gradients, motion blur, captions over footage and logos, and Claude has read only these frames. The vision page itself warns about low-quality, rotated or very small images.
• It reads text, not meaning. The check does not judge whether the picture, the colors, the logo, the claim or the price is right, whether the words are legal to say, or whether the audio matches. A wrong claim spelled correctly passes.
• One still is not the whole shot. Text that appears and disappears between stills is not read. Export more than one still for a long shot.
• Case is not compared by default. The demo frames are drawn in capitals, so a wrong capital would pass until you set CASE_SENSITIVE.
• A model can correct a typo when reading it. The prompt forbids it, and in our run it did not. A model that did would let a typo pass, which is why run 2 reads real misspelled frames.
• Answers vary. A live run on the same frames can word things differently.
• The six planted faults are the faults the check was built for. It does not publish, change or approve anything.