Freeze Frame Duration Calculator
A freeze frame holds one image on screen while the video timeline continues, so inserting one changes the finished running time without changing the duration of the original moving footage.
Run — free
This calculator takes the original video duration, the timestamp where the hold begins, and the desired freeze length, all in seconds. It verifies that the freeze point belongs to the source timeline and returns the new total duration. Use it when planning an edit, checking an export specification, estimating a voice-over timeline, or generating reliable duration metadata before rendering.
Enter timeline values in seconds
Provide the complete duration of the unmodified video as original_duration, the source timestamp to hold as freeze_point, and the amount of added time as freeze_length. All three values use seconds and may include decimals, which makes the calculator suitable for subsecond editing decisions as well as long-form footage. For example, a value of 2.5 means two and a half seconds. The original duration must be greater than zero, while the freeze length may be zero when you want to validate a planned point without extending the result. The freeze point may be the opening timestamp, any timestamp inside the video, or the exact ending timestamp. It cannot be negative or later than the original ending time. Keep every value on the same time scale: if an editor displays minutes and seconds, convert that reading to total seconds before submitting it. This avoids treating 1:30 as a decimal number and accidentally entering 1.30 seconds instead of 90 seconds.
Understand what the calculation includes
The calculation adds the freeze length to the original duration. The freeze point determines whether the proposed insertion is valid, but it does not change the amount added: a four-second hold adds four seconds whether it begins near the opening, in the middle, or on the final frame. The returned new_total_duration is therefore the source duration plus the inserted hold. This model assumes a true insertion that pushes all later material forward. It does not describe replacing existing footage with a still image, because a replacement can keep the total running time unchanged. It also does not account for transitions, handles, speed ramps, duplicated frames used only to satisfy a frame rate, or extra audio padding unless their lengths are included separately in your editing plan. The response repeats the three accepted input values beside the result, making it easier to audit a calculation, retain it with edit notes, or compare a planned timeline against an exported asset.
Use the result in an editing workflow
Use the new duration as an early planning value before opening a render queue or updating delivery metadata. An editor can check whether a tutorial still fits a publishing limit after pausing on an interface detail. A producer can reserve enough narration or music bed for a held product shot. An automated pipeline can validate an edit decision list before handing work to a video renderer, rejecting a freeze point that refers to footage beyond the available source. Because the calculation is deterministic and uses no media upload, it is also useful when the actual video must remain in local storage: only numeric timing information is needed. For frame-accurate work, first convert the chosen frame position and hold-frame count to seconds using the project's exact frame rate, then submit those values. Be especially careful with fractional frame rates such as 29.97, where rounded display timestamps can differ slightly from exact timeline positions. This capability calculates duration rather than inspecting codecs, timecode tracks, variable-frame-rate behavior, or the rendered file itself.
What you can do with it
Plan a tutorial pause
Check the finished running time after holding an instructional frame long enough for viewers to read it.
Validate an edit decision
Reject a freeze instruction whose timestamp falls before the source starts or after the source ends.
Update delivery metadata
Calculate the planned total duration before a renderer or publishing workflow creates the final asset.
FAQ
What does the calculation cost?
It runs free in the browser on this page. API requests use the current $0.002 base price.
What units should I use?
Enter the original duration, freeze point, and freeze length in seconds. Decimal seconds are accepted.
Can the freeze point be at the exact end of the video?
Yes. The ending timestamp is within the original duration and represents holding the final frame.
Why does the freeze point not appear in the addition?
It validates where the insertion occurs. The inserted length is the same regardless of its valid position on the source timeline.
Does replacing footage with a still image increase duration?
Not necessarily. This calculator models an inserted hold that pushes later footage forward, not a replacement that occupies existing timeline time.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/video/freeze-frame-duration \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"original_duration":90,"freeze_point":32.5,"freeze_length":4.25}'const res = await fetch("https://api.kit.forhosting.com/video/freeze-frame-duration", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"original_duration": 90,
"freeze_point": 32.5,
"freeze_length": 4.25
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/video/freeze-frame-duration",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"original_duration": 90,
"freeze_point": 32.5,
"freeze_length": 4.25
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/video/freeze-frame-duration", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"original_duration":90,"freeze_point":32.5,"freeze_length":4.25}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"original_duration":90,"freeze_point":32.5,"freeze_length":4.25}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/video/freeze-frame-duration", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"original_duration": 90,
"freeze_point": 32.5,
"freeze_length": 4.25
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "video.freeze_frame_duration",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_mb | 500 |
max_minutes | 60 |
max_megapixels | 3.9 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |