Time-lapse calculator
An eight-hour sunset captured every 5 seconds gives 5760 frames and a 192-second clip at 30 frames per second, 150 times faster than real life. Know the runtime before you set the intervalometer. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Duration
- 28,800
- Interval
- 5
- Fps
- 30
- Frames
- 5,760
- Playback seconds
- 192
- Speedup
- 150
Time-lapse photography compresses hours of real-world motion into a short clip by capturing still frames at a fixed interval and playing them back at a cinematic frame rate. Planning that shoot means answering one number before you set the intervalometer: how long will the finished video last. This time-lapse calculator takes the total recording duration in seconds, the capture interval in seconds, and an optional playback frame rate, then returns the clip length in seconds together with the frame count and the speed-up factor. A non-positive interval is rejected as invalid input, because division by a zero or negative gap does not define a capture schedule.
What a time-lapse clip duration actually is
When a camera fires one still every I seconds for a total recording window of T seconds, the capture produces T divided by I frames, using exact division so planners can see a fractional frame when the window is not an integer multiple of the interval. Those frames are assembled into a video that plays at F frames per second, so the finished clip lasts T divided by the product of I and F seconds.
The speed-up factor is the inverse, interval times fps, which tells you how many times faster the sky, the crowd, or the construction site will appear to move. Typical field values are a sunset of eight hours, which is twenty-eight thousand eight hundred seconds, captured every five seconds and played at thirty frames per second. That schedule yields five thousand seven hundred sixty frames and a three-minute-twelve-second clip of one hundred ninety-two seconds, with a one-hundred-fifty-times speed-up.
Construction-site and plant-growth shoots often run for days with intervals of thirty to three hundred seconds; night-sky and traffic shoots may drop to one or two seconds. The calculator does not resample, interpolate, or encode video. It only answers the planning question so you can set the intervalometer, estimate card space from the frame count, and promise a runtime on a shot list before anyone presses record.
What to enter, what you get and what fails
A zero or negative interval is the documented hard error: there is no well-defined capture schedule when the camera would have to fire infinitely often or backwards in time, so the task is rejected rather than returning Infinity. A zero or negative fps is likewise rejected. A negative recording duration is rejected; a duration of zero is allowed and yields zero frames and zero playback seconds, which is the empty-clip edge case.
Numbers are rounded to twelve decimal places so goldens compare byte-for-byte across runtimes. Failed validation is not billed.
Where a time-lapse duration calculator earns its keep
Cinematographers and YouTube creators use a time-lapse calculator to lock clip length before they leave for a location: a two-minute music bed needs a known frame count, which back-solves the interval once duration and fps are fixed. Camera firmware, intervalometer apps, and drone planners can call the same contract instead of embedding a one-line formula that later disagrees with the spreadsheet a producer keeps.
Pair it with timecode tools when you need hour-minute-second-frame labels, with video metadata readers when you already have a file, and with this planner when the shoot has not happened yet. Keep requests small, pin the rounded seconds in tests, and you get a reproducible clip length for shot lists, LMS plugins, and edge workers without standing up a media pipeline of your own.
What you can do with it
Sunset and sky time-lapses
Convert an eight-hour recording window and a five-second capture gap into a 192-second clip at 30 fps before you lock the intervalometer on location.
Construction and growth recaps
Turn multi-day site or plant recordings into a known playback length so editorial slots and storage estimates are honest before the first still is taken.
FAQ
How is time-lapse playback duration calculated?
Send duration (recording window in seconds) and interval (seconds between stills). Optional fps defaults to 30.
What frame rate does the time-lapse calculator assume?
Playback fps defaults to 30 when omitted, the common web and television rate for assembled time-lapse. Pass fps (or framerate) explicitly for 24 fps film, 25 fps PAL, or 60 fps.
Can recording duration be zero?
Yes. A duration of zero with a positive interval yields zero frames and zero playback seconds (an empty clip).
How long is a time-lapse of an eight-hour sunset shot every 5 seconds?
The 28800 seconds of recording produce 5760 frames. Played at 30 frames per second they last 192 seconds, three minutes and twelve seconds, and the scene moves 150 times faster than in reality.
What capture interval should I use?
It depends on how fast the subject changes. Construction sites and growing plants are often shot over days with gaps of thirty to three hundred seconds, while night skies and traffic may need one or two seconds.
Related tools
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/time-lapse \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"duration":28800,"interval":5}'const res = await fetch("https://api.kit.forhosting.com/video/time-lapse", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"duration": 28800,
"interval": 5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/video/time-lapse",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"duration": 28800,
"interval": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/video/time-lapse", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"duration":28800,"interval":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"duration":28800,"interval":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/video/time-lapse", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"duration": 28800,
"interval": 5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "video.time_lapse",
"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. |
Technical notes
The same pure arithmetic runs free in your browser and at $0.002 per successful API call, so storyboards, camera apps, and production spreadsheets never disagree on clip length.
What a time-lapse clip duration actually is
That identity is the entire engine: playback_seconds equals duration divided by interval times fps.
Input contract, response shape, and error behaviour
POST a JSON body with duration, the total recording window in seconds as a non-negative finite number, with aliases recording_duration, recording, shoot_duration, and total, and interval, the capture gap in seconds, which must be a strictly positive finite number, with aliases capture_interval, frame_interval, and interval_seconds. Optional fps is the playback frame rate; it defaults to thirty, the common web and television rate for time-lapse assembly, and must be positive when supplied, with aliases framerate, frame_rate, and playback_fps. Each field accepts a JSON number or a decimal numeric string. Missing keys, empty strings, NaN, Infinity, and non-numeric tokens fail with invalid_input naming the field. On success the body echoes the cleaned duration, interval, and fps, returns frames as duration divided by interval, returns playback_seconds as the primary result, returns speedup as interval times fps, and attaches a formula string restating playback_seconds equals duration divided by interval times fps.
Where a time-lapse duration calculator earns its keep
Construction, agriculture, and scientific observation programmes publish multi-day recordings as short recap videos; knowing playback_seconds up front is how those programmes size storage and editorial slots.
Integration use cases
Shot lists and music beds
Match a planned time-lapse to a two-minute score by computing frames and playback_seconds from duration, interval, and fps in one call.
Technical questions
What happens if the capture interval is zero or negative?
The task fails with invalid_input. A non-positive interval does not define a capture schedule, so the calculator refuses to return Infinity or a negative clip and the call is not billed.
What does the time-lapse calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.