A 7:30 Timeline render bills 8 minutes: cut 30 s to save $0.10

A 7-minute 30-second Timeline render bills 8 minutes, which is $0.80 at the public rate of $0.10 per ceil(output minute). Cutting 30 seconds so that the output is exactly 420 seconds bills 7 minutes, which is $0.70. The docs state that the reserve is ceil(audio.duration_seconds / 60) minutes, so the billed length follows the declared audio length, not the footage you imported.

Why the declared length matters

The reserve is taken from audio.duration_seconds when the job starts, so a spine declared at 450 seconds reserves 8 minutes even if the finished picture is shorter. If you want the lower bill, change the declared length, not only the footage. Run the unbilled plan first, then the render, and compare billable_minutes in both. They should match; if they do not, your request changed between the two calls.

The billing rule

Timeline 1.0 takes one audio spine and ordered video[] slots and returns one MP4. The job uses no provider inference, only worker ffmpeg, and the docs give the rate as $0.10 per ceil(output minute). The result reports billable_minutes, so you can compare it with your own arithmetic. The limit for audio.duration_seconds is 1 to 1800 seconds, which is 30 minutes and a maximum charge of $3.00 for one render.

Where the saving comes from

The step is a whole minute, so the saving appears only when you cross a minute line. From 450 seconds, the nearest line below is 420 seconds. That is a cut of 30 seconds and a saving of $0.10. A cut from 450 to 430 seconds saves nothing, because 430 seconds is still 8 minutes. The reverse also holds: 480 seconds costs the same as 450 seconds, so you can add 30 seconds of content at no extra charge.

Ten cents is small for one render. It matters for a batch. At 100 renders of 450 seconds, the bill is $80.00. At 100 renders of 420 seconds, it is $70.00. The difference is $10.00.

Check it for free first

POST /v1/timeline-1.0/plan is unbilled. It validates the schema and the Sume-host URLs, runs the pure compiler, and returns duration_seconds, segment_count, billable_minutes and estimated_cost_usd_micros. It creates no job, reserves no credits and downloads no media. The docs warn that a plan cannot predict short-source pad or loop warnings.

A small function gives the same number from your own declared length, so you can price a list of renders before you build any request:

import math

PRICE_PER_MINUTE = 0.10

def timeline_cost(seconds: int) -> float:
    if not 1 <= seconds <= 1800:
        raise ValueError("audio.duration_seconds must be 1 to 1800")
    return math.ceil(seconds / 60) * PRICE_PER_MINUTE

for s in (419, 420, 421, 450, 480, 481):
    print(s, round(timeline_cost(s), 2))

What not to cut

Do not trim the audio to hit a minute line if the cut loses content. The rule helps when you have slack: a long outro, a repeated bumper, or a pause. Also remember the other limit. video[0].start must be 0, and coverage can stop at most 0.5 seconds before the end of the spine, so shortening audio.duration_seconds means shortening the last slot too.