Keep Requested, Measured, and Billable Video Duration Separate

A Seedance brief asks for ten seconds. A local media inspection reports a duration slightly above ten seconds. A cost worksheet still contains the original request value. Which number should replace the others?

Usually none of them should be overwritten. Requested duration expresses intent; measured duration describes an observed media artifact; billable duration or usage follows the provider's charging contract. Treating them as one field destroys useful evidence.

Store values with their basis

A local record might contain requested_seconds, measured_stream_seconds, and billable_quantity, with the last field left unknown until supported by settlement evidence. These are application fields, not a Seedance response schema.

The measurement should also identify the artifact and the method. A container duration, a selected video stream duration, and a calculation from an assumed constant frame rate are different bases. Record which one was used instead of describing all three as “the duration.”

For an actual local file, ffprobe can expose selected stream and container fields in machine-readable output. For example:

ffprobe -v error -select_streams v:0 -show_entries stream=duration,duration_ts,time_base,avg_frame_rate:format=duration -of json clip.mp4

That command is an inspection example, not an observed result from a generated Seedance clip. Fields can be absent or unavailable; a parser should preserve that condition. Selecting v:0 also does not establish that the chosen stream is the intended deliverable in every file.

Use exact arithmetic for a stated timing assumption

Consider a synthetic constant-frame-rate example with 240 frames. At exactly 24 frames per second, its frame-count duration is ten seconds. At 24000/1001 frames per second, the same count gives 10.01 seconds.

Python's Fraction documentation describes rational arithmetic. It lets this example preserve the supplied ratios instead of rounding the rate to a short decimal first:

from fractions import Fraction

def cfr_duration(frame_count, fps):
    if type(frame_count) is not int or frame_count < 0:
        raise ValueError("frame count must be a nonnegative integer")
    if not isinstance(fps, Fraction) or fps <= 0:
        raise ValueError("fps must be a positive Fraction")
    return Fraction(frame_count, 1) / fps

requested = Fraction(10, 1)
exact_24 = cfr_duration(240, Fraction(24, 1))
fractional_rate = cfr_duration(240, Fraction(24000, 1001))
assert exact_24 == requested
assert fractional_rate == Fraction(1001, 100)
assert fractional_rate - requested == Fraction(1, 100)

The helper explicitly assumes a constant frame rate and a known frame count. It does not derive frame count from avg_frame_rate, inspect a media file, or validate timestamps. Variable-frame-rate material requires a measurement method that actually accounts for its timing information.

Review a difference without inventing its cause

A difference between request and measurement may justify inspecting the output, the timing basis, or an edit. It does not by itself establish that a provider overcharged, rounded duration, ignored the prompt, or generated extra billable work.

Define any delivery tolerance separately. For a particular editing workflow, a team might choose a tolerance based on frame boundaries and the receiving timeline. That is a local acceptance policy; it is not a universal tolerance or a provider guarantee. Preserve the original values even when the file passes the policy.

The billing record needs its own unit. If a service charges video tokens, multiplying a measured duration by a guessed per-second rate is not a settlement check. If it charges seconds, minimums and rounding still need evidence. Neither the sample function nor ffprobe can determine those rules.

The practical result is a record that can explain a timing discrepancy without rewriting the brief or fabricating a charge. The Python example and invalid-input fixtures were exercised locally. No video was generated or measured for this article.

AI disclosure: An autonomous AI assistant drafted and checked this article for the TokenPeak account. All frame counts and rates are illustrative; no paid model request was made.