Estimate video render time from duration and encoder speed
Estimate how long a video encode should take before you commit a workstation, render node, or delivery window.
Run — free
Enter the program duration, output width and height, video frame rate, and the encoder throughput you have measured at that resolution. The calculator converts duration into a frame count, divides those frames by the encoder speed, and returns a readable render time alongside the exact estimate. It also shows the real-time factor so you can quickly see whether the encoder is expected to finish faster or slower than playback.
Start with measurements that describe the same job
A useful render estimate depends on consistent inputs. Duration should describe the complete timeline that will be encoded, including titles, credits, or padding that remains in the export. Frame rate must be the actual output rate rather than a rounded label copied from a project name; for example, 29.97 and 30 frames per second produce slightly different frame totals over a long program. Width and height record the target output resolution. They do not directly change the arithmetic because encoder throughput is already expressed as frames processed per second, but they make the estimate auditable: a throughput result measured for one resolution should not be reused blindly for a substantially larger frame. Measure encoder speed with the same codec, preset, bit depth, filters, hardware, and resolution whenever practical. If you only have an early benchmark, use a conservative throughput figure rather than the best momentary reading. The result is an operational estimate, not a guarantee, because real encoders can slow down on complex scenes, thermal limits, or competing workloads.
Understand the calculation and the real-time factor
The calculator first multiplies duration in seconds by the output frame rate to obtain the number of frames in the job. It then divides that frame count by the measured encoder throughput in frames per second. A two-minute, 30 fps program contains 3,600 frames; an encoder sustaining 60 fps needs about one minute to process it. The reported real-time factor is encoder throughput divided by program frame rate. A value above one means the encode is faster than playback, a value of one means approximately real time, and a value below one means the encode is slower than playback. Resolution is included in the output so benchmark records remain tied to their intended raster size. Fractional frame totals can occur when decimal duration is combined with fractional frame rate. The tool preserves that mathematical estimate rather than silently changing the supplied duration. Displayed render time is rounded to the nearest millisecond, while numeric fields use stable decimal rounding for predictable API and browser results.
Plan a schedule with realistic safety margin
Treat the result as the active encoding time under the conditions represented by your speed measurement. A full delivery schedule may also need time for source transfer, cache preparation, audio analysis, multipass setup, file muxing, checksum generation, upload, and quality control. Those stages are not represented by an encoder speed measured in frames per second, so add them separately. For a batch, calculate representative jobs at the slowest expected throughput, then include a margin based on past variance. If a system reports unstable performance, a lower percentile throughput is more useful for deadlines than an average boosted by easy scenes. Recalculate when you change resolution, codec, preset, denoising, scaling, color conversion, or hardware acceleration, because each can materially change throughput. The estimate costs $0.002 per API request, while the tier-A browser path can run the same deterministic calculation locally. No media is uploaded: the calculation uses only the numeric properties you enter, and it does not inspect or encode a video file.
What you can do with it
Set an export deadline
Convert a known timeline length and a workstation benchmark into an expected encoding window before promising delivery.
Compare encoder presets
Enter benchmark throughput from different presets at the same resolution to compare their likely completion times.
Size a render batch
Estimate each job with a conservative measured speed, then combine the results with transfer and review overhead.
FAQ
Why does the calculator need frame rate as well as duration?
Encoder speed is measured in frames per second, so duration must be converted into a frame count using the video's output frame rate before render time can be calculated.
Does resolution directly change the formula?
No. Resolution affects the benchmark speed you should enter. The formula assumes the encoder speed was measured for the stated width, height, codec, and settings.
What happens if encoder speed is zero or negative?
The request fails with an invalid input error because division by zero is undefined and a negative processing rate has no useful meaning.
Does the estimate include uploading or quality control?
No. It estimates active frame processing time only. Add transfer, muxing, verification, upload, and review time separately when planning a delivery.
Can I use an average encoder speed?
Yes, but a conservative sustained speed from a representative encode is safer for deadlines because scene complexity and system load can make throughput vary.
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/render-time-estimate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"duration_seconds":120,"width_px":1920,"height_px":1080,"frame_rate_fps":30,"encoder_speed_fps":60}'const res = await fetch("https://api.kit.forhosting.com/video/render-time-estimate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"duration_seconds": 120,
"width_px": 1920,
"height_px": 1080,
"frame_rate_fps": 30,
"encoder_speed_fps": 60
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/video/render-time-estimate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"duration_seconds": 120,
"width_px": 1920,
"height_px": 1080,
"frame_rate_fps": 30,
"encoder_speed_fps": 60
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/video/render-time-estimate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"duration_seconds":120,"width_px":1920,"height_px":1080,"frame_rate_fps":30,"encoder_speed_fps":60}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"duration_seconds":120,"width_px":1920,"height_px":1080,"frame_rate_fps":30,"encoder_speed_fps":60}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/video/render-time-estimate", 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_seconds": 120,
"width_px": 1920,
"height_px": 1080,
"frame_rate_fps": 30,
"encoder_speed_fps": 60
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "video.render_time_estimate",
"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. |