Time-lapse Shooting Duration Calculator
This time-lapse shooting duration calculator tells you how long the camera must keep capturing frames to complete a sequence.
Run — free
Enter the total frame count and the interval in seconds, and it returns the elapsed shooting time in seconds, minutes, hours, and a readable day-hour-minute format. The calculation treats the first frame as occurring immediately, so the duration runs from the first capture to the last rather than adding an unnecessary interval after the final frame.
Plan the capture window before setting up
A time-lapse can compress hours of real activity into seconds of finished video, but the camera still has to remain in place for the entire source event. This calculator turns two intervalometer settings—frame count and interval—into the required shooting duration. Use the result to decide when to begin, whether a battery will last, how long a location must remain accessible, and whether the planned sequence fits daylight or weather conditions. The interval is measured from the start of one capture to the start of the next. For example, 600 frames at a five-second interval span 599 intervals, not 600, because the first frame is captured at the beginning of the session. The final frame arrives 2,995 seconds later. That distinction is small in a short test but becomes important with long intervals or multi-day projects. The output includes exact seconds as well as minutes, hours, and a readable duration, giving you both machine-friendly values and a practical schedule for field planning.
Understand the frame-count formula
The calculation uses shooting duration = (frame count − 1) × interval. Frames mark points in time, while intervals are the gaps between those points. Two frames contain one gap; ten frames contain nine gaps; a single frame contains no gap and therefore has a shooting duration of zero. This convention describes elapsed time from the first shutter activation to the start of the last shutter activation. It does not add the exposure time of the last frame, camera write time, intervalometer startup delays, or a safety margin. Most intervalometers define an interval as the time between the starts of consecutive exposures, so the exposure must normally be shorter than the selected interval. If your controller instead waits for an exposure to finish and then starts its delay, its effective start-to-start interval may include both values. Check the controller manual and enter that effective interval here. Decimal intervals are accepted for high-frequency sequences, and the calculator keeps stable precision without relying on clocks, time zones, or the current date.
Turn the result into a reliable field schedule
Treat the calculated duration as the mathematical minimum for collecting the requested frames, then add preparation and operating margin outside the calculation. Arrive early enough to frame, focus, level, test exposure, disable unwanted automation, and confirm that the intervalometer is actually triggering. For a sunset sequence, work backward from the desired final-frame time using the reported shooting duration, then add setup time. For construction, plants, clouds, or other long-running subjects, compare the duration with battery capacity, memory-card space, permitted access hours, and likely interruptions. The calculator deliberately does not guess those constraints because camera files, power systems, and shooting conditions vary widely. It also does not calculate finished-video length; that requires a playback frame rate and is a separate question from capture duration. If a shot cannot tolerate a missed endpoint, schedule a few extra frames or begin earlier. The API version costs $0.002 per request and returns structured values that can feed a shot planner, production worksheet, monitoring dashboard, or automated intervalometer setup workflow.
What you can do with it
Schedule a sunrise or sunset sequence
Work backward from the desired final frame to determine when continuous shooting must begin.
Estimate power and access needs
Compare the required capture window with battery endurance, site opening hours, and supervision time.
Build a production shot plan
Insert exact capture durations into call sheets, automation scripts, or repeatable camera setups.
FAQ
Why does the formula use one fewer interval than frames?
The first frame is captured at time zero. Only the gaps between frames contribute elapsed time, so N frames contain N minus one intervals.
Does the duration include the final exposure time?
No. It measures from the start of the first exposure to the start of the last. Add the last exposure time if you need the moment when all capture activity finishes.
Can I use a fractional interval?
Yes. Enter the interval in seconds as a number down to 0.001 seconds, provided your camera and controller support that timing.
Does this calculate the finished video length?
No. Finished length depends on playback frame rate. This calculator answers how long the camera must shoot to gather the specified frames.
What does the API calculation cost?
Each API request costs $0.002. The same deterministic calculation can run free in your browser.
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/hobby/photo-timelapse-shoot-duration \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"frame_count":600,"interval_seconds":5}'const res = await fetch("https://api.kit.forhosting.com/hobby/photo-timelapse-shoot-duration", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"frame_count": 600,
"interval_seconds": 5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/photo-timelapse-shoot-duration",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"frame_count": 600,
"interval_seconds": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/photo-timelapse-shoot-duration", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"frame_count":600,"interval_seconds":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"frame_count":600,"interval_seconds":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/photo-timelapse-shoot-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
{
"frame_count": 600,
"interval_seconds": 5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.photo_timelapse_shoot_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.
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. |