Shortest and longest values Sume accepts for a Short: one table

Why a limits table

When you build Shorts in a loop, the refusal you hit is almost always a limit you did not have in front of you. A 0.1-second slot, a 1.5-second fade, a 12-second soundtrack fade: each is a documented refusal, and each costs a round trip. This page puts the numbers from the Timeline 1.0 and video trim docs in one place, and ends with an offline checker that applies the slot rules.

The reason to care this week is volume. The October platform roundup describes YouTube Shorts series, with seasons and episodes, rolling out from 23 September. A season is dozens of bodies, and a table beats rereading two docs pages every time.

The numbers

Every row is a limit printed on the Sume page named in the first column. Where a limit has an error code, the code is shown.

A slot checker

The function checks a slot's duration and its transition against the rules above and prints the problems. It uses no network. The three sample calls print one problem for a 0.15-second slot, one problem for a 1.2-second slot with an 0.8-second transition next to a 1.0-second neighbor, since 0.8 is over half of 1.0, and an empty list for a slot that is fine.

LIMITS = {                                  # Timeline 1.0 + trim, from the Sume docs
    "trim_duration_s": (0.2, 900),
    "slot_duration_min_s": 0.2,
    "transition_max_s": 1.0,
    "output_fade_max_s": 5.0,
    "soundtrack_fade_out_max_s": 10.0,
    "spine_s": (1, 1800),
}

def check_slot(duration, transition=0.0, neighbor=None):
    problems = []
    if duration < LIMITS["slot_duration_min_s"]:
        problems.append(f"slot {duration}s is under {LIMITS['slot_duration_min_s']}s")
    if transition > LIMITS["transition_max_s"]:
        problems.append("transition over 1 s")
    if neighbor is not None and transition > 0.5 * min(duration, neighbor):
        problems.append("transition over 50% of the shorter neighbor")
    return problems

print(check_slot(0.15))
print(check_slot(1.2, transition=0.8, neighbor=1.0))
print(check_slot(2.0, transition=0.5, neighbor=3.0))

How the limits interact

A fast hook is where limits collide. A 0.2-second slot is legal, but a transition into it is limited to half the shorter neighbor, so a 0.2-second slot allows at most a 0.1-second transition. Stack eight chained transitions and the ninth is refused. If you are cutting a three-second hook with six slots, use plain cuts, and keep a transition for the cut after the hook, where the slot is long enough to carry it.

The spine sets the ceiling for everything else. A render reserves $0.10 per whole output minute (the docs reserve ceil of the spine length over 60), so a 61-second episode reserves two minutes and a 59-second episode reserves one. YouTube's help page says a Short can be three minutes, and the spine limit of 1800 seconds is not the constraint there. The 200-slot cap is, and it works out to about one cut every 0.9 seconds over three minutes.

Where the limit is not printed

Some limits you will want are not in the docs: a maximum file size, a maximum bitrate and the exact encoding. We do not state them. If your platform imposes one, read the finished file's properties yourself before you upload, and treat the first render of a new format as a test.

A worked case: you want an eight-second hook with four slots of two seconds each, a fade-in of 0.5 seconds and a closing fade-out of 1 second. Every slot is above 0.2 seconds, the fades are far under the 5-second cap, and no transition is needed. Now add a 1-second dissolve between slots two and three: the cap is 1 second and 50 percent of a 2-second neighbor is also 1 second, so it is allowed. Shorten the neighbor to 1.5 seconds and the same dissolve is over half of it, so it is refused with transition_too_long.

Run the plan call after the offline check. The plan is unbilled, needs no Idempotency-Key and returns the duration, the segment count and the billable minutes, so it is the right place to see a limit you did not model. The offline checker only knows the rules in the table.

Keep the table next to your code as data. The LIMITS dictionary above is the same table in a form a script can read, so a change in the docs becomes a one-line diff. Add a comment with the date you last read each page, and re-read the pages before a long batch.