Make a three-minute YouTube Short with a Format and check duration_ms

To make a three-minute YouTube Short, produce a vertical or square video of 180 seconds or less and confirm that on the file before you upload. YouTube's help page says videos uploaded on or after October 15, 2024 with a square or vertical aspect ratio up to three minutes long are categorized as Shorts (read 2026-10-09). A Sume Format run reports duration_ms, width and height for each file it produces, so you can test that rule in code.

What counts as a Short

Two facts from the YouTube page matter here. The length limit is three minutes, and the shape must be square or vertical. A 16:9 file of 90 seconds is not covered by that sentence, even though it is short. The page also lists upload dates by channel type, so check the section for your channel type before you rely on the three-minute limit.

• Length: up to three minutes (180,000 ms).
• Shape: square or vertical, so height >= width.
• Upload date: on or after October 15, 2024 for standard channels (read 2026-10-09).

Test the receipt, not the plan

A Format run is one agent turn, and the agent decides the final cut. A request for a "two-minute" video can come back at a different length, so do not trust the instruction as the proof. The receipt's artifacts[] entry holds the measured duration_ms. Compare it to 180000.

If the run hands back several files, such as a main cut and a teaser, test each video entry. If you bound an output_schema with primary_output_key, the primary_output_url points at the one you asked for, and you can match it to its artifact by url.

A check you can run

This reads a finished run and flags files that are over the limit. It needs SUME_API_KEY with formats:read. Square or vertical shape is printed so you can see it in the same line.

import json, os, urllib.request

def short_ok(run_id, limit_ms=180000):
    req = urllib.request.Request(
        "https://api.sume.com/v1/format-runs/" + run_id + "/result",
        headers={"Authorization": "Bearer " + os.environ["SUME_API_KEY"]},
    )
    with urllib.request.urlopen(req) as r:
        run = json.load(r)["data"]
    for a in run["artifacts"]:
        if a["type"] == "video":
            ok = a["duration_ms"] is not None and a["duration_ms"] <= limit_ms
            print(a["url"], a["width"], a["height"], a["duration_ms"], "ok" if ok else "TOO LONG")

If the cut is too long

Do not edit the old run. Start a new one with previous_run_id set to the finished run and an instruction such as "Trim to under 170 seconds and keep the opening." A continuation is a new run with its own receipt, its own spend cap and its own webhook, so you pay for the new turn, and the receipt shows its usage separately. Bind the same output_schema again, because it is not inherited.

Limits of this check

This check covers length and shape only. The YouTube help page also covers eligibility, monetization and copyright. For example, the page's rules for Shorts that carry music or someone else's footage are separate from the length rule, so a file that passes duration_ms can still be restricted. We did not verify those rules against Sume output, and you should read the YouTube page for your channel type before relying on a result.

A second practical point: the instruction is not a measurement. If you write "under three minutes" in instruction, the agent aims at it but nothing in the API enforces it, so the receipt check is the control. Put the check in your pipeline between the webhook and the upload step, and fail the job when it reports TOO LONG.